private Point2D DetermineShieldBatteryPos()
{
if (WallIn.Wall.Count < 5)
{
return(null);
}
Point2D pos = SC2Util.TowardCardinal(WallIn.Wall[4].Pos, Natural.BaseLocation.Pos, 2);
if (Bot.Main.buildingPlacer.CheckPlacement(pos, SC2Util.Point(2, 2), UnitTypes.PYLON, null, true))
{
return(pos);
}
return(null);
}
public bool FleeEnemies(bool returnFire, float fleeDistance)
{
Point2D retreatFrom = null;
Unit retreatUnit = null;
float dist = fleeDistance * fleeDistance;
foreach (Unit enemy in Tyr.Bot.Enemies())
{
float newDist = DistanceSq(enemy);
if (newDist < dist)
{
retreatFrom = SC2Util.To2D(enemy.Pos);
retreatUnit = enemy;
dist = newDist;
}
}
foreach (UnitLocation enemy in Tyr.Bot.EnemyMineManager.Mines)
{
float newDist = DistanceSq(enemy.Pos);
if (newDist < dist)
{
retreatFrom = SC2Util.To2D(enemy.Pos);
dist = newDist;
}
}
foreach (UnitLocation enemy in Tyr.Bot.EnemyTankManager.Tanks)
{
float newDist = DistanceSq(enemy.Pos);
if (newDist < dist)
{
retreatFrom = SC2Util.To2D(enemy.Pos);
dist = newDist;
}
}
if (retreatFrom != null)
{
if (retreatUnit != null && returnFire && Unit.WeaponCooldown == 0)
{
float range = GetRange(retreatUnit);
if (DistanceSq(retreatFrom) <= range * range)
{
Order(Abilities.ATTACK, retreatFrom);
return(true);
}
}
Flee(retreatFrom);
return(true);
}
return(false);
}
public bool NeuralParasite(Agent agent)
{
if (agent.Unit.Energy < 100 || !UpgradeType.LookUp[UpgradeType.NeuralParasite].Done())
{
return(false);
}
foreach (Unit unit in Tyr.Bot.Enemies())
{
if (unit.UnitType != UnitTypes.BATTLECRUISER &&
unit.UnitType != UnitTypes.TEMPEST &&
unit.UnitType != UnitTypes.COLOSUS &&
unit.UnitType != UnitTypes.MOTHERSHIP &&
unit.UnitType != UnitTypes.CARRIER)
{
continue;
}
if (NeuralControllers.ContainsKey(unit.Tag))
{
continue;
}
if (SC2Util.DistanceSq(unit.Pos, agent.Unit.Pos) <= 10 * 10)
{
agent.Order(249, unit.Tag);
if (!NeuralControllers.ContainsKey(unit.Tag))
{
NeuralControllers.Add(unit.Tag, agent.Unit.Tag);
}
else
{
NeuralControllers[unit.Tag] = agent.Unit.Tag;
}
if (!NeuralFrame.ContainsKey(agent.Unit.Tag))
{
NeuralFrame.Add(agent.Unit.Tag, Tyr.Bot.Frame);
}
else
{
NeuralFrame[agent.Unit.Tag] = Tyr.Bot.Frame;
}
return(true);
}
}
return(false);
}
public override bool DetermineAction(Agent agent, Point2D target)
{
if (agent.Unit.UnitType != UnitTypes.HELLION)
{
return(false);
}
if (agent.DistanceSq(Bot.Main.TargetManager.PotentialEnemyStartLocations[0]) >= 12 * 12)
{
agent.Order(Abilities.MOVE, Bot.Main.TargetManager.PotentialEnemyStartLocations[0]);
return(true);
}
float distance = 8 * 8;
Unit killTarget = null;
foreach (Unit unit in Bot.Main.Enemies())
{
if (unit.UnitType != UnitTypes.SCV &&
unit.UnitType != UnitTypes.MARINE &&
unit.UnitType != UnitTypes.REAPER)
{
continue;
}
float newDist = agent.DistanceSq(unit);
if (newDist >= distance)
{
continue;
}
distance = newDist;
killTarget = unit;
}
if (killTarget != null)
{
if (agent.Unit.WeaponCooldown == 0)
{
return(false);
}
else if (distance <= 4 * 4)
{
agent.Order(Abilities.MOVE, SC2Util.To2D(Bot.Main.MapAnalyzer.StartLocation));
}
agent.Order(Abilities.MOVE, agent.Toward(killTarget, 4));
return(true);
}
agent.Order(Abilities.MOVE, Bot.Main.TargetManager.PotentialEnemyStartLocations[0]);
return(true);
}
private bool CheckPlacementFull(List <uint> types, Point2D start, Point2D end, Point2D middle, BoolGrid placable)
{
if (!CheckRect(placable, middle.X - 1, middle.Y - 1, middle.X + 1, middle.Y + 1))
{
return(false);
}
if (Math.Abs(start.X - middle.X) == 3)
{
if (Math.Abs(start.Y - middle.Y) >= 3)
{
return(false);
}
}
else if (Math.Abs(start.Y - middle.Y) == 3)
{
if (Math.Abs(start.X - middle.X) >= 3)
{
return(false);
}
}
else
{
return(false);
}
Point2D pylonPos = SC2Util.Point(end.X, end.Y);
pylonPos = SC2Util.TowardCardinal(pylonPos, middle, 2.5f);
Wall = new List <WallBuilding>();
Wall.Add(new WallBuilding()
{
Pos = start, Type = types[0]
});
Wall.Add(new WallBuilding()
{
Pos = middle, Type = types[1]
});
Wall.Add(new WallBuilding()
{
Pos = pylonPos, Type = types[2]
});
Wall.Add(new WallBuilding()
{
Pos = end, Type = types[3]
});
return(true);
}
public override Build OverrideBuild()
{
if (EnemyMain == null)
{
EnemyMain = Bot.Main.TargetManager.PotentialEnemyStartLocations[0];
}
if (!InBaseBarracks &&
!Proxy)
{
foreach (Unit unit in Bot.Main.Enemies())
{
if (unit.UnitType != UnitTypes.BARRACKS &&
unit.UnitType != UnitTypes.FACTORY)
{
continue;
}
if (SC2Util.DistanceSq(unit.Pos, EnemyMain) <= 40 * 40)
{
InBaseBarracks = true;
}
else
{
Proxy = true;
}
}
}
if (InBaseBarracks)
{
if (PvTStalkerImmortal == null)
{
PvTStalkerImmortal = new PvTStalkerImmortal();
PvTStalkerImmortal.OnStart(Bot.Main);
PvTStalkerImmortal.InitializeTasks();
}
return(PvTStalkerImmortal);
}
else
{
if (OneBaseStalkerImmortal == null)
{
OneBaseStalkerImmortal = new OneBaseStalkerImmortal()
{
Scouting = true
};
OneBaseStalkerImmortal.OnStart(Bot.Main);
OneBaseStalkerImmortal.InitializeTasks();
}
return(OneBaseStalkerImmortal);
}
}
public override List <UnitDescriptor> GetDescriptors()
{
List <UnitDescriptor> descriptors = new List <UnitDescriptor>();
int requiredCount = 2 - Units.Count;
if (requiredCount > 0)
{
descriptors.Add(new UnitDescriptor(UnitTypes.STALKER)
{
Count = requiredCount,
Pos = SC2Util.To2D(Bot.Main.MapAnalyzer.StartLocation)
});
}
return(descriptors);
}
public override bool DetermineAction(Agent agent, Point2D target)
{
Unit killTarget = null;
float dist = 15 * 15;
foreach (Unit unit in Tyr.Bot.Enemies())
{
if (unit.UnitType != TargetType)
{
if (NoEnemiesAround)
{
if (!UnitTypes.WorkerTypes.Contains(unit.UnitType) &&
UnitTypes.CombatUnitTypes.Contains(unit.UnitType) &&
agent.DistanceSq(unit) <= 12 * 12)
{
return(false);
}
}
continue;
}
float newDist = agent.DistanceSq(unit);
if (newDist > dist)
{
continue;
}
killTarget = unit;
dist = newDist;
}
if (killTarget == null)
{
return(false);
}
if (agent.Unit.WeaponCooldown > 0)
{
agent.Order(Abilities.MOVE, SC2Util.To2D(killTarget.Pos));
}
else
{
agent.Order(Abilities.ATTACK, killTarget.Tag);
}
return(true);
}
