bool Revelation(UnitCommander commander, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (commander.UnitCalculation.Unit.Energy < 25 || !commander.AbilityOffCooldown(Abilities.EFFECT_ORACLEREVELATION, frame, SharkyOptions.FramesPerSecond, SharkyUnitData) || commander.UnitCalculation.Unit.BuffIds.Contains((uint)Buffs.ORACLEWEAPON))
{
return(false);
}
var cloackedPosition = CloakedInvader(commander);
if (cloackedPosition != null)
{
action = commander.Order(frame, Abilities.EFFECT_ORACLEREVELATION, cloackedPosition);
return(true);
}
if (commander.UnitCalculation.NearbyEnemies.Any(e => e.Unit.BuffIds.Contains((uint)Buffs.ORACLEREVELATION)))
{
return(false); // TODO: unless a unit is invisible
}
var revelationLocation = GetBestRevelationLocation(commander);
if (revelationLocation != null)
{
action = commander.Order(frame, Abilities.EFFECT_ORACLEREVELATION, revelationLocation);
return(true);
}
return(false);
}
protected override bool OffensiveAbility(UnitCommander commander, Point2D target, Point2D defensivePoint, Point2D groupCenter, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (commander.AbilityOffCooldown(Abilities.EFFECT_VOIDRAYPRISMATICALIGNMENT, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
if (commander.UnitCalculation.Unit.Orders.Any(o => o.AbilityId == (uint)Abilities.ATTACK || o.AbilityId == (uint)Abilities.ATTACK_ATTACK))
{
foreach (var tag in commander.UnitCalculation.Unit.Orders.Select(o => o.TargetUnitTag))
{
UnitCalculation unit;
if (ActiveUnitData.EnemyUnits.TryGetValue(tag, out unit))
{
if (unit.Attributes.Contains(Attribute.Armored))
{
if (commander.UnitCalculation.EnemiesInRange.Where(e => e.Attributes.Contains(Attribute.Armored)).Sum(e => e.Unit.Health) > 200)
{
action = commander.Order(frame, Abilities.EFFECT_VOIDRAYPRISMATICALIGNMENT);
return(true);
}
}
}
}
}
}
return(false);
}
protected override bool PreOffenseOrder(UnitCommander commander, Point2D target, Point2D defensivePoint, Point2D groupCenter, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (commander.AbilityOffCooldown(Abilities.EFFECT_ADEPTPHASESHIFT, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
action = commander.Order(frame, Abilities.EFFECT_ADEPTPHASESHIFT, target);
return(true);
}
return(false);
}
bool TimeWarp(UnitCommander commander, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (commander.UnitCalculation.Unit.Orders.Any(o => o.AbilityId == (uint)Abilities.EFFECT_TIMEWARP))
{
return(true);
}
if (commander.UnitCalculation.Unit.Energy < 100 || !commander.AbilityOffCooldown(Abilities.EFFECT_TIMEWARP, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
return(false);
}
var point = GetTimeWarpLocation(commander);
if (point == null)
{
return(false);
}
action = commander.Order(frame, Abilities.EFFECT_TIMEWARP, point);
return(true);
}
protected override bool AvoidDamage(UnitCommander commander, Point2D target, Point2D defensivePoint, int frame, out List <SC2APIProtocol.Action> action) // TODO: use unit speed to dynamically adjust AvoidDamageDistance
{
action = null;
var blinkReady = SharkyUnitData.ResearchedUpgrades.Contains((uint)Upgrades.BLINKTECH) && commander.AbilityOffCooldown(Abilities.EFFECT_BLINK_STALKER, frame, SharkyOptions.FramesPerSecond, SharkyUnitData);
if (blinkReady && commander.UnitCalculation.Unit.Shield < 10)
{
var attacks = new List <UnitCalculation>();
foreach (var enemyAttack in commander.UnitCalculation.NearbyEnemies)
{
if (DamageService.CanDamage(enemyAttack, commander.UnitCalculation) && InRange(commander.UnitCalculation.Position, enemyAttack.Position, UnitDataService.GetRange(enemyAttack.Unit) + commander.UnitCalculation.Unit.Radius + enemyAttack.Unit.Radius + AvoidDamageDistance))
{
attacks.Add(enemyAttack);
}
}
if (attacks.Count > 0)
{
var attack = attacks.OrderBy(e => (e.Range * e.Range) - Vector2.DistanceSquared(commander.UnitCalculation.Position, e.Position)).FirstOrDefault(); // enemies that are closest to being outranged
var range = UnitDataService.GetRange(attack.Unit);
if (attack.Range > range)
{
range = attack.Range;
}
var avoidPoint = GetGroundAvoidPoint(commander, commander.UnitCalculation.Unit.Pos, attack.Unit.Pos, target, defensivePoint, attack.Range + attack.Unit.Radius + commander.UnitCalculation.Unit.Radius + AvoidDamageDistance);
action = commander.Order(frame, Abilities.EFFECT_BLINK_STALKER, avoidPoint);
return(true);
}
if (MaintainRange(commander, frame, out action))
{
return(true);
}
return(false);
}
return(base.AvoidDamage(commander, target, defensivePoint, frame, out action));
}
protected override bool AvoidTargettedDamage(UnitCommander commander, Point2D target, Point2D defensivePoint, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
var blinkReady = SharkyUnitData.ResearchedUpgrades.Contains((uint)Upgrades.BLINKTECH) && commander.AbilityOffCooldown(Abilities.EFFECT_BLINK_STALKER, frame, SharkyOptions.FramesPerSecond, SharkyUnitData);
if (blinkReady)
{
var attack = commander.UnitCalculation.Attackers.OrderBy(e => (e.Range * e.Range) - Vector2.DistanceSquared(commander.UnitCalculation.Position, e.Position)).FirstOrDefault();
if (attack != null)
{
var avoidPoint = GetGroundAvoidPoint(commander, commander.UnitCalculation.Unit.Pos, attack.Unit.Pos, target, defensivePoint, attack.Range + attack.Unit.Radius + commander.UnitCalculation.Unit.Radius + AvoidDamageDistance);
action = commander.Order(frame, Abilities.EFFECT_BLINK_STALKER, avoidPoint);
return(true);
}
return(false);
}
return(base.AvoidTargettedDamage(commander, target, defensivePoint, frame, out action));
}
protected override bool AttackBestTargetInRange(UnitCommander commander, Point2D target, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (bestTarget != null)
{
if (commander.UnitCalculation.EnemiesInRange.Any(e => e.Unit.Tag == bestTarget.Unit.Tag) && bestTarget.Unit.DisplayType == DisplayType.Visible)
{
action = commander.Order(frame, Abilities.ATTACK, null, bestTarget.Unit.Tag);
return(true);
}
var blinkReady = SharkyUnitData.ResearchedUpgrades.Contains((uint)Upgrades.BLINKTECH) && commander.AbilityOffCooldown(Abilities.EFFECT_BLINK_STALKER, frame, SharkyOptions.FramesPerSecond, SharkyUnitData);
if (blinkReady)
{
action = commander.Order(frame, Abilities.EFFECT_BLINK_STALKER, new Point2D {
X = bestTarget.Unit.Pos.X, Y = bestTarget.Unit.Pos.Y
});
return(true);
}
}
return(false);
}
protected override bool OffensiveAbility(UnitCommander commander, Point2D target, Point2D defensivePoint, Point2D groupCenter, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (!commander.AbilityOffCooldown(Abilities.EFFECT_PURIFICATIONNOVA, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
return(false);
}
if (commander.UnitCalculation.NearbyAllies.Any(a => a.Unit.UnitType == (uint)UnitTypes.PROTOSS_DISRUPTORPHASED && Vector2.DistanceSquared(a.Position, commander.UnitCalculation.Position) < PurificationNovaRange * PurificationNovaRange))
{
return(false);
}
if (lastPurificationFrame >= frame - 5)
{
return(false);
}
var attacks = new List <UnitCalculation>();
var center = commander.UnitCalculation.Position;
foreach (var enemyAttack in commander.UnitCalculation.NearbyEnemies)
{
if (!enemyAttack.Unit.IsFlying && InRange(enemyAttack.Position, commander.UnitCalculation.Position, PurificationNovaRange + enemyAttack.Unit.Radius + commander.UnitCalculation.Unit.Radius)) // TODO: do actual pathing to see if the shot can make it there, if a wall is in the way it can't
{
attacks.Add(enemyAttack);
}
}
if (attacks.Count > 0)
{
var oneShotKills = attacks.OrderBy(a => GetPurificationNovaDamage(a.Unit, SharkyUnitData.UnitData[(UnitTypes)a.Unit.UnitType])).ThenByDescending(u => u.Dps);
if (oneShotKills.Count() > 0)
{
var bestAttack = GetBestAttack(commander.UnitCalculation, oneShotKills, attacks);
if (commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.WinAir)
{
var airAttackers = oneShotKills.Where(u => u.DamageAir);
if (airAttackers.Count() > 0)
{
var air = GetBestAttack(commander.UnitCalculation, airAttackers, attacks);
if (air != null)
{
bestAttack = air;
}
}
}
else if (commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.WinGround)
{
var groundAttackers = oneShotKills.Where(u => u.DamageGround);
if (groundAttackers.Count() > 0)
{
var ground = GetBestAttack(commander.UnitCalculation, groundAttackers, attacks);
if (ground != null)
{
bestAttack = ground;
}
}
}
else
{
if (oneShotKills.Count() > 0)
{
var any = GetBestAttack(commander.UnitCalculation, oneShotKills, attacks);
if (any != null)
{
bestAttack = any;
}
}
}
if (bestAttack != null)
{
action = commander.Order(frame, Abilities.EFFECT_PURIFICATIONNOVA, bestAttack);
lastPurificationFrame = frame;
return(true);
}
}
}
return(false);
}
protected override bool OffensiveAbility(UnitCommander commander, Point2D target, Point2D defensivePoint, Point2D groupCenter, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (commander.UnitCalculation.Unit.Orders.Any(o => o.AbilityId == (uint)Abilities.EFFECT_KD8CHARGE))
{
return(true);
}
if (commander.UnitCalculation.NearbyAllies.Any(a => a.Unit.UnitType == (uint)UnitTypes.TERRAN_KD8CHARGE))
{
return(false);
} // don't spam them all at once
if (bestTarget != null && bestTarget.Unit.Tag != commander.UnitCalculation.Unit.Tag && bestTarget.FrameLastSeen == frame && !bestTarget.Attributes.Contains(Attribute.Structure) && commander.AbilityOffCooldown(Abilities.EFFECT_KD8CHARGE, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
var distanceSqaured = Vector2.DistanceSquared(commander.UnitCalculation.Position, bestTarget.Position); // TODO: use unit velocity to predict where to place the charge and check if in range of that
if (distanceSqaured <= 100)
{
var enemyPosition = new Point2D {
X = bestTarget.Unit.Pos.X, Y = bestTarget.Unit.Pos.Y
};
if (bestTarget.Velocity > 0)
{
var futurePosition = bestTarget.Position + (bestTarget.AverageVector * (bestTarget.AverageVelocity * SharkyOptions.FramesPerSecond));
if (Vector2.DistanceSquared(commander.UnitCalculation.Position, futurePosition) < Kd8Charge * Kd8Charge)
{
var interceptionPoint = new Point2D {
X = futurePosition.X, Y = futurePosition.Y
};
action = commander.Order(frame, Abilities.EFFECT_KD8CHARGE, interceptionPoint);
return(true);
}
}
else if (distanceSqaured < Kd8Charge * Kd8Charge)
{
var point = new Point2D {
X = bestTarget.Position.X, Y = bestTarget.Position.Y
};
action = commander.Order(frame, Abilities.EFFECT_KD8CHARGE, point);
return(true);
}
}
}
return(false);
}
protected override bool OffensiveAbility(UnitCommander commander, Point2D target, Point2D defensivePoint, Point2D groupCenter, UnitCalculation bestTarget, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (bestTarget != null && SharkyUnitData.ResearchedUpgrades.Contains((uint)Upgrades.DARKTEMPLARBLINKUPGRADE) && commander.AbilityOffCooldown(Abilities.EFFECT_SHADOWSTRIDE, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
var distanceSqaured = Vector2.DistanceSquared(commander.UnitCalculation.Position, bestTarget.Position);
if (distanceSqaured <= ShadowStrikeRange * ShadowStrikeRange && distanceSqaured > 9)
{
var x = bestTarget.Unit.Radius * Math.Cos(bestTarget.Unit.Facing);
var y = bestTarget.Unit.Radius * Math.Sin(bestTarget.Unit.Facing);
var blinkPoint = new Point2D {
X = bestTarget.Unit.Pos.X + (float)x, Y = bestTarget.Unit.Pos.Y - (float)y
};
action = commander.Order(frame, Abilities.EFFECT_SHADOWSTRIDE, blinkPoint);
return(true);
}
}
return(false);
}
bool Storm(UnitCommander commander, int frame, out List <SC2APIProtocol.Action> action)
{
action = null;
if (!commander.AbilityOffCooldown(Abilities.EFFECT_PSISTORM, frame, SharkyOptions.FramesPerSecond, SharkyUnitData))
{
return(true); // don't do anything until it storms
}
if (commander.UnitCalculation.Unit.Energy < 75 || !SharkyUnitData.ResearchedUpgrades.Contains((uint)Upgrades.PSISTORMTECH))
{
return(false);
}
if (lastStormFrame >= frame - 5)
{
return(false);
}
var enemies = commander.UnitCalculation.NearbyEnemies.Where(a => !a.Attributes.Contains(Attribute.Structure) && !a.Unit.BuffIds.Contains((uint)Buffs.PSISTORM)).OrderBy(u => u.Unit.Health);
if (enemies.Count() > 2)
{
var bestAttack = GetBestAttack(commander.UnitCalculation, enemies);
if (commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.WinAir)
{
var airAttackers = enemies.Where(u => u.DamageAir);
if (airAttackers.Count() > 0)
{
var air = GetBestAttack(commander.UnitCalculation, airAttackers);
if (air != null)
{
bestAttack = air;
}
}
}
else if (commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.WinGround)
{
var groundAttackers = enemies.Where(u => u.DamageGround);
if (groundAttackers.Count() > 0)
{
var ground = GetBestAttack(commander.UnitCalculation, groundAttackers);
if (ground != null)
{
bestAttack = ground;
}
}
}
else
{
if (enemies.Count() > 0)
{
var any = GetBestAttack(commander.UnitCalculation, enemies);
if (any != null)
{
bestAttack = any;
}
}
}
if (bestAttack != null)
{
action = commander.Order(frame, Abilities.EFFECT_PSISTORM, bestAttack);
lastStormFrame = frame;
return(true);
}
}
return(false);
}