private static List <TerrainDisparity> CalculateAllCoverDisparities(
HumanoidVantage strategizer,
List <HumanoidVantage> enemyVantages,
Vector3 location
)
{
List <TerrainDisparity> totalDisparity = new List <TerrainDisparity>();
Projectile stratWeaponThreat = strategizer.GetWeaponThreat();
Vector3 standingAtEnd = location.AddY(strategizer.GetStandingHeight());
Vector3 kneelingAtEnd = location.AddY(strategizer.GetKneelingHeight());
Vector3 layingAtEnd = location.AddY(strategizer.GetLayingHeight());
foreach (HumanoidVantage enemyVantage in enemyVantages)
{
Projectile enemyWeaponThreat = enemyVantage.GetWeaponThreat();
Vector3 enemyStanding = enemyVantage.GetStandingVantage();
Vector3 enemyKneeling = enemyVantage.GetKneelingVantage();
Vector3 enemyLaying = enemyVantage.GetLayingVantage();
TerrainDisparity topToTopDisp =
EnvironmentPhysics.CalculateTerrainDisparityBetween(
stratWeaponThreat,
enemyWeaponThreat,
standingAtEnd,
enemyStanding
);
totalDisparity.Add(topToTopDisp);
}
return(totalDisparity);
}
public override CostResult GetAdditionalCostAt(Vector3 location)
{
var enemyVantages = targeter.GetAllKnownVantages();
TerrainDisparity totalCoverDisparityPenalty =
CostCalculatorHelper.CalculateByMostVisibleToTarget(
strategizer.InfoGetVantageData(),
enemyVantages,
location
);
CostResult result = new CostResult(
new Tuple <float, float, TerrainDisparity>(
coverDisparityData.coverDisparityPenalty,
coverDisparityData.exposedPenalty,
totalCoverDisparityPenalty
),
0,
new Tuple <bool, float>(
Grid.GetMapNodeAt(location).IsCoverNode(),
coverDisparityData.notCoverPenalty
)
);
return(result);
}
public CostResult(
Tuple <float, float, TerrainDisparity> disparityPenalty,
int terrainPenalty,
Tuple <bool, float> coverData
)
{
terrainDisparity = disparityPenalty.Item3;
coverDisparityMultiplier = disparityPenalty.Item1;
exposedPenalty = disparityPenalty.Item2;
heightPenalty = terrainPenalty;
isCover = coverData.Item1;
notCoverPenalty = coverData.Item2;
}
public virtual void EffectOnSeeEnemy(HumanoidModel enemy)
{
Vector3 thisVantagePoint = GetVantagePoint();
Projectile thisWeapon = currentWeapon.GetProjectile();
Vector3 enemyVantagePoint = enemy.GetVantagePoint();
Projectile enemyWeapon = enemy.currentWeapon.GetProjectile();
TerrainDisparity terrainDisparity = EnvironmentPhysics.CalculateTerrainDisparityBetween(
thisWeapon, enemyWeapon, thisVantagePoint, enemyVantagePoint
);
float coverDisparity = terrainDisparity.visibleToTarget - terrainDisparity.visibleToObserver;
// the following line prevents advantageous cover from decreasing stress
coverDisparity = coverDisparity < 0 ? 0 : coverDisparity;
baseStressManager.PendSightStress(coverDisparity, enemy);
}
public static TerrainDisparity CalculateTerrainDisparityBetween(
Projectile heuristicOfObserver,
Projectile heuristicOfTarget,
Vector3 observerVantage,
Vector3 targetVantage
)
{
Tuple <Projectile, Projectile, Vector3, Vector3> data =
new Tuple <Projectile, Projectile, Vector3, Vector3>(
heuristicOfObserver,
heuristicOfTarget,
observerVantage,
targetVantage
);
if (instance.calculateTerrainDisparityBetweenCache.ContainsKey(data))
{
return(instance.calculateTerrainDisparityBetweenCache[data]);
}
TerrainDisparity result = new TerrainDisparity();
VisiblePortionResult observerResult =
CalculateVisiblePortion(heuristicOfObserver, observerVantage, targetVantage);
VisiblePortionResult targetResult =
CalculateVisiblePortion(heuristicOfTarget, targetVantage, observerVantage);
result.visibleToObserver = observerResult.visible;
result.targetHeight = observerResult.heightOfTarget;
result.visibleToTarget = targetResult.visible;
result.observerHeight = targetResult.heightOfTarget;
instance.calculateTerrainDisparityBetweenCache[data] =
result;
if (instance.calculateTerrainDisparityBetweenCache.Count
> CALCULATE_TERRAIN_DISPARITY_BETWEEN_CACHE_MAX_SIZE)
{
instance.calculateTerrainDisparityBetweenCache.PopFirst();
}
return(result);
}
/*
* Need to cache the result of this
*/
public override CostResult GetAdditionalCostAt(Vector3 start, Vector3 end)
{
var enemyVantages = targeter.GetAllKnownVantages();
float heightDifference = end.y - start.y;
float heightPenalty = CostCalculatorHelper.CalculateHeightPenalty(
heightDifference,
heightData.goingUpPenalty,
heightData.climbUpThreshold,
heightData.climbUpThreshold,
heightData.goingDownPenalty,
heightData.climbDownPenalty,
heightData.climbDownThreshold
);
TerrainDisparity totalCoverDisparityPenalty = CostCalculatorHelper.CalculateByMostVisibleToTarget(
strategizer.InfoGetVantageData(),
enemyVantages,
end/*,
* coverDisparityData.exposedPenalty,
* coverDisparityData.coverDisparityPenalty*/
);
CostResult result = new CostResult(
new Tuple <float, float, TerrainDisparity> (
coverDisparityData.coverDisparityPenalty,
coverDisparityData.exposedPenalty,
totalCoverDisparityPenalty
)
, (int)heightPenalty
, new Tuple <bool, float>(
Grid.GetMapNodeAt(end).IsCoverNode(),
coverDisparityData.notCoverPenalty
)
);
//DrawGizmo.AddGizmo(Color.grey, "" + result.CompletelyHidden(), end);
return(result);
}
