private static bool EvaluateAdvancement( IHTNAgent npc, ScientistJunkpileContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, float directness) { if ((double)directness >= 0.200000002980232) { float sqrMagnitude1 = ((Vector3) ref dirCover).get_sqrMagnitude(); if ((double)sqrMagnitude1 > (double)((Vector3) ref dirDanger).get_sqrMagnitude() || (double)sqrMagnitude1 < 0.5) { return(false); } Vector3 vector3_1 = Vector3.op_Subtraction(option.Position, enemyInfo.LastKnownPosition); float sqrMagnitude2 = ((Vector3) ref vector3_1).get_sqrMagnitude(); float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float num = (float)((double)directness + ((double)allowedCoverRangeSqr - (double)sqrMagnitude1) / (double)allowedCoverRangeSqr + (double)option.Score + ((double)sqrMagnitude2 < (double)sqrMagnitude1 ? 1.0 : 0.0)); if ((double)num > (double)bestScore && (!AI.npc_cover_use_path_distance || npc == null || c.Domain.PathDistanceIsValid(enemyInfo.LastKnownPosition, option.Position, false))) { Vector3 vector3_2 = Vector3.op_Subtraction(option.Position, enemyInfo.LastKnownPosition); if ((double)((Vector3) ref vector3_2).get_sqrMagnitude() < (double)sqrMagnitude1) { num *= 0.9f; } bestScore = num; c.BestAdvanceCover = option; return(true); } } return(false); }
private bool TryFindCoverPoint(Vector3 playerToEnemyNormalised, out CoverPoint coverFound) { coverFound = null; var success = false; var coverPoints = CoverManager.GetCoverPointsSortedByDistanceTo(transform.position); if (coverPoints != null) { var playerPosition = GameManager.PlayerPosition; var myPosition = CachedTransform.position; for (int i = 0; !success && (i < coverPoints.Count); ++i) { L(coverPoints[i].name); if (IsSuitableCover(playerPosition, coverPoints[i], myPosition, playerToEnemyNormalised)) { success = true; coverFound = coverPoints[i]; } L("------------------"); } } return(success); }
Vector3 FindCoverAdvanced() //Finding the nearest reachable cover object { Vector3 initialPoint = transform.position; viablePoints = new List <CoverPoint>(); //------------ Find all cover objects within range for (int i = 0; i < coverObjects.Length; i++) { CoverObject cover = coverObjects[i]; NavMeshPath path = new NavMeshPath(); agent.CalculatePath(cover.transform.position, path); //If the cover is reachable if (agent.pathStatus == NavMeshPathStatus.PathComplete) { //If within range if (Vector3.Distance(transform.position, cover.transform.position) < AP * 2.0f) { //Find and add all furthest points int furthest = cover.FurthestSide(player.transform.position); for (int id = 0; id < cover.coverPoints.Length; id++) { CoverPoint point = cover.coverPoints[id]; if (cover.isTakenList[id] == false) { if (point.side == furthest) { if (CheckLineOfSight(cover.coverPoints[id].pos)) { viablePoints.Add(point); isShooting = true; } } } } } } } if (viablePoints.Count > 0) { if (currentCover != null) { currentCover.isTakenList[coverPointID] = false; } int randomPoint = Random.Range(0, viablePoints.Count); coverPointID = viablePoints[randomPoint].id; currentCover = viablePoints[randomPoint].parent; currentCover.isTakenList[coverPointID] = true; return(viablePoints[randomPoint].pos); } else { return(FindCoverSimple()); } }
private static bool EvaluateRetreat( IHTNAgent npc, ScientistJunkpileContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, ref float directness) { float sqrMagnitude = ((Vector3) ref dirCover).get_sqrMagnitude(); if ((double)directness <= -0.200000002980232) { float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float num = (float)((double)directness * -1.0 + ((double)allowedCoverRangeSqr - (double)sqrMagnitude) / (double)allowedCoverRangeSqr) + option.Score; if ((double)num > (double)bestScore) { bestScore = num; c.BestRetreatCover = option; return(true); } } return(false); }
// "In front of" here is to be taken relatively: the idea is that // if I have to get past the player to get to cover, that's not a // good cover. private bool IsCoverInFrontOfPlayer(Vector3 playerPosition, CoverPoint c, Vector3 playerToMe) { //TODO - make this condition stricter maybe? // or if 0f is fine, discard the normalization var isInFront = Vector3.Dot(playerToMe, (c.Position - playerPosition).normalized) > 0f; return(isInFront); }
public bool HasCheckedHideout(CoverPoint hideout) { for (int i = 0; i < this.CheckedHideoutPoints.Count; i++) { if (this.CheckedHideoutPoints[i].Hideout == hideout) { return(true); } } return(false); }
public bool HasCheckedHideout(CoverPoint hideout) { for (int index = 0; index < this.CheckedHideoutPoints.Count; ++index) { if (this.CheckedHideoutPoints[index].Hideout == hideout) { return(true); } } return(false); }
Vector3 FindCoverSimple() //Finding the nearest reachable cover object { Vector3 bestPoint = transform.position; CoverObject bestCover = null; float bestCoverDist = 100.0f; float bestPointDist = 0.0f; //------------ First find the nearest cover object ------------ for (int i = 0; i < coverObjects.Length; i++) { CoverObject cover = coverObjects[i]; NavMeshPath path = new NavMeshPath(); agent.CalculatePath(cover.transform.position, path); //If the cover is within reachable distance if (agent.pathStatus == NavMeshPathStatus.PathComplete) { float dist = Vector3.Distance(transform.position, cover.transform.position); if (dist < bestCoverDist) //If the distance is the best distance { bestCoverDist = dist; bestCover = cover; } } } //------------- Then find the furthest cover point on the cover object from the enemy --------- if (bestCover != null) { int bestPointID = -1; for (int id = 0; id < bestCover.coverPoints.Length; id++) { CoverPoint coverPoint = bestCover.coverPoints[id]; float dist = Vector3.Distance(coverPoint.pos, player.transform.position); if (dist > bestPointDist && bestCover.coverPoints[id].isTaken == false) { currentCover = bestCover; bestPointID = coverPoint.id; coverPointID = coverPoint.id; bestCover.coverPoints[id].isTaken = true; currentCover.coverPoints[coverPointID].isTaken = true; bestPointDist = dist; bestPoint = coverPoint.pos; } } } return(bestPoint); }
private void Awake() { Quaternion initialRotation = transform.rotation; transform.rotation = Quaternion.identity; render = GetComponent <MeshRenderer>(); extent = render.bounds.extents; transform.rotation = initialRotation; //Calculate number of cover points available depthPoints = Mathf.CeilToInt(extent.x * 2.0f); //Front & Back widthPoints = Mathf.CeilToInt(extent.z * 2.0f); //Left & Right //Calculate if this is full-cover or not (half-cover) if (Mathf.CeilToInt(extent.y * 2.0f) >= 2) { isFullCover = true; } else { isFullCover = false; } frontPoints = new CoverPoint[depthPoints]; backPoints = new CoverPoint[depthPoints]; leftPoints = new CoverPoint[widthPoints]; rightPoints = new CoverPoint[widthPoints]; frontGizmos = new Vector3[depthPoints]; backGizmos = new Vector3[depthPoints]; leftGizmos = new Vector3[widthPoints]; rightGizmos = new Vector3[widthPoints]; coverPoints = new CoverPoint[(depthPoints * 2) + (widthPoints * 2)]; isTakenList = new bool[(depthPoints * 2) + (widthPoints * 2)]; //Set all coverpoint IDs, and also parent to this for (int c = 0; c < coverPoints.Length; c++) { coverPoints[c].pos = transform.position; coverPoints[c].isTaken = false; coverPoints[c].side = 0; coverPoints[c].id = c; coverPoints[c].parent = this; } PositionCoverPoints(); }
/// <summary> /// Cause the agent to seek cover near the target location. /// </summary> /// <param name="_position">Location to seek cover near.</param> public void MoveToCoverNearPosition(Vector3 _position) { var cover_points = GameManager.scene.tactical_assessor.ClosestCoverPoints( _position, settings.cover_search_radius); if (cover_points.Count == 0) { return; } CoverPoint target_point = cover_points[0]; nav.destination = target_point.position; }
private bool DoesCoverHideMyAss(Vector3 playerPosition, CoverPoint c) { var playerToCover = (c.Position - playerPosition).normalized; var pcDotA = Vector3.Dot(playerToCover, c.wallNormalA); var pcDotB = Vector3.Dot(playerToCover, c.wallNormalB); var doesHide = pcDotA > pcDotB ? (pcDotA > 0f) : (pcDotB > 0f); if (log) { L(string.Format("DoesHide? {0}", doesHide)); } return(doesHide); }
public void ReserveCoverPoint(CoverPoint coverPoint) { if (coverPoint == null || coverPoint.IsValidFor(this.Body)) { if (this.ReservedCoverPoint != null && this.ReservedCoverPoint != coverPoint) { this.ReservedCoverPoint.ReservedFor = null; } this.ReservedCoverPoint = coverPoint; if (this.ReservedCoverPoint != null) { this.ReservedCoverPoint.ReservedFor = this.Body; this.ReservedCoverTime = Time.time; } } }
public void ReserveCoverPoint(CoverPoint coverPoint) { if (coverPoint != null && !coverPoint.IsValidFor((BaseEntity)this.Body)) { return; } if (this.ReservedCoverPoint != null && this.ReservedCoverPoint != coverPoint) { this.ReservedCoverPoint.ReservedFor = (BaseEntity)null; } this.ReservedCoverPoint = coverPoint; if (this.ReservedCoverPoint == null) { return; } this.ReservedCoverPoint.ReservedFor = (BaseEntity)this.Body; this.ReservedCoverTime = Time.get_time(); }
/// <summary> /// Moves the squaddies to cover near the context indicator position. /// A working list is used to prevent squaddies being issued the same cover points. /// </summary> /// <param name="_context"></param> void SquadCoverCommand(CurrentContext _context) { order_target_bobber.SetTarget(_context.indicator_position); // Working list to prevent squaddies being issued the same cover. List <CoverPoint> allocated_points = new List <CoverPoint>(); foreach (SquaddieAI squaddie in squad_sense.squaddies) { var cover_points = GameManager.scene.tactical_assessor.ClosestCoverPoints( _context.indicator_position, squaddie.settings.cover_search_radius); if (cover_points.Count <= 0) { break; } CoverPoint target_point = null; foreach (CoverPoint cover_point in cover_points) { if (target_point != null) { break; } if (allocated_points.Contains(cover_point)) { continue; } target_point = cover_point; } if (target_point == null) { break; } allocated_points.Add(target_point); squaddie.IssueMoveCommand(target_point.position); } }
public void Update(CoverPoint retreat, CoverPoint flank, CoverPoint advance) { Vector3 position; this.Retreat.ReservedCoverPoint = retreat; this.Flank.ReservedCoverPoint = flank; this.Advance.ReservedCoverPoint = advance; this.Closest.ReservedCoverPoint = null; float single = Single.MaxValue; if (retreat != null) { position = retreat.Position - this.Retreat.Human.ServerPosition; float single1 = position.sqrMagnitude; if (single1 < single) { this.Closest.ReservedCoverPoint = retreat; single = single1; } } if (flank != null) { position = flank.Position - this.Flank.Human.ServerPosition; float single2 = position.sqrMagnitude; if (single2 < single) { this.Closest.ReservedCoverPoint = flank; single = single2; } } if (advance != null) { position = advance.Position - this.Advance.Human.ServerPosition; float single3 = position.sqrMagnitude; if (single3 < single) { this.Closest.ReservedCoverPoint = advance; single = single3; } } }
/// <summary> /// Performs a RaycastAll based on the ray pack's configuration and records the details of any hits. /// </summary> /// <param name="_ray_pack">The raycast configuration.</param> void EnumerateCoverPoints(RaycastPackage _ray_pack) { var hits = Physics.RaycastAll(_ray_pack.from, _ray_pack.direction, _ray_pack.length, hit_layers); foreach (var hit in hits) { NavMeshHit nav_hit; if (NavMesh.SamplePosition(hit.point + hit.normal, out nav_hit, nav_search_radius, NavMesh.AllAreas)) { CoverPoint cover_point = new CoverPoint(cover_point_settings); cover_point.position = hit.point + hit.normal; cover_point.normal = hit.normal; cover_points.Add(cover_point); } } }
public void Update(CoverPoint retreat, CoverPoint flank, CoverPoint advance) { this.Retreat.ReservedCoverPoint = retreat; this.Flank.ReservedCoverPoint = flank; this.Advance.ReservedCoverPoint = advance; this.Closest.ReservedCoverPoint = (CoverPoint)null; float num = float.MaxValue; if (retreat != null) { Vector3 vector3 = Vector3.op_Subtraction(retreat.Position, this.Retreat.Human.ServerPosition); float sqrMagnitude = ((Vector3) ref vector3).get_sqrMagnitude(); if ((double)sqrMagnitude < (double)num) { this.Closest.ReservedCoverPoint = retreat; num = sqrMagnitude; } } if (flank != null) { Vector3 vector3 = Vector3.op_Subtraction(flank.Position, this.Flank.Human.ServerPosition); float sqrMagnitude = ((Vector3) ref vector3).get_sqrMagnitude(); if ((double)sqrMagnitude < (double)num) { this.Closest.ReservedCoverPoint = flank; num = sqrMagnitude; } } if (advance == null) { return; } Vector3 vector3_1 = Vector3.op_Subtraction(advance.Position, this.Advance.Human.ServerPosition); if ((double)((Vector3) ref vector3_1).get_sqrMagnitude() >= (double)num) { return; } this.Closest.ReservedCoverPoint = advance; }
private static bool EvaluateFlanking( IHTNAgent npc, ScientistAStarContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, float directness) { if ((double)directness > -0.200000002980232 && (double)directness < 0.200000002980232) { float sqrMagnitude = ((Vector3) ref dirCover).get_sqrMagnitude(); float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float num = (float)((0.200000002980232 - (double)Mathf.Abs(directness)) / 0.200000002980232 + ((double)allowedCoverRangeSqr - (double)sqrMagnitude) / (double)allowedCoverRangeSqr) + option.Score; if ((double)num > (double)bestScore && (!AI.npc_cover_use_path_distance || npc == null || c.Domain.PathDistanceIsValid(enemyInfo.LastKnownPosition, option.Position, false))) { bestScore = 0.1f - Mathf.Abs(num); c.BestFlankCover = option; return(true); } } return(false); }
private void updateSubStages() { findTargetLocationToFire(); switch (currentCombatSubStage) { case CombatSubStages.InCover: //Debug.Log("In Cover"); m_selfAgent.lookAtTarget(); if (currentCoverPoint.isSafeFromTarget() && currentCoverPoint.canFireToTarget(fireRangeDistance)) { switch (currentCoverShootingSubStage) { case CoverShootingSubStages.Cover: m_selfAgent.aimWeapon(); currentCoverShootingSubStage = CoverShootingSubStages.Peek; shotsFromCover = (int)(Random.value * 5); //Debug.Log(shotsFromCover); break; case CoverShootingSubStages.Peek: m_selfAgent.weaponFireForAI(); currentCoverShootingSubStage = CoverShootingSubStages.Shoot; setStepIntervalSize(0.3f); break; case CoverShootingSubStages.Shoot: currentShotsFromCover++; if (currentShotsFromCover > shotsFromCover) { currentCoverShootingSubStage = CoverShootingSubStages.Cover; currentShotsFromCover = 0; m_selfAgent.stopAiming(); setStepIntervalSize(0.8f); } else { currentCoverShootingSubStage = CoverShootingSubStages.Peek; } break; } } else { //Debug.Log("Cover is not safe or cannot fire to target"); currentCombatSubStage = CombatSubStages.LookingForCover; setStepIntervalSize(1); } break; case CombatSubStages.LookingForCover: //Debug.Log("Looking for cover"); CoverPoint tempCurrentCoverPoint = closestCombatLocationAvaialbe(); if (tempCurrentCoverPoint != null) { if (currentCoverPoint) { //currentCoverPoint.stPointOccupentsName(""); currentCoverPoint.setOccupent(null); } currentCoverPoint = tempCurrentCoverPoint; m_navMeshAgent.SetDestination(currentCoverPoint.getPosition()); currentCombatSubStage = CombatSubStages.MovingToCover; // Get up and move m_selfAgent.toggleHide(); m_selfAgent.aimWeapon(); } break; case CombatSubStages.MovingToCover: //Debug.Log("Moving to cover"); if (!m_navMeshAgent.pathPending && m_navMeshAgent.remainingDistance > 1) { if (m_navMeshAgent.remainingDistance > 3 && Vector3.Distance(m_selfAgent.getCurrentPosition(), opponent.getCurrentPosition()) > fireRangeDistance) { m_enableRun = true; m_selfAgent.stopAiming(); } else { if (Vector3.Distance(m_selfAgent.getCurrentPosition(), opponent.getCurrentPosition()) < fireRangeDistance) { m_selfAgent.aimWeapon(); m_enableRun = false; m_selfAgent.weaponFireForAI(); } } } else { m_selfAgent.lookAtTarget(); currentCombatSubStage = CombatSubStages.InCover; // Get down on cover m_selfAgent.toggleHide(); m_selfAgent.stopAiming(); setStepIntervalSize(0.8f); m_navMeshAgent.velocity = Vector3.zero; } break; } }
private bool IsSuitableCover(Vector3 playerPosition, CoverPoint c, Vector3 myPosition, Vector3 playerToMe) { return(IsCoverInFrontOfPlayer(playerPosition, c, playerToMe) && DoesCoverHideMyAss(playerPosition, c)); }
private CoverPoint closestCombatLocationAvaialbe() { float minimumDistanceToIdealCoverPoint = 999; float minimumDistanceToSafeCoverPoint = 999; float maximumDistanceToRiskyCoverPoint = 0; CoverPoint tempIDealCoverPoint = null; CoverPoint tempSafeCoverPoint = null; CoverPoint tempRiskyCoverPoint = null; foreach (CoverPoint point in coverPoints) { if (!point.isOccupied()) { point.setTargetToCover(opponent); if (point.isSafeFromTarget()) { // Find the safe cover point. if (minimumDistanceToSafeCoverPoint > point.distanceTo(opponent.getCurrentPosition())) { minimumDistanceToSafeCoverPoint = point.distanceTo(opponent.getCurrentPosition()); tempSafeCoverPoint = point; } // Find the ideal closest cover point. if (point.canFireToTarget(fireRangeDistance)) { if (minimumDistanceToIdealCoverPoint > point.distanceTo(m_selfAgent.getCurrentPosition())) { minimumDistanceToIdealCoverPoint = point.distanceTo(m_selfAgent.getCurrentPosition()); tempIDealCoverPoint = point; } } } else { // Find the safe cover point. float distanceFromRiskyPoint = point.distanceTo(opponent.getCurrentPosition()); if (maximumDistanceToRiskyCoverPoint < distanceFromRiskyPoint && distanceFromRiskyPoint < COVER_POINT_MIN_DISTANCE) { maximumDistanceToRiskyCoverPoint = point.distanceTo(opponent.getCurrentPosition()); tempRiskyCoverPoint = point; } } } } if (tempIDealCoverPoint != null) { //tempIDealCoverPoint.stPointOccupentsName(selfAgent.getName()); tempIDealCoverPoint.setOccupent(m_selfAgent); return(tempIDealCoverPoint); } else if (tempSafeCoverPoint != null && Vector2.Distance(opponent.getCurrentPosition(), tempSafeCoverPoint.transform.position) <= COVER_POINT_MIN_DISTANCE) { //tempSafeCoverPoint.stPointOccupentsName(selfAgent.getName()); tempSafeCoverPoint.setOccupent(m_selfAgent); return(tempSafeCoverPoint); } else if (tempRiskyCoverPoint != null) { return(tempRiskyCoverPoint); } return(null); }
private bool isCoverPointUsable(CoverPoint point) { return(point.isSafeFromTarget() && point.canFireToTarget(fireRangeDistance)); }
public void SetMovementGoal(MovementGoalType movementGoalType) { _movementGoalType = movementGoalType; if (movementGoalType == MovementGoalType.PLAYER_ROOM) { _roomOfInterest = _levelLoadingManager .RoomGraphManager .GetRoomContainingObject(_player); movementGoalType = MovementGoalType.ROOM; } switch (movementGoalType) { case MovementGoalType.FOOTSTEP: SetMovementGoal(_footStepFactory.FirstFootStep, null); Task.current.Complete(true); break; case MovementGoalType.FOOTSTEP_PATH: SetMovementGoal(_footStepFactory.LatestFootStep, _footStepFactory.Path); Task.current.Complete(true); break; case MovementGoalType.HEARD_NOISE: SetMovementGoal(_heardNoise); Task.current.Complete(true); break; case MovementGoalType.LOCKER: { if (_lockerManager.CurrentLocker != null) { SetMovementGoal(_lockerManager.CurrentLocker.gameObject.transform.parent.transform.GetChild(1).transform.gameObject.GetComponent <DestinationSearch>()); } Task.current.Complete(true); break; } case MovementGoalType.TARGET: SetMovementGoal(_target); Task.current.Complete(true); break; case MovementGoalType.PLAYER: SetMovementGoal(_player); Task.current.Complete(true); break; case MovementGoalType.DEAD_GUARD: SetMovementGoal(_deadGuardController); Task.current.Complete(true); break; case MovementGoalType.COVER_TARGET: case MovementGoalType.COVER_SELF: { if (Task.current.isStarting) { _coverPointFound = false; _coverPoint = null; List <PathObjectPair> pops = new List <PathObjectPair> (); List <Vector2> blockedCoordinates = GetBlockedCoordinates(); AsyncListOperation <CoverPoint> listOperation = new AsyncListOperation <CoverPoint>( _coverPoints, ( CoverPoint coverPoint, System.Action callbackOperation ) => { _pathManager.RequestTask( this, coverPoint, ( PathObjectPair pop ) => { pops.Add(pop); callbackOperation(); }, blockedCoordinates ); }, () => { pops.Sort((PathObjectPair a, PathObjectPair b) => { float distanceA = a.GetPathLength(); float distanceB = b.GetPathLength(); if (distanceA == 0) { distanceA = 999999; } if (distanceB == 0) { distanceB = 999999; } return((int)distanceA - (int)distanceB); }); GameObject coverFrom = gameObject; if (movementGoalType == MovementGoalType.COVER_TARGET) { coverFrom = _target.gameObject; } foreach (var pop in pops) { RaycastHit2D hit = _mapHelper.Probe( coverFrom, ((MonoBehaviour)pop.GetObject2()).gameObject, new string[] { "CeilingLayer", "WallLayer" } ); if (hit.collider != null) { _coverPoint = (CoverPoint)pop.GetObject2(); SetMovementGoal(_coverPoint); _preComputedPathToMovementGoal = pop.GetPath(); _coverPointFound = true; break; } } } ); listOperation.RunParallel(); } else if (_coverPointFound) { Task.current.Complete(true); } // _coverPoints.Sort( (CoverPoint a, CoverPoint b) => // { // float distanceA = (a.transform.position - transform.position).magnitude; // float distanceB = (b.transform.position - transform.position).magnitude; // return (int) distanceA - (int) distanceB; // }); // GameObject coverFrom = gameObject; // if( movementGoalType == MovementGoalType.COVER_TARGET ) // { // coverFrom = _target.gameObject; // } // foreach( CoverPoint coverPoint in _coverPoints ) // { // RaycastHit2D hit = _mapHelper.Probe( // coverFrom, // coverPoint.gameObject, // new string[] {"CeilingLayer", "WallLayer"} // ); // if( hit.collider != null ) // { // _coverPoint = coverPoint; // break; // } // } // // if no cover was found we should probably be more aggressive. // SetMovementGoal(_coverPoint); // Task.current.Complete(true); }; break; case MovementGoalType.ROOM: { if (Task.current.isStarting) { PerformRoomExitPathFinding(); } else if (_roomExitFindingComplete) { SetMovementGoal( _pathObjectPairsForRoomRoomExitFinding[0].GetObject2(), _pathObjectPairsForRoomRoomExitFinding[0].GetPath() ); Task.current.Complete(true); } }; break; } }
private static bool EvaluateFlanking(IHTNAgent npc, ScientistAStarContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, float directness) { if (directness > -0.2f && directness < 0.2f) { float single = dirCover.sqrMagnitude; float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float single1 = (0.2f - Mathf.Abs(directness)) / 0.2f + (allowedCoverRangeSqr - single) / allowedCoverRangeSqr + option.Score; if (single1 > bestScore) { if (ConVar.AI.npc_cover_use_path_distance && npc != null && !c.Domain.PathDistanceIsValid(enemyInfo.LastKnownPosition, option.Position, false)) { return(false); } bestScore = 0.1f - Mathf.Abs(single1); c.BestFlankCover = option; return(true); } } return(false); }
private static bool EvaluateRetreat(IHTNAgent npc, ScientistAStarContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, ref float directness) { float single = dirCover.sqrMagnitude; if (directness <= -0.2f) { float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float single1 = directness * -1f + (allowedCoverRangeSqr - single) / allowedCoverRangeSqr + option.Score; if (single1 > bestScore) { bestScore = single1; c.BestRetreatCover = option; return(true); } } return(false); }
// Update is called once per frame void Update() { switch (status) { case Status.Find: float takeActionValue; takeActionValue = Random.Range(0.0f, 1.0f); if (takeActionValue <= takeCloseCoverRate) { status = Status.Hide; } else { takeActionValue = Random.Range(0.0f, 1.0f); } if (takeActionValue <= directAttackRate) { status = Status.Shoot; } break; case Status.Hide: CoverPoint closeistPoint = coverPoints[0]; foreach (var point in coverPoints) { if ((point.position - player.transform.position).magnitude < closeistPoint.GetMagnitudeWith(player.transform.position)) { closeistPoint = point; } } Vector3 pos = closeistPoint.position; float zOffset = player.transform.position.z > agentObject.transform.position.z ? -coverZDistence : coverZDistence; agent.destination = new Vector3(pos.x, pos.y, pos.z + zOffset); if (agent.remainingDistance < distanceFromCoverPoint) { curGunfireCount = minGunFireCount; status = Status.Shoot; } break; case Status.Shoot: curFireDelay += Time.deltaTime; agent.destination = player.transform.position; if (curFireDelay >= fireDelay) { objPool.CreateBullet(1, agent.transform.position, (player.transform.position - agent.transform.position).normalized, "EnemyBullet"); Debug.Log("Fire!!"); curGunfireCount--; curFireDelay = 0; } if (curGunfireCount <= 0) { status = Status.Find; } break; } SyncSpriteToAgent(); }
private static bool EvaluateAdvancement(IHTNAgent npc, ScientistAStarContext c, ref float bestScore, ref BaseNpcMemory.EnemyPlayerInfo enemyInfo, CoverPoint option, Vector3 dirCover, Vector3 dirDanger, float directness) { if (directness >= 0.2f) { float single = dirCover.sqrMagnitude; if (single > dirDanger.sqrMagnitude || single < 0.5f) { return(false); } float position = (option.Position - enemyInfo.LastKnownPosition).sqrMagnitude; float allowedCoverRangeSqr = c.Domain.GetAllowedCoverRangeSqr(); float single1 = directness + (allowedCoverRangeSqr - single) / allowedCoverRangeSqr + option.Score + (position < single ? 1f : 0f); if (single1 > bestScore) { if (ConVar.AI.npc_cover_use_path_distance && npc != null && !c.Domain.PathDistanceIsValid(enemyInfo.LastKnownPosition, option.Position, false)) { return(false); } if ((option.Position - enemyInfo.LastKnownPosition).sqrMagnitude < single) { single1 *= 0.9f; } bestScore = single1; c.BestAdvanceCover = option; return(true); } } return(false); }