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);
}
