public bool FleeFromAlliedDisruptors(Agent agent)
{
if (agent.Unit.IsFlying)
{
return(false);
}
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 4;
bool flee = false;
foreach (Agent disruptor in PhasedDisruptorTask.Task.Units)
{
if (!PhasedDisruptorTask.Task.PhasedFrame.ContainsKey(disruptor.Unit.Tag) ||
Tyr.Bot.Frame - PhasedDisruptorTask.Task.PhasedFrame[disruptor.Unit.Tag] < 23)
{
continue;
}
if (agent.DistanceSq(disruptor) <= 3 * 3)
{
potential.From(disruptor.Unit.Pos);
flee = true;
}
}
if (!flee)
{
return(false);
}
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
public override void OnFrame(Tyr tyr)
{
int bases = 0;
foreach (Base b in tyr.BaseManager.Bases)
{
if (b.ResourceCenter != null)
{
bases++;
}
}
Point2D target;
Base defendBase = null;
if (bases >= 2)
{
target = tyr.BaseManager.NaturalDefensePos;
defendBase = tyr.BaseManager.Natural;
}
else
{
target = tyr.BaseManager.MainDefensePos;
defendBase = tyr.BaseManager.Main;
}
PotentialHelper potential = new PotentialHelper(target);
potential.Magnitude = 2;
potential.To(defendBase.BaseLocation.Pos);
target = potential.Get();
foreach (Agent queen in units)
{
if (queen.Unit.Energy >= 50)
{
Agent transfuseTarget = null;
foreach (Agent agent in tyr.UnitManager.Agents.Values)
{
if (agent.Unit.HealthMax - agent.Unit.Health >= 125 &&
agent.Unit.Tag != queen.Unit.Tag &&
queen.DistanceSq(agent) <= 8 * 8)
{
transfuseTarget = agent;
break;
}
}
if (transfuseTarget != null)
{
queen.Order(Abilities.TRANSFUSE, transfuseTarget.Unit.Tag);
continue;
}
}
if (queen.DistanceSq(target) >= 5 * 5)
{
queen.Order(Abilities.MOVE, target);
}
}
}
public override void OnFrame(Tyr tyr)
{
if (Stopped)
{
Clear();
return;
}
if (IdleLocation == null)
{
IdleLocation = tyr.MapAnalyzer.GetMainRamp();
}
Agent bunker = null;
foreach (Agent agent in tyr.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType == UnitTypes.BUNKER)
{
bunker = agent;
break;
}
}
if (bunker == null)
{
return;
}
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK_SIEGED &&
agent.DistanceSq(bunker.Unit.Pos) >= 4 * 4)
{
agent.Order(Abilities.UNSIEGE);
}
else if (agent.DistanceSq(IdleLocation) < 5 * 5)
{
if (agent.DistanceSq(tyr.MapAnalyzer.GetMainRamp()) < agent.DistanceSq(bunker))
{
agent.Order(Abilities.MOVE, SC2Util.To2D(tyr.MapAnalyzer.StartLocation));
}
else
{
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 1;
potential.From(IdleLocation, 2);
potential.To(bunker.Unit);
agent.Order(Abilities.MOVE, potential.Get());
}
}
else if (agent.DistanceSq(bunker.Unit.Pos) >= 4 * 4)
{
agent.Order(Abilities.MOVE, SC2Util.To2D(bunker.Unit.Pos));
}
else if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK)
{
agent.Order(Abilities.SIEGE);
}
}
}
public override bool DetermineAction(Agent agent, Point2D target)
{
if (agent.Unit.UnitType != UnitTypes.CARRIER)
{
return(false);
}
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 4;
bool flee = false;
foreach (Unit enemy in Tyr.Bot.Enemies())
{
if (UnitTypes.AirAttackTypes.Contains(enemy.UnitType) &&
agent.DistanceSq(enemy) <= 8 * 8)
{
potential.From(enemy.Pos);
flee = true;
}
}
if (flee)
{
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
return(false);
}
private bool Revelation(Agent oracle)
{
if (Bot.Main.Frame - RevelatorFrame <= 10)
{
return(oracle.Unit.Tag == Revelator);
}
if (Bot.Main.Frame % 5 != 0)
{
return(false);
}
if (oracle.Unit.Energy < 50)
{
return(false);
}
Unit followEnemy = null;
float dist = 15 * 15;
foreach (Unit enemy in Bot.Main.CloakedEnemies())
{
if (enemy.Cloak != CloakState.Cloaked)
{
continue;
}
float newDist = units[0].DistanceSq(enemy);
if (newDist < dist)
{
followEnemy = enemy;
dist = newDist;
}
}
if (followEnemy != null)
{
Point2D target;
if (dist >= 6 * 6)
{
target = new PotentialHelper(followEnemy.Pos, 5).To(oracle.Unit.Pos).Get();
}
else
{
target = new Point2D()
{
X = (followEnemy.Pos.X + oracle.Unit.Pos.X) / 2f, Y = (followEnemy.Pos.Y + oracle.Unit.Pos.Y) / 2f
}
};
oracle.Order(2146, target);
Revelator = oracle.Unit.Tag;
RevelatorFrame = Bot.Main.Frame;
return(true);
}
return(false);
}
}
public override void OnFrame(Tyr tyr)
{
if (OverrideTarget != null)
{
Target = OverrideTarget;
}
else if (tyr.BaseManager.Natural.Owner == tyr.PlayerId)
{
Target = tyr.BaseManager.NaturalDefensePos;
}
else
{
Target = tyr.BaseManager.MainDefensePos;
}
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.LURKER && SC2Util.DistanceSq(agent.Unit.Pos, Target) < 3 * 3)
{
agent.Order(Abilities.BURROW_DOWN);
continue;
}
if (FearEnemies && (agent.IsCombatUnit || agent.Unit.UnitType == UnitTypes.OVERSEER || agent.Unit.UnitType == UnitTypes.RAVEN))
{
Unit fleeEnemy = null;
float distance = 10 * 10;
foreach (Unit enemy in tyr.Enemies())
{
if (!UnitTypes.CombatUnitTypes.Contains(enemy.UnitType))
{
continue;
}
float dist = agent.DistanceSq(enemy);
if (dist < distance)
{
distance = dist;
fleeEnemy = enemy;
}
}
if (fleeEnemy != null)
{
PotentialHelper helper = new PotentialHelper(agent.Unit.Pos);
helper.From(fleeEnemy.Pos);
agent.Order(Abilities.MOVE, helper.Get());
continue;
}
}
if ((agent.IsCombatUnit || agent.Unit.UnitType == UnitTypes.OVERSEER) && SC2Util.DistanceSq(agent.Unit.Pos, Target) >= 5 * 5)
{
agent.Order(Abilities.MOVE, Target);
}
}
}
public bool EvadeEnemies(Agent agent, Point2D target)
{
Point enemyLocation = null;
float dist = 9 * 9;
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.UnitType != UnitTypes.BUNKER)
{
continue;
}
if (enemy.BuildProgress < 0.9)
{
continue;
}
float newDist = agent.DistanceSq(enemy.Pos);
if (newDist < dist)
{
dist = newDist;
enemyLocation = enemy.Pos;
}
}
if (enemyLocation != null)
{
bool alreadyRetreating = RetreatFrame.ContainsKey(agent.Unit.Tag) && Bot.Main.Frame - RetreatFrame[agent.Unit.Tag] <= 5;
if (dist <= 7 * 7 || alreadyRetreating)
{
if (RetreatFrame.ContainsKey(agent.Unit.Tag))
{
RetreatFrame[agent.Unit.Tag] = Bot.Main.Frame;
}
else
{
RetreatFrame.Add(agent.Unit.Tag, Bot.Main.Frame);
}
agent.Order(Abilities.MOVE, agent.From(enemyLocation, 4));
return(true);
}
PotentialHelper helper = new PotentialHelper(agent.Unit.Pos, 4);
helper.From(enemyLocation, 1);
helper.To(target, 1);
agent.Order(Abilities.MOVE, helper.Get());
return(true);
}
return(false);
}
private Point2D GetSiegeTarget(Agent agent)
{
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.IsFlying)
{
continue;
}
if (enemy.UnitType == UnitTypes.CREEP_TUMOR ||
enemy.UnitType == UnitTypes.CREEP_TUMOR_BURROWED ||
enemy.UnitType == UnitTypes.CREEP_TUMOR_QUEEN)
{
continue;
}
if (enemy.UnitType == UnitTypes.ADEPT_PHASE_SHIFT ||
enemy.UnitType == UnitTypes.KD8_CHARGE)
{
continue;
}
if (enemy.UnitType == UnitTypes.BROODLING)
{
continue;
}
if (UnitTypes.BuildingTypes.Contains(enemy.UnitType))
{
continue;
}
if (agent.DistanceSq(enemy) > 8 * 8)
{
continue;
}
PotentialHelper potential = new PotentialHelper(enemy.Pos);
potential.Magnitude = 3;
potential.To(agent.Unit);
Point2D siegeTarget = potential.Get();
if (!LiberationZoneTooClose(agent, siegeTarget))
{
return(siegeTarget);
}
}
return(null);
}
public bool EvadeMines(Agent agent, Point2D target)
{
Point mineLocation = null;
float dist = 9 * 9;
foreach (UnitLocation mine in Bot.Main.EnemyMineManager.Mines)
{
if (Bot.Main.EnemyMineManager.BurrowFrame.ContainsKey(mine.Tag) && Bot.Main.Frame - Bot.Main.EnemyMineManager.BurrowFrame[mine.Tag] <= 16)
{
continue;
}
float newDist = agent.DistanceSq(mine.Pos);
if (newDist < dist)
{
dist = newDist;
mineLocation = mine.Pos;
}
}
if (mineLocation != null)
{
bool alreadyRetreating = RetreatFrame.ContainsKey(agent.Unit.Tag) && Bot.Main.Frame - RetreatFrame[agent.Unit.Tag] <= 5;
if (dist <= 7 * 7 || alreadyRetreating)
{
if (RetreatFrame.ContainsKey(agent.Unit.Tag))
{
RetreatFrame[agent.Unit.Tag] = Bot.Main.Frame;
}
else
{
RetreatFrame.Add(agent.Unit.Tag, Bot.Main.Frame);
}
agent.Order(Abilities.MOVE, agent.From(mineLocation, 4));
return(true);
}
PotentialHelper helper = new PotentialHelper(agent.Unit.Pos, 4);
helper.From(mineLocation, 1);
helper.To(target, 1);
agent.Order(Abilities.MOVE, helper.Get());
return(true);
}
return(false);
}
public override bool DetermineAction(Agent agent, Point2D target)
{
if (agent.Unit.UnitType != UnitTypes.STALKER)
{
return(false);
}
if (agent.Unit.WeaponCooldown == 0)
{
return(false);
}
Unit bunker = GetNaturalBunker();
if (bunker == null)
{
return(false);
}
PotentialHelper potential = new PotentialHelper(EnemyNatural, 8);
potential.From(bunker.Pos);
Point2D attackTarget = potential.Get();
Point2D minePos = null;
float dist = 10 * 10;
foreach (UnitLocation mine in Bot.Main.EnemyMineManager.Mines)
{
float newDist = agent.DistanceSq(mine.Pos);
if (newDist < dist)
{
dist = newDist;
minePos = SC2Util.To2D(mine.Pos);
}
}
potential = new PotentialHelper(agent.Unit.Pos, 4);
potential.To(attackTarget, 2);
if (minePos != null)
{
potential.To(minePos, 1);
}
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
public override void InitializeTasks()
{
base.InitializeTasks();
TimingAttackTask.Enable();
WorkerScoutTask.Enable();
QueenInjectTask.Enable();
QueenDefenseTask.Enable();
ArmyOverseerTask.Enable();
QueenTumorTask.Enable();
DefenseTask.Enable();
WorkerRushDefenseTask.Enable();
OverlordSuicideTask.Enable();
SafeZerglingsFromReapersTask.Enable();
BaseLocation enemyNatural = Tyr.Bot.MapAnalyzer.GetEnemyNatural();
if (enemyNatural != null)
{
Base enemyNaturalBase = null;
foreach (Base b in Tyr.Bot.BaseManager.Bases)
{
if (SC2Util.DistanceSq(b.BaseLocation.Pos, enemyNatural.Pos) <= 2 * 2)
{
enemyNaturalBase = b;
break;
}
}
DefendEnemyNaturalTask = new DefenseSquadTask(enemyNaturalBase, UnitTypes.ZERGLING);
DefendEnemyNaturalTask.MaxDefenders = 100;
DefendEnemyNaturalTask.AlwaysNeeded = true;
DefendEnemyNaturalTask.DraftFromFarAway = true;
DefendEnemyNaturalTask.DefendRange = 12;
DefendEnemyNaturalTask.RetreatMoveCommand = true;
PotentialHelper potential = new PotentialHelper(enemyNatural.Pos);
potential.Magnitude = 10;
potential.From(Tyr.Bot.MapAnalyzer.GetEnemyRamp());
DefendEnemyNaturalTask.OverrideIdleLocation = potential.Get();
potential = new PotentialHelper(enemyNatural.Pos);
potential.Magnitude = 5;
potential.From(Tyr.Bot.MapAnalyzer.GetEnemyRamp());
DefendEnemyNaturalTask.OverrideDefenseLocation = potential.Get();
DefenseSquadTask.Enable(DefendEnemyNaturalTask);
}
}
public Point2D GetHideLocation()
{
if (HideLocation == null)
{
if (Tyr.Bot.TargetManager.PotentialEnemyStartLocations.Count != 1)
{
return(null);
}
Point2D enemyMain = Tyr.Bot.TargetManager.PotentialEnemyStartLocations[0];
Point2D enemyNatural = Tyr.Bot.MapAnalyzer.GetEnemyNatural().Pos;
PotentialHelper potential = new PotentialHelper(enemyNatural, 30);
potential.From(enemyMain);
Point2D closeTo = potential.Get();
float dist = 10000;
foreach (Base b in Tyr.Bot.BaseManager.Bases)
{
float newDist = SC2Util.DistanceSq(closeTo, b.BaseLocation.Pos);
if (newDist >= dist)
{
continue;
}
if (SC2Util.DistanceSq(enemyMain, b.BaseLocation.Pos) < 4)
{
continue;
}
if (SC2Util.DistanceSq(enemyNatural, b.BaseLocation.Pos) < 4)
{
continue;
}
dist = newDist;
HideLocation = b.BaseLocation.Pos;
}
if (Tyr.Bot.EnemyRace == Race.Zerg)
{
potential = new PotentialHelper(HideLocation, 15);
potential.To(Tyr.Bot.MapAnalyzer.StartLocation);
HideLocation = potential.Get();
}
}
return(HideLocation);
}
public bool DetermineAction(Agent agent, Point2D target)
{
bool nearbyDead = false;
foreach (RecentlyDeceased deceased in Tyr.Bot.EnemyManager.GetRecentlyDeceased())
{
if (UnitTypes.AirAttackTypes.Contains(deceased.UnitType) && agent.DistanceSq(deceased.Pos) <= 15 * 15)
{
nearbyDead = true;
break;
}
}
if (!nearbyDead)
{
return(false);
}
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 4;
int count = 0;
foreach (Unit enemy in Tyr.Bot.Enemies())
{
if (!UnitTypes.AirAttackTypes.Contains(enemy.UnitType))
{
continue;
}
float newDist = agent.DistanceSq(enemy);
if (newDist < 12 * 12)
{
count++;
potential.From(enemy.Pos);
}
}
if (count < 5)
{
return(false);
}
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
public override void OnFrame(Bot bot)
{
if (Stopped)
{
Clear();
return;
}
if (Natural == null)
{
Natural = Bot.Main.BaseManager.Natural.BaseLocation.Pos;
}
if (NaturalDefensePos == null)
{
NaturalDefensePos = Bot.Main.BaseManager.NaturalDefensePos;
}
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK_SIEGED &&
(agent.DistanceSq(Natural) >= 8 * 8 || agent.DistanceSq(NaturalDefensePos) <= 10 * 10))
{
agent.Order(Abilities.UNSIEGE);
}
else if (agent.DistanceSq(Natural) >= 8 * 8)
{
agent.Order(Abilities.MOVE, Natural);
}
else if (agent.DistanceSq(NaturalDefensePos) <= 10 * 10)
{
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 1;
potential.From(NaturalDefensePos, 2);
potential.To(Natural);
agent.Order(Abilities.MOVE, potential.Get());
}
else if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK)
{
agent.Order(Abilities.SIEGE);
}
}
}
private void GetScoutingPylonPos()
{
Point2D main = Main.BaseLocation.Pos;
Point2D natural = Natural.BaseLocation.Pos;
float dist = 1000000;
foreach (Base b in Bot.Main.BaseManager.Bases)
{
float topDist = b.BaseLocation.Pos.Y;
float leftDist = b.BaseLocation.Pos.X;
float bottomDist = Bot.Main.GameInfo.StartRaw.MapSize.Y - b.BaseLocation.Pos.Y;
float rightDist = Bot.Main.GameInfo.StartRaw.MapSize.X - b.BaseLocation.Pos.X;
float edgeDist = System.Math.Min(System.Math.Min(topDist, leftDist), System.Math.Min(bottomDist, rightDist));
if (edgeDist >= 50)
{
continue;
}
float mainDist = SC2Util.DistanceSq(b.BaseLocation.Pos, main);
if (mainDist > dist)
{
continue;
}
if (mainDist <= 2 * 2)
{
continue;
}
float naturalDist = SC2Util.DistanceSq(b.BaseLocation.Pos, natural);
if (mainDist > naturalDist)
{
continue;
}
dist = mainDist;
DefendDropsPos = new PotentialHelper(main, 15).To(b.BaseLocation.Pos).Get();
Point2D waypoint = new PotentialHelper(main, 50).To(b.BaseLocation.Pos).Get();
ScoutingPylonPos = new PotentialHelper(waypoint, 40).To(Bot.Main.MapAnalyzer.GetEnemyNatural().Pos).Get();
ScoutingPylonBase = b;
}
}
public override bool DetermineAction(Agent agent, Point2D target)
{
if (Stopped || agent.Unit.UnitType != UnitTypes.VOID_RAY)
{
return(false);
}
float dist = 12 * 12;
Unit fleeTarget = null;
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.UnitType != UnitTypes.VIKING_FIGHTER)
{
continue;
}
float newDist = agent.DistanceSq(enemy);
if (newDist < dist)
{
fleeTarget = enemy;
dist = newDist;
}
}
if (fleeTarget != null)
{
PotentialHelper helper = new PotentialHelper(agent.Unit.Pos);
helper.Magnitude = 8;
helper.From(fleeTarget.Pos);
agent.Order(Abilities.MOVE, helper.Get());
return(true);
}
return(false);
}
public bool FleeFromEffects(Agent agent)
{
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 4;
bool flee = false;
foreach (Managers.Effect effect in Tyr.Bot.EffectManager.Effects)
{
if (effect.EffectId == 11 && agent.DistanceSq(effect.Pos) <= 3 * 3 &&
(Tyr.Bot.Frame - effect.FirstSeenFrame >= 34 || agent.Unit.UnitType != UnitTypes.ZERGLING))
{
potential.From(effect.Pos);
flee = true;
}
}
if (!flee)
{
return(false);
}
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
public override void OnFrame(Bot bot)
{
if (Sentry != null)
{
bool sentryAlive = false;
foreach (Agent agent in Units)
{
if (agent.Unit.Tag == Sentry.Unit.Tag)
{
sentryAlive = true;
break;
}
}
if (!sentryAlive)
{
Sentry = null;
}
}
if (Cancelled)
{
for (int i = Units.Count - 1; i >= 0; i--)
{
if (!BlinkedStalkers.Contains(Units[i].Unit.Tag) &&
Units[i].Unit.UnitType != UnitTypes.SENTRY)
{
ClearAt(i);
}
}
}
if (EnemyThird == null && bot.TargetManager.PotentialEnemyStartLocations.Count == 1)
{
Point2D enemyNatural = bot.MapAnalyzer.GetEnemyNatural().Pos;
Point2D enemyMain = bot.TargetManager.PotentialEnemyStartLocations[0];
Point2D enemyRamp = bot.MapAnalyzer.GetEnemyRamp();
float dist = 1000000;
foreach (BaseLocation loc in bot.MapAnalyzer.BaseLocations)
{
if (SC2Util.DistanceSq(loc.Pos, enemyNatural) <= 2 * 2)
{
continue;
}
float mainDist = SC2Util.DistanceSq(loc.Pos, enemyMain);
if (mainDist <= 2 * 2)
{
continue;
}
if (mainDist > 50 * 50)
{
continue;
}
//float newDist = SC2Util.DistanceSq(loc.Pos, enemyRamp);
if (mainDist > dist)
{
continue;
}
dist = mainDist;
EnemyThird = loc.Pos;
}
PotentialHelper potential;
dist = 25 * 25;
for (int x = 0; x < bot.MapAnalyzer.EnemyDistances.GetLength(0); x++)
{
for (int y = 0; y < bot.MapAnalyzer.EnemyDistances.GetLength(1); y++)
{
if (bot.MapAnalyzer.EnemyDistances[x, y] > 30)
{
continue;
}
Point2D point = new Point2D()
{
X = x, Y = y
};
float newDist = SC2Util.DistanceSq(point, EnemyThird);
if (newDist > dist)
{
continue;
}
dist = newDist;
StagingArea = new PotentialHelper(point, 1)
.To(bot.TargetManager.PotentialEnemyStartLocations[0])
.Get();
}
}
potential = new PotentialHelper(StagingArea, 7f);
potential.From(bot.TargetManager.PotentialEnemyStartLocations[0]);
LoadArea = potential.Get();
}
if (StagingArea != null)
{
bot.DrawSphere(new Point()
{
X = StagingArea.X, Y = StagingArea.Y, Z = bot.MapAnalyzer.StartLocation.Z
});
}
if (units.Count == 0)
{
return;
}
if (Sentry == null)
{
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.SENTRY)
{
Sentry = agent;
break;
}
}
}
OrderSentry();
bool highGroundVision = false;
bool colosusExists = false;
foreach (Agent agent in Units)
{
if (agent.Unit.UnitType != UnitTypes.COLOSUS)
{
continue;
}
colosusExists = true;
if (agent.DistanceSq(StagingArea) <= 3 * 3)
{
highGroundVision = true;
break;
}
}
foreach (Agent agent in units)
{
if (Sentry != null && agent.Unit.Tag == Sentry.Unit.Tag)
{
continue;
}
if (agent.Unit.BuffIds.Contains(3687))
{
BlinkedStalkers.Add(agent.Unit.Tag);
}
if (agent.Unit.UnitType == UnitTypes.COLOSUS)
{
agent.Order(Abilities.MOVE, StagingArea);
}
else if (BlinkedStalkers.Contains(agent.Unit.Tag) || bot.Frame >= 22.4 * 60 * 7.5)
{
Attack(agent, bot.TargetManager.AttackTarget);
}
else if (agent.DistanceSq(LoadArea) <= 2 * 2 && highGroundVision)
{
agent.Order(Abilities.BLINK, StagingArea);
}
else if (agent.DistanceSq(EnemyThird) <= 10 * 10 && colosusExists)
{
agent.Order(Abilities.ATTACK, LoadArea);
}
else
{
Attack(agent, EnemyThird);
}
}
}
public bool DetermineAction(Agent agent, Point2D target)
{
if (agent.Unit.UnitType != UnitTypes.STALKER)
{
return(false);
}
if (agent.Unit.Shield <= 1 && !agent.Unit.BuffIds.Contains(3687) && Tyr.Bot.Observation.Observation.RawData.Player.UpgradeIds.Contains(87))
{
Unit closestEnemy = null;
float dist = 12 * 12;
foreach (Unit enemy in Tyr.Bot.Enemies())
{
if (!UnitTypes.CombatUnitTypes.Contains(enemy.UnitType))
{
continue;
}
float newDist = SC2Util.DistanceSq(enemy.Pos, agent.Unit.Pos);
if (newDist < dist)
{
dist = newDist;
closestEnemy = enemy;
}
}
if (closestEnemy != null)
{
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos, 2);
potential.From(closestEnemy.Pos);
agent.Order(Abilities.BLINK, potential.Get());
return(true);
}
}
Unit kill = null;
float hp = 10000;
int priority = 0;
foreach (Unit enemy in Tyr.Bot.Enemies())
{
int newPriority;
if (enemy.UnitType == UnitTypes.VIKING_FIGHTER ||
enemy.UnitType == UnitTypes.LIBERATOR ||
enemy.UnitType == UnitTypes.BANSHEE)
{
newPriority = 5;
}
else if (enemy.UnitType == UnitTypes.SIEGE_TANK ||
enemy.UnitType == UnitTypes.SIEGE_TANK_SIEGED)
{
newPriority = 4;
}
else
{
newPriority = 0;
}
if (newPriority < priority)
{
continue;
}
float newHp = enemy.Health + enemy.Shield;
if (newPriority == priority && newHp >= hp)
{
continue;
}
if (SC2Util.DistanceSq(agent.Unit.Pos, enemy.Pos) > 8 * 8)
{
continue;
}
kill = enemy;
priority = newPriority;
hp = newHp;
}
if (kill != null)
{
agent.Order(Abilities.ATTACK, kill.Tag);
return(true);
}
return(false);
}
private void OrderWarpPrism()
{
Unit closeEnemy = null;
float dist = 8 * 8;
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.UnitType != UnitTypes.PHOTON_CANNON)
{
continue;
}
float newDist = SC2Util.DistanceSq(enemy.Pos, StagingArea);
if (newDist > dist)
{
continue;
}
dist = newDist;
closeEnemy = enemy;
}
Point2D stagingAreaFinal;
if (closeEnemy != null)
{
PotentialHelper potential = new PotentialHelper(StagingArea, 2);
potential.From(closeEnemy.Pos, 2);
potential.To(Bot.Main.TargetManager.PotentialEnemyStartLocations[0]);
stagingAreaFinal = potential.Get();
}
else
{
stagingAreaFinal = StagingArea;
}
WarpPrismInPlace = false;
if (WarpPrism == null)
{
return;
}
float distance = WarpPrism.DistanceSq(stagingAreaFinal);
if (distance < 20 * 20)
{
WarpPrismInPlace = true;
}
if (distance >= 9 * 9)
{
WarpPrism.Order(Abilities.MOVE, stagingAreaFinal);
return;
}
if (WarpPrism.Unit.Passengers != null && WarpPrism.Unit.Passengers.Count > 0)
{
WarpPrism.Order(913, stagingAreaFinal);
foreach (PassengerUnit passenger in WarpPrism.Unit.Passengers)
{
DroppedUnits.Add(passenger.Tag);
}
return;
}
foreach (Agent agent in Units)
{
if (agent.Unit.IsFlying)
{
continue;
}
if (DroppedUnits.Contains(agent.Unit.Tag))
{
continue;
}
if (agent.DistanceSq(WarpPrism) > 7 * 7)
{
continue;
}
WarpPrism.Order(911, agent.Unit.Tag);
PickupUnitTag = agent.Unit.Tag;
return;
}
if (WarpPrism.DistanceSq(stagingAreaFinal) <= 0.5 * 0.5 &&
WarpPrism.Unit.UnitType == UnitTypes.WARP_PRISM)
{
WarpPrism.Order(Abilities.WarpPrismPhasingMode);
return;
}
WarpPrism.Order(Abilities.MOVE, stagingAreaFinal);
}
public override void OnFrame(Bot bot)
{
BuildingType barracksType = BuildingType.LookUp[UnitTypes.BARRACKS];
if (Bot.Main.UnitManager.Count(UnitTypes.BARRACKS) < 2 && bot.Minerals() >= 150 && BuildRequests.Count == 0)
{
Point2D placement = ProxyBuildingPlacer.FindPlacement(GetHideLocation(), barracksType.Size, UnitTypes.BARRACKS);
BuildRequests.Add(new BuildRequest()
{
Type = UnitTypes.BARRACKS, Pos = placement
});
}
else if (Bot.Main.UnitManager.Count(UnitTypes.BUNKER) < 2 && bot.Minerals() >= 100 && BuildRequests.Count == 0 && bot.UnitManager.Completed(UnitTypes.BARRACKS) > 0 && bot.UnitManager.Count(UnitTypes.BARRACKS) >= 2)
{
PotentialHelper helper = new PotentialHelper(bot.MapAnalyzer.GetEnemyNatural().Pos);
helper.Magnitude = 4;
helper.From(bot.MapAnalyzer.GetEnemyRamp(), 1);
Point2D placement = ProxyBuildingPlacer.FindPlacement(helper.Get(), barracksType.Size, UnitTypes.BUNKER);
BuildRequests.Add(new BuildRequest()
{
Type = UnitTypes.BUNKER, Pos = placement
});
}
else if (Bot.Main.UnitManager.Count(UnitTypes.BUNKER) >= 2 && bot.Minerals() >= 100 && BuildRequests.Count == 0 && bot.UnitManager.Count(UnitTypes.SIEGE_TANK) >= 2 && bot.UnitManager.Count(UnitTypes.BARRACKS) >= 2 && bot.UnitManager.Completed(UnitTypes.ENGINEERING_BAY) >= 1 && bot.UnitManager.Count(UnitTypes.MISSILE_TURRET) < 2)
{
PotentialHelper helper = new PotentialHelper(bot.MapAnalyzer.GetEnemyNatural().Pos);
helper.Magnitude = 4;
helper.From(bot.MapAnalyzer.GetEnemyRamp(), 1);
Point2D placement = ProxyBuildingPlacer.FindPlacement(helper.Get(), new Point2D()
{
X = 2, Y = 2
}, UnitTypes.MISSILE_TURRET);
BuildRequests.Add(new BuildRequest()
{
Type = UnitTypes.MISSILE_TURRET, Pos = placement
});
}
List <BuildRequest> doneRequests = new List <BuildRequest>();
foreach (BuildRequest request in BuildRequests)
{
if (request.worker != null && !Bot.Main.UnitManager.Agents.ContainsKey(request.worker.Unit.Tag))
{
request.worker = null;
}
if (request.worker == null)
{
foreach (Agent agent in Units)
{
if (BuildingType.BuildingAbilities.Contains((int)agent.CurrentAbility()))
{
continue;
}
request.worker = agent;
break;
}
}
if (!ProxyBuildingPlacer.CheckPlacement(request.Pos, BuildingType.LookUp[request.Type].Size, request.Type, null, true))
{
doneRequests.Add(request);
continue;
}
foreach (Agent agent in bot.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType == request.Type &&
agent.DistanceSq(request.Pos) < 4)
{
doneRequests.Add(request);
break;
}
}
}
foreach (BuildRequest request in doneRequests)
{
BuildRequests.Remove(request);
}
Agent bunker = null;
foreach (Agent agent in bot.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType != UnitTypes.BUNKER)
{
continue;
}
if (agent.Unit.BuildProgress < 0.99)
{
continue;
}
if (bunker == null || agent.Unit.Health < agent.Unit.HealthMax)
{
bunker = agent;
}
}
Agent bc = null;
foreach (Agent agent in bot.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType != UnitTypes.BATTLECRUISER)
{
continue;
}
if (bunker == null || agent.DistanceSq(bunker.Unit.Pos) >= 5 * 5)
{
continue;
}
if (agent.Unit.Health < agent.Unit.HealthMax)
{
bc = agent;
}
}
foreach (Agent agent in Units)
{
bool building = false;
foreach (BuildRequest request in BuildRequests)
{
if (request.worker == null || request.worker.Unit.Tag != agent.Unit.Tag)
{
continue;
}
building = true;
agent.Order(BuildingType.LookUp[request.Type].Ability, request.Pos);
break;
}
if (building)
{
continue;
}
if (bunker != null)
{
if (bunker.Unit.Health < bunker.Unit.HealthMax)
{
agent.Order(Abilities.REPAIR, bunker.Unit.Tag);
}
else if (bc != null)
{
agent.Order(Abilities.REPAIR, bc.Unit.Tag);
}
else
{
agent.Order(Abilities.MOVE, bunker.From(bot.TargetManager.PotentialEnemyStartLocations[0], 3));
}
continue;
}
if (agent.DistanceSq(GetHideLocation()) >= 4 * 4)
{
agent.Order(Abilities.MOVE, GetHideLocation());
continue;
}
}
}
public override void OnFrame(Bot bot)
{
if (WarpPrism != null)
{
bool warpPrismAlive = false;
foreach (Agent agent in Units)
{
if (agent.Unit.Tag == WarpPrism.Unit.Tag)
{
warpPrismAlive = true;
break;
}
}
if (!warpPrismAlive)
{
WarpPrism = null;
}
}
if (Cancelled)
{
for (int i = Units.Count - 1; i >= 0; i--)
{
if (!DroppedUnits.Contains(Units[i].Unit.Tag) &&
Units[i].Unit.UnitType != UnitTypes.WARP_PRISM)
{
ClearAt(i);
}
}
}
if (EnemyThird == null && bot.TargetManager.PotentialEnemyStartLocations.Count == 1)
{
Point2D enemyNatural = bot.MapAnalyzer.GetEnemyNatural().Pos;
Point2D enemyMain = bot.TargetManager.PotentialEnemyStartLocations[0];
Point2D enemyRamp = bot.MapAnalyzer.GetEnemyRamp();
float dist = 1000000;
foreach (BaseLocation loc in bot.MapAnalyzer.BaseLocations)
{
if (SC2Util.DistanceSq(loc.Pos, enemyNatural) <= 2 * 2)
{
continue;
}
float mainDist = SC2Util.DistanceSq(loc.Pos, enemyMain);
if (mainDist <= 2 * 2)
{
continue;
}
if (mainDist > 50 * 50)
{
continue;
}
//float newDist = SC2Util.DistanceSq(loc.Pos, enemyRamp);
if (mainDist > dist)
{
continue;
}
dist = mainDist;
EnemyThird = loc.Pos;
}
PotentialHelper potential;
dist = 25 * 25;
for (int x = 0; x < bot.MapAnalyzer.EnemyDistances.GetLength(0); x++)
{
for (int y = 0; y < bot.MapAnalyzer.EnemyDistances.GetLength(1); y++)
{
if (bot.MapAnalyzer.EnemyDistances[x, y] > 30)
{
continue;
}
Point2D point = new Point2D()
{
X = x, Y = y
};
float newDist = SC2Util.DistanceSq(point, EnemyThird);
if (newDist > dist)
{
continue;
}
dist = newDist;
StagingArea = new PotentialHelper(point, 0.5f)
.To(bot.TargetManager.PotentialEnemyStartLocations[0])
.Get();
}
}
potential = new PotentialHelper(StagingArea, 6.5f);
potential.From(bot.TargetManager.PotentialEnemyStartLocations[0]);
LoadArea = potential.Get();
if (bot.Map == MapEnum.Simulacrum)
{
if (bot.MapAnalyzer.StartLocation.X < 100)
{
StagingArea = new Point2D()
{
X = 136.5f, Y = 51.2f
};
LoadArea = new Point2D()
{
X = 134.5f, Y = 55.2f
};
}
else
{
StagingArea = new Point2D()
{
X = 79, Y = 133f
};
LoadArea = new Point2D()
{
X = 82f, Y = 130.5f
};
}
}
}
if (StagingArea != null)
{
bot.DrawSphere(new Point()
{
X = StagingArea.X, Y = StagingArea.Y, Z = bot.MapAnalyzer.StartLocation.Z
});
}
if (units.Count == 0)
{
return;
}
if (WarpPrism == null)
{
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM)
{
WarpPrism = agent;
break;
}
}
}
PickupUnitTag = 0;
bot.DrawText("Pickup unit: " + PickupUnitTag);
OrderWarpPrism();
foreach (Agent agent in units)
{
if (WarpPrism != null && agent.Unit.Tag == WarpPrism.Unit.Tag)
{
continue;
}
if (agent.Unit.IsFlying)
{
DroppedUnits.Add(agent.Unit.Tag);
}
if (DroppedUnits.Contains(agent.Unit.Tag))
{
Attack(agent, bot.TargetManager.AttackTarget);
}
else if (PickupUnitTag == agent.Unit.Tag)
{
if (PickupUnitTag != 0)
{
bot.DrawLine(agent.Unit.Pos, WarpPrism.Unit.Pos);
}
agent.Order(Abilities.MOVE, WarpPrism.Unit.Tag);
}
else if (WarpPrismInPlace)
{
Attack(agent, LoadArea);
}
else
{
Attack(agent, EnemyThird);
}
}
}
public override void OnFrame(Tyr tyr)
{
WorkerTask.Task.EvacuateThreatenedBases = true;
foreach (Agent agent in tyr.UnitManager.Agents.Values)
{
if (tyr.Frame % 224 != 0)
{
break;
}
if (agent.Unit.UnitType != UnitTypes.GATEWAY)
{
continue;
}
if (Count(UnitTypes.NEXUS) < 2 && TimingAttackTask.Task.Units.Count == 0)
{
agent.Order(Abilities.MOVE, Main.BaseLocation.Pos);
}
else
{
agent.Order(Abilities.MOVE, tyr.TargetManager.PotentialEnemyStartLocations[0]);
}
}
if (TotalEnemyCount(UnitTypes.ZEALOT) >= 3 || EnemyCount(UnitTypes.PHOTON_CANNON) > 0)
{
KillImmortals.Stopped = true;
KillStalkers.Stopped = true;
KillRobos.Stopped = true;
}
else
{
KillImmortals.Stopped = false;
KillStalkers.Stopped = false;
KillRobos.Stopped = false;
}
EnemyArmy = System.Math.Max(EnemyArmy, EnemyCount(UnitTypes.ZEALOT) + EnemyCount(UnitTypes.STALKER));
tyr.DrawText("Enemy army: " + EnemyArmy);
if (EnemyCount(UnitTypes.PHOENIX) <= 3)
{
DefenseTask.AirDefenseTask.IgnoreEnemyTypes.Add(UnitTypes.PHOENIX);
}
else
{
DefenseTask.AirDefenseTask.IgnoreEnemyTypes.Remove(UnitTypes.PHOENIX);
}
if (tyr.EnemyStrategyAnalyzer.WorkerRushDetected &&
Count(UnitTypes.ZEALOT) < 2)
{
GasWorkerTask.WorkersPerGas = 0;
}
else
{
BalanceGas();
}
if (TotalEnemyCount(UnitTypes.FORGE) > 0 && tyr.Frame <= 22.4 * 60 * 2)
{
EarlyForgeDetected = true;
}
ScoutTask.Task.ScoutType = UnitTypes.PHOENIX;
ScoutTask.Task.Target = tyr.TargetManager.PotentialEnemyStartLocations[0];
if (CannonDefenseDetected &&
TotalEnemyCount(UnitTypes.STARGATE) + TotalEnemyCount(UnitTypes.DARK_SHRINE) + TotalEnemyCount(UnitTypes.VOID_RAY) == 0)
{
foreach (Agent agent in tyr.Units())
{
if (agent.Unit.UnitType != UnitTypes.SENTRY)
{
continue;
}
if (agent.Unit.Energy < 75)
{
continue;
}
// Hallucinate scouting phoenix.
agent.Order(154);
}
}
if (!VoidraysDetected && TotalEnemyCount(UnitTypes.VOID_RAY) > 0)
{
VoidraysDetected = true;
if (TimingAttackTask.Task.Units.Count < 12)
{
TimingAttackTask.Task.Clear();
}
}
if (!ZealotRushSuspected && !tyr.EnemyStrategyAnalyzer.WorkerRushDetected)
{
if ((Tyr.Bot.Frame >= 22.4 * 60 * 1.5 &&
!Tyr.Bot.EnemyStrategyAnalyzer.NoProxyGatewayConfirmed &&
TotalEnemyCount(UnitTypes.ASSIMILATOR) + TotalEnemyCount(UnitTypes.CYBERNETICS_CORE) == 0) ||
(Tyr.Bot.Frame < 22.4 * 60 * 1.5 && Tyr.Bot.EnemyStrategyAnalyzer.ThreeGateDetected))
{
ZealotRushSuspected = true;
}
}
if (!LowGroundCannons)
{
foreach (Unit enemy in tyr.Enemies())
{
if (enemy.UnitType != UnitTypes.PHOTON_CANNON)
{
continue;
}
if (tyr.MapAnalyzer.MapHeight((int)enemy.Pos.X, (int)enemy.Pos.Y) < tyr.MapAnalyzer.MapHeight((int)tyr.TargetManager.PotentialEnemyStartLocations[0].X, (int)tyr.TargetManager.PotentialEnemyStartLocations[0].Y))
{
LowGroundCannons = true;
break;
}
}
}
if (!CannonDefenseDetected &&
TotalEnemyCount(UnitTypes.PHOTON_CANNON) + TotalEnemyCount(UnitTypes.FORGE) > 0 &&
tyr.Frame < 22.4 * 60 * 4 &&
(EarlyForgeDetected || tyr.EnemyStrategyAnalyzer.Expanded || LowGroundCannons))
{
CannonDefenseDetected = true;
if (TimingAttackTask.Task.Units.Count < 12)
{
TimingAttackTask.Task.Clear();
}
}
if (tyr.EnemyStrategyAnalyzer.WorkerRushDetected &&
Count(UnitTypes.ZEALOT) < 2)
{
foreach (Agent agent in tyr.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType == UnitTypes.ASSIMILATOR &&
agent.Unit.BuildProgress < 0.99)
{
agent.Order(Abilities.CANCEL);
}
}
}
tyr.TargetManager.TargetCannons = true;
if (ZealotRushSuspected)
{
tyr.TargetManager.TargetGateways = true;
WorkerScoutTask.Task.Stopped = true;
WorkerScoutTask.Task.Clear();
}
if (WorkerScoutTask.Task.BaseCircled())
{
WorkerScoutTask.Task.Stopped = true;
WorkerScoutTask.Task.Clear();
}
if (ZealotRushSuspected ||
Completed(UnitTypes.IMMORTAL) > 0)
{
foreach (WorkerDefenseTask task in WorkerDefenseTask.Tasks)
{
task.Stopped = true;
task.Clear();
}
}
if (ZealotRushSuspected && Completed(UnitTypes.STALKER) >= 12)
{
foreach (Agent agent in tyr.Units())
{
if (agent.Unit.UnitType != UnitTypes.GATEWAY)
{
continue;
}
if (agent.DistanceSq(WallIn.Wall[2].Pos) >= 2)
{
continue;
}
KillOwnUnitTask.Task.TargetTag = agent.Unit.Tag;
break;
}
}
WorkerScoutTask.Task.StartFrame = 600;
ObserverScoutTask.Task.Priority = 6;
tyr.NexusAbilityManager.Stopped = Count(UnitTypes.STALKER) == 0 && tyr.Frame >= 120 * 22.4;
tyr.NexusAbilityManager.PriotitizedAbilities.Add(917);
if (EnemyExpandFrame >= 1000000 &&
tyr.EnemyStrategyAnalyzer.Expanded)
{
EnemyExpandFrame = tyr.Frame;
}
if (EnemyExpandFrame < 3 * 60 * 22.4)
{
EarlyExpand = true;
}
if (VoidraysDetected ||
(TotalEnemyCount(UnitTypes.PHOTON_CANNON) + TotalEnemyCount(UnitTypes.FORGE) > 0 && !LowGroundCannons && !EarlyExpand))
{
TimingAttackTask.Task.RequiredSize = 24;
}
else if (ZealotRushSuspected ||
(CannonDefenseDetected && EarlyExpand))
{
TimingAttackTask.Task.RequiredSize = 12;
}
else
{
TimingAttackTask.Task.RequiredSize = 4;
}
TimingAttackTask.Task.RetreatSize = 0;
if (EnemyCount(UnitTypes.ZEALOT) + EnemyCount(UnitTypes.STALKER) >= 6 &&
tyr.Frame < 22.4 * 60 * 5)
{
CancelElevator = true;
WarpPrismElevatorTask.Task.Cancelled = true;
}
if (EnemyCount(UnitTypes.IMMORTAL)
+ EnemyCount(UnitTypes.VOID_RAY) > 0)
{
CancelElevator = true;
WarpPrismElevatorTask.Task.Cancelled = true;
}
if (TotalEnemyCount(UnitTypes.PHOTON_CANNON) + TotalEnemyCount(UnitTypes.FORGE) > 0 &&
!LowGroundCannons &&
!EarlyExpand &&
TimingAttackTask.Task.Units.Count < 18 &&
TimingAttackTask.Task.RequiredSize > 18)
{
TimingAttackTask.Task.Clear();
}
if (CannonDefenseDetected && !CancelElevator)
{
TimingAttackTask.Task.Stopped = true;
TimingAttackTask.Task.Clear();
ShieldRegenTask.Task.Stopped = true;
ShieldRegenTask.Task.Clear();
WarpPrismElevatorTask.Task.Stopped = false;
tyr.TargetManager.PrefferDistant = false;
tyr.TargetManager.TargetAllBuildings = true;
PotentialHelper potential = new PotentialHelper(tyr.TargetManager.PotentialEnemyStartLocations[0], 6);
potential.From(tyr.MapAnalyzer.GetEnemyRamp());
StutterController.Toward = potential.Get();
tyr.DrawSphere(new Point()
{
X = StutterController.Toward.X, Y = StutterController.Toward.Y, Z = tyr.MapAnalyzer.StartLocation.Z
});
EvadeCannonsController.Stopped = Completed(UnitTypes.STALKER) + Completed(UnitTypes.IMMORTAL) >= 12;
EvadeCannonsController.FleeToward = StutterController.Toward;
FallBackController.Stopped = true;
}
else
{
TimingAttackTask.Task.Stopped = false;
WarpPrismElevatorTask.Task.Stopped = true;
tyr.TargetManager.PrefferDistant = true;
ShieldRegenTask.Task.Stopped = false;
tyr.TargetManager.TargetAllBuildings = false;
StutterController.Toward = null;
EvadeCannonsController.Stopped = true;
FallBackController.Stopped = ZealotRushSuspected;
}
ForwardProbeTask.Task.Stopped =
Completed(UnitTypes.STALKER) + Count(UnitTypes.ADEPT) + Completed(UnitTypes.IMMORTAL) < Math.Max(8, TimingAttackTask.Task.RequiredSize) &&
(!CannonDefenseDetected || !StargateDetected || EarlyExpand);
if (ForwardProbeTask.Task.Stopped)
{
ForwardProbeTask.Task.Clear();
}
if (Count(UnitTypes.NEXUS) <= 1)
{
IdleTask.Task.OverrideTarget = OverrideMainDefenseTarget;
}
else if (Count(UnitTypes.NEXUS) >= 3)
{
IdleTask.Task.OverrideTarget = OverrideDefenseTarget;
}
else
{
IdleTask.Task.OverrideTarget = null;
}
if (ZealotRushSuspected)
{
DefenseTask.GroundDefenseTask.BufferZone = 0;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.GroundDefenseTask.MainDefenseRadius = 20;
DefenseTask.GroundDefenseTask.MaxDefenseRadius = 120;
DefenseTask.GroundDefenseTask.DrawDefenderRadius = 80;
}
else
{
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 30;
DefenseTask.GroundDefenseTask.MainDefenseRadius = 30;
DefenseTask.GroundDefenseTask.MaxDefenseRadius = 120;
DefenseTask.GroundDefenseTask.DrawDefenderRadius = 80;
}
if (TotalEnemyCount(UnitTypes.TEMPEST) > 0)
{
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 50;
DefenseTask.AirDefenseTask.MainDefenseRadius = 50;
DefenseTask.AirDefenseTask.MaxDefenseRadius = 120;
DefenseTask.AirDefenseTask.DrawDefenderRadius = 80;
}
else
{
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 30;
DefenseTask.AirDefenseTask.MainDefenseRadius = 30;
DefenseTask.AirDefenseTask.MaxDefenseRadius = 120;
DefenseTask.AirDefenseTask.DrawDefenderRadius = 80;
}
//EarlyNexus = CannonDefenseDetected;
EarlyNexus = false;
StargateDetected = TotalEnemyCount(UnitTypes.STARGATE)
+ TotalEnemyCount(UnitTypes.VOID_RAY)
+ TotalEnemyCount(UnitTypes.PHOENIX)
+ TotalEnemyCount(UnitTypes.TEMPEST)
+ TotalEnemyCount(UnitTypes.CARRIER)
+ TotalEnemyCount(UnitTypes.FLEET_BEACON) > 0;
}
public override void OnFrame(Tyr tyr)
{
if (units.Count == 0)
{
return;
}
Unit fleeEnemy = null;
float dist = 10 * 10;
foreach (Unit enemy in tyr.Enemies())
{
if (!UnitTypes.AirAttackTypes.Contains(enemy.UnitType))
{
continue;
}
float newDist = units[0].DistanceSq(enemy);
if (newDist < dist)
{
fleeEnemy = enemy;
dist = newDist;
}
}
if (fleeEnemy != null)
{
PotentialHelper helper = new PotentialHelper(units[0].Unit.Pos);
helper.Magnitude = 4;
helper.From(fleeEnemy.Pos);
units[0].Order(Abilities.MOVE, helper.Get());
tyr.DrawText("Raven fleeing!");
return;
}
if (tyr.Frame % 5 == 0)
{
return;
}
Point2D target = tyr.TargetManager.AttackTarget;
Agent closest = null;
dist = 1000000;
foreach (Agent agent in tyr.UnitManager.Agents.Values)
{
if (!UnitTypes.CombatUnitTypes.Contains(agent.Unit.UnitType))
{
continue;
}
float newDist = agent.DistanceSq(target);
if (newDist < dist)
{
closest = agent;
dist = newDist;
}
}
int bases = 0;
foreach (Base b in tyr.BaseManager.Bases)
{
if (b.ResourceCenter != null)
{
bases++;
}
}
Point2D defenseLocation;
if (bases >= 2)
{
defenseLocation = tyr.BaseManager.NaturalDefensePos;
}
else
{
defenseLocation = tyr.BaseManager.MainDefensePos;
}
foreach (Agent agent in units)
{
if (closest == null)
{
tyr.DrawText("Raven returning!");
agent.Order(Abilities.MOVE, defenseLocation);
}
else
{
tyr.DrawText("Raven moving out!");
agent.Order(Abilities.MOVE, SC2Util.To2D(closest.Unit.Pos));
}
}
}
public override void OnFrame(Bot bot)
{
if (OverrideTarget != null)
{
Target = OverrideTarget;
}
else if (bot.BaseManager.Natural.Owner == bot.PlayerId)
{
Target = bot.BaseManager.NaturalDefensePos;
}
else
{
Target = bot.BaseManager.MainDefensePos;
}
foreach (Agent agent in units)
{
if (agent.Unit.UnitType == UnitTypes.LURKER && SC2Util.DistanceSq(agent.Unit.Pos, Target) < 3 * 3)
{
agent.Order(Abilities.BURROW_DOWN);
continue;
}
if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK && SC2Util.DistanceSq(agent.Unit.Pos, Target) < 3 * 3)
{
agent.Order(Abilities.SIEGE);
continue;
}
if (YamatoController.DetermineAction(agent, Target))
{
continue;
}
if (agent.Unit.UnitType == UnitTypes.SIEGE_TANK_SIEGED && SC2Util.DistanceSq(agent.Unit.Pos, Target) > IdleRange * IdleRange)
{
if (AttackMove)
{
Attack(agent, Target);
}
else
{
agent.Order(Abilities.UNSIEGE);
}
continue;
}
if (agent.Unit.UnitType == UnitTypes.LIBERATOR_AG)
{
Attack(agent, Target);
continue;
}
if (agent.Unit.UnitType == UnitTypes.OVERLORD &&
agent.DistanceSq(bot.MapAnalyzer.StartLocation) >= 80 * 80 &&
RetreatFarOverlords)
{
agent.Order(Abilities.MOVE, SC2Util.To2D(bot.MapAnalyzer.StartLocation));
continue;
}
if (FearEnemies && (agent.IsCombatUnit || agent.Unit.UnitType == UnitTypes.OVERSEER || agent.Unit.UnitType == UnitTypes.RAVEN))
{
Unit fleeEnemy = null;
float distance = 10 * 10;
foreach (Unit enemy in bot.Enemies())
{
if (!UnitTypes.CombatUnitTypes.Contains(enemy.UnitType))
{
continue;
}
float dist = agent.DistanceSq(enemy);
if (dist < distance)
{
distance = dist;
fleeEnemy = enemy;
}
}
if (fleeEnemy != null)
{
PotentialHelper helper = new PotentialHelper(agent.Unit.Pos);
helper.From(fleeEnemy.Pos);
agent.Order(Abilities.MOVE, helper.Get());
continue;
}
}
if ((agent.IsCombatUnit || agent.Unit.UnitType == UnitTypes.OVERSEER || agent.Unit.UnitType == UnitTypes.OBSERVER) && SC2Util.DistanceSq(agent.Unit.Pos, Target) >= IdleRange * IdleRange)
{
if (AttackMove)
{
Attack(agent, Target);
}
else
{
agent.Order(Abilities.MOVE, Target);
}
continue;
}
if (AttackMove && agent.Unit.UnitType == UnitTypes.SIEGE_TANK && SC2Util.DistanceSq(agent.Unit.Pos, Target) < IdleRange * IdleRange && bot.Frame % 67 == 0)
{
agent.Order(Abilities.SIEGE);
continue;
}
}
}
public override void OnFrame(Bot bot)
{
UpdateWarpingInUnits();
Point2D armyLocation = GetArmyFrontPosition();
Point2D closestEnemyToArmy = armyLocation == null ? null : GetClosestEnemy(armyLocation, false);
if (closestEnemyToArmy != null && SC2Util.DistanceSq(closestEnemyToArmy, armyLocation) <= 6 * 6)
{
armyLocation = new PotentialHelper(armyLocation, 4).From(closestEnemyToArmy).Get();
}
if (armyLocation != null)
{
if (Units.Count >= 1)
{
bot.DrawSphere(new Point()
{
X = armyLocation.X, Y = armyLocation.Y, Z = Units[0].Unit.Pos.Z
});
}
DeterminePickupTargets(armyLocation);
}
foreach (Agent agent in Units)
{
Point2D closestEnemy = GetClosestEnemy(SC2Util.To2D(agent.Unit.Pos), false);
Point2D closestAirEnemy = GetClosestEnemy(SC2Util.To2D(agent.Unit.Pos), true);
float enemyDist = closestEnemy == null ? 1000000 : agent.DistanceSq(closestEnemy);
float airEnemyDist = closestAirEnemy == null ? 1000000 : agent.DistanceSq(closestAirEnemy);
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM &&
agent.Unit.Passengers.Count < (airEnemyDist < 5 * 5 ? 1 : 2) &&
agent.Unit.Health + agent.Unit.Shield >= 60)
{
bool pickingUp = false;
foreach (WarpPrismObjective objective in Objectives)
{
if (objective is PickUpObjective)
{
ulong tag = ((PickUpObjective)objective).UnitTag;
pickingUp = true;
agent.Order(911, tag);
break;
}
}
if (pickingUp)
{
continue;
}
}
if (enemyDist < 6 * 6 &&
agent.Unit.UnitType == UnitTypes.WARP_PRISM_PHASING)
{
if (!WarpInInProgress)
{
agent.Order(Abilities.WarpPrismTransportMode);
}
continue;
}
if (enemyDist >= 5 * 5 && agent.Unit.Passengers.Count > 0)
{
agent.Order(913, SC2Util.To2D(agent.Unit.Pos));
continue;
}
if (enemyDist <= 8 * 8 && agent.Unit.UnitType == UnitTypes.WARP_PRISM)
{
Point2D fleePos = new PotentialHelper(agent.Unit.Pos, 6).From(closestEnemy).Get();
agent.Order(Abilities.MOVE, fleePos);
continue;
}
if (armyLocation == null)
{
agent.Order(Abilities.MOVE, bot.BaseManager.NaturalDefensePos);
continue;
}
if ((agent.DistanceSq(armyLocation) >= 10 * 10 || Bot.Main.Frame - WarpInStartFrane >= 22.4 * 20) &&
agent.Unit.UnitType == UnitTypes.WARP_PRISM_PHASING &&
!WarpInInProgress &&
(!WarpInObjectiveSet() || Bot.Main.Frame - WarpInStartFrane >= 22.4 * 20))
{
agent.Order(Abilities.WarpPrismTransportMode);
continue;
}
/*
* if (agent.Unit.UnitType == UnitTypes.WARP_PRISM
* && agent.DistanceSq(armyLocation) >= 10 * 10)
* {
* agent.Order(Abilities.MOVE, armyLocation);
* continue;
* }
*/
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM && WarpInObjectiveSet())
{
WarpInStartFrane = bot.Frame;
agent.Order(Abilities.WarpPrismPhasingMode);
continue;
}
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM && agent.DistanceSq(armyLocation) >= 4 * 4)
{
agent.Order(Abilities.MOVE, armyLocation);
continue;
}
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM_PHASING)
{
WarpInObjective warpInObjective = null;
foreach (WarpPrismObjective objective in Objectives)
{
if (objective is WarpInObjective)
{
warpInObjective = (WarpInObjective)objective;
break;
}
}
if (warpInObjective != null)
{
Point2D warpInLocation = WarpInPlacer.FindPlacement(SC2Util.To2D(agent.Unit.Pos), warpInObjective.UnitType);
WarpIn(warpInLocation, warpInObjective.UnitType);
}
}
}
}
public override void OnFrame(Bot bot)
{
bot.DrawText("Adept harass count: " + units.Count);
if (Units.Count >= RequiredSize)
{
Sent = true;
}
if (Units.Count >= 2)
{
float dist = 0;
foreach (Agent agent1 in Units)
{
foreach (Agent agent2 in Units)
{
dist = Math.Max(dist, agent1.DistanceSq(agent2));
}
}
if (dist >= 6 * 6)
{
CurrentState = State.GroupUp;
}
if (dist <= 2 * 2)
{
CurrentState = State.Attack;
}
}
Base enemyMain = null;
foreach (Base b in bot.BaseManager.Bases)
{
if (SC2Util.DistanceSq(b.BaseLocation.Pos, bot.TargetManager.PotentialEnemyStartLocations[0]) <= 2 * 2)
{
enemyMain = b;
break;
}
}
Point2D targetLocation = new PotentialHelper(enemyMain.BaseLocation.Pos, 8).To(enemyMain.MineralLinePos).Get();
if (CurrentState == State.Attack ||
Units.Count < 2)
{
foreach (Agent agent in units)
{
if (Bot.Main.Frame % 48 == 0)
{
agent.Order(2544, targetLocation);
}
bot.MicroController.Attack(agent, targetLocation);
}
}
else if (CurrentState == State.GroupUp)
{
Point2D center = new Point2D();
foreach (Agent agent in Units)
{
center.X += agent.Unit.Pos.X / Units.Count;
center.Y += agent.Unit.Pos.Y / Units.Count;
}
foreach (Agent agent in units)
{
bot.MicroController.Attack(agent, center);
}
}
}
public override void OnFrame(Bot bot)
{
if (bot.TargetManager.PotentialEnemyStartLocations.Count == 1 && ScoutPoints == null)
{
ScoutPoints = new List <Point2D>();
for (float dx = -15; dx <= 15; dx++)
{
for (float dy = -15; dy <= 15; dy++)
{
if (dx * dx + dy * dy <= 10 * 10)
{
continue;
}
if (dx * dx + dy * dy > 15 * 15)
{
continue;
}
ScoutPoints.Add(new Point2D()
{
X = bot.TargetManager.PotentialEnemyStartLocations[0].X + dx, Y = bot.TargetManager.PotentialEnemyStartLocations[0].Y + dy
});
}
}
}
Point2D target = bot.TargetManager.PotentialEnemyStartLocations[0];
if (bot.TargetManager.PotentialEnemyStartLocations.Count == 1 && units.Count > 0 && SC2Util.DistanceSq(units[0].Unit.Pos, target) <= 6 * 6)
{
Done = true;
}
if (!Done && bot.EnemyManager.EnemyBuildings.Count > 0)
{
Done = true;
}
if (ScoutNatural && bot.Frame > CheckNaturalTimeEnd)
{
Done = true;
Clear();
return;
}
bool scoutingNatural = ScoutNatural && bot.Frame > CheckNaturalTimeStart && bot.TargetManager.PotentialEnemyStartLocations.Count == 1;
if (scoutingNatural)
{
GetEnemyNatural();
target = EnemyNatural.Pos;
}
foreach (Agent agent in units)
{
float targetDist = (float)Math.Sqrt(SC2Util.DistanceSq(agent.Unit.Pos, target));
if (ScoutNatural && targetDist <= 6 * 6)
{
CheckedNatural = true;
}
ScoutSent = true;
Point2D closest = null;
if (Done)
{
for (int i = ScoutPoints.Count - 1; i >= 0; i--)
{
Point2D scoutPoint = ScoutPoints[i];
if (agent.DistanceSq(scoutPoint) <= 6 * 6)
{
CollectionUtil.RemoveAt(ScoutPoints, i);
}
}
float dist = 1000000;
Point2D scoutTarget = null;
foreach (Point2D scoutPoint in ScoutPoints)
{
float newDist = agent.DistanceSq(scoutPoint);
if (newDist < dist)
{
dist = newDist;
scoutTarget = scoutPoint;
}
}
if (scoutTarget != null)
{
agent.Order(Abilities.MOVE, scoutTarget);
continue;
}
float distance = 6 * 6;
foreach (Unit unit in bot.Enemies())
{
if (!UnitTypes.CombatUnitTypes.Contains(unit.UnitType) && !UnitTypes.WorkerTypes.Contains(unit.UnitType))
{
continue;
}
float newDist = SC2Util.DistanceSq(unit.Pos, agent.Unit.Pos);
if (newDist < distance)
{
distance = newDist;
closest = SC2Util.To2D(unit.Pos);
}
}
}
if ((closest == null && (targetDist >= MaxDist + 1 || !Done)) || (scoutingNatural && !CheckedNatural))
{
if (targetDist >= MaxDist + 1 || (scoutingNatural && !CheckedNatural))
{
agent.Order(Abilities.MOVE, target);
}
}
else
{
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos, 2);
if (targetDist <= MaxDist)
{
potential.From(target, Math.Min(1, MaxDist - targetDist));
}
else
{
potential.To(target, Math.Max(1, targetDist - MaxDist));
}
if (closest != null)
{
potential.From(closest, 2);
}
agent.Order(Abilities.MOVE, potential.Get());
}
}
}
public override void OnFrame(Bot bot)
{
if (Completed(UnitTypes.WARP_PRISM) == 0 &&
(Count(UnitTypes.WARP_PRISM) == 1 || Count(UnitTypes.IMMORTAL) >= 3))
{
bot.NexusAbilityManager.PriotitizedAbilities.Remove(TrainingType.LookUp[UnitTypes.IMMORTAL].Ability);
}
else
{
bot.NexusAbilityManager.PriotitizedAbilities.Add(TrainingType.LookUp[UnitTypes.IMMORTAL].Ability);
}
bot.NexusAbilityManager.PriotitizedAbilities.Add(TrainingType.LookUp[UnitTypes.WARP_PRISM].Ability);
ProxyTask.Task.UseCloseHideLocation = true;
bot.buildingPlacer.BuildCompact = true;
bot.TargetManager.PrefferDistant = false;
bot.TargetManager.TargetAllBuildings = true;
Agent warpPrismPhasing = null;
foreach (Agent agent in bot.Units())
{
if (agent.Unit.UnitType == UnitTypes.WARP_PRISM_PHASING)
{
warpPrismPhasing = agent;
}
}
if (warpPrismPhasing != null)
{
TrainStep.WarpInLocation = SC2Util.To2D(warpPrismPhasing.Unit.Pos);
}
else
{
TrainStep.WarpInLocation = ProxyTask.Task.GetHideLocation();
}
if (!printed)
{
foreach (Agent agent in Bot.Main.Units())
{
if (agent.Unit.UnitType != UnitTypes.PYLON)
{
continue;
}
if (agent.Unit.BuildProgress < 1)
{
continue;
}
if (agent.DistanceSq(TrainStep.WarpInLocation) >= 30 * 30)
{
continue;
}
printed = true;
}
}
if (StutterController.Toward == null &&
bot.TargetManager.PotentialEnemyStartLocations.Count == 1 &&
Completed(UnitTypes.WARP_PRISM) > 0)
{
Point2D enemyBaseCenter = new PotentialHelper(bot.TargetManager.PotentialEnemyStartLocations[0], 12).To(WarpPrismElevatorTask.Task.StagingArea).Get();
StutterController.Toward = new PotentialHelper(enemyBaseCenter, 6).From(bot.MapAnalyzer.GetEnemyRamp()).Get();
}
if (Completed(UnitTypes.IMMORTAL) < RequiredImmortals)
{
TimingAttackTask.Task.RequiredSize = 8;
TimingAttackTask.Task.RetreatSize = 4;
}
else
{
TimingAttackTask.Task.RequiredSize = 4;
TimingAttackTask.Task.RetreatSize = 0;
}
ProxyTask.Task.Stopped = Count(UnitTypes.GATEWAY) == 0;
if (ProxyTask.Task.Stopped)
{
ProxyTask.Task.Clear();
}
if (DefendProxyTask.Base == Main)
{
Point2D proxyLocation = ProxyTask.Task.GetHideLocation();
if (proxyLocation != null)
{
DefendProxyTask.OverrideDefenseLocation = proxyLocation;
DefendProxyTask.OverrideIdleLocation = proxyLocation;
foreach (Base b in bot.BaseManager.Bases)
{
if (SC2Util.DistanceSq(b.BaseLocation.Pos, proxyLocation) <= 20 * 20)
{
DefendProxyTask.Base = b;
}
}
}
}
if (UpgradeType.LookUp[UpgradeType.WarpGate].Progress() >= 0.5 &&
IdleTask.Task.OverrideTarget == null &&
(bot.EnemyRace != Race.Protoss || bot.Frame >= 22.4 * 4 * 60))
{
DefendProxyTask.Stopped = false;
}
else
{
DefendProxyTask.Stopped = AdeptHarass.Get().DetectedPreviously;
}
bot.DrawText("DefendProxyTask.Stopped: " + DefendProxyTask.Stopped);
if (DefendProxyTask.Stopped)
{
DefendProxyTask.Clear();
}
if (DropInMain &&
(Completed(UnitTypes.WARP_PRISM) > 0 || bot.Frame >= 22.4 * 6 * 60))
{
WarpPrismElevatorTask.Task.Stopped = false;
}
else
{
WarpPrismElevatorTask.Task.Stopped = true;
WarpPrismElevatorTask.Task.Clear();
}
if (Completed(UnitTypes.OBSERVER) > 0)
{
StalkerAttackNaturalController.Stopped = true;
}
if (!DefendReapers && bot.EnemyStrategyAnalyzer.Count(UnitTypes.REAPER) > 0 && UpgradeType.LookUp[UpgradeType.WarpGate].Done())
{
foreach (Unit enemy in bot.Enemies())
{
if (enemy.UnitType != UnitTypes.REAPER)
{
continue;
}
if (SC2Util.DistanceSq(enemy.Pos, bot.MapAnalyzer.StartLocation) <= 30 * 30)
{
DefendReapers = true;
ReaperDefenseTask.MaxDefenders = 1;
break;
}
}
}
}
public override bool DetermineAction(Agent agent, Point2D target)
{
if (agent.Unit.UnitType != UnitTypes.ZERGLING)
{
return(false);
}
if (agent.Unit.Tag == BanelingHunter)
{
Unit targetBaneling = null;
float distance = 9;
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.UnitType != UnitTypes.BANELING)
{
continue;
}
float newDist = agent.DistanceSq(enemy);
if (newDist < distance)
{
targetBaneling = enemy;
distance = newDist;
}
}
if (targetBaneling != null)
{
agent.Order(Abilities.ATTACK, targetBaneling.Tag);
BanelingHunter = agent.Unit.Tag;
BanelingHunterFrame = Bot.Main.Frame;
return(true);
}
BanelingHunterFrame = 0;
BanelingHunter = 0;
}
PotentialHelper potential = new PotentialHelper(agent.Unit.Pos);
potential.Magnitude = 4;
bool flee = false;
foreach (Unit enemy in Bot.Main.Enemies())
{
if (enemy.UnitType == UnitTypes.BANELING && agent.DistanceSq(enemy) <= 3 * 3)
{
potential.From(enemy.Pos);
flee = true;
if (Bot.Main.Frame - BanelingHunterFrame >= 2)
{
agent.Order(Abilities.ATTACK, enemy.Tag);
BanelingHunter = agent.Unit.Tag;
BanelingHunterFrame = Bot.Main.Frame;
}
}
}
if (!flee)
{
return(false);
}
agent.Order(Abilities.MOVE, potential.Get());
return(true);
}
