public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < DesiredCount)
{
if (started)
{
Disable();
return;
}
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_ORACLE)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
if (UnitCommanders.Count() == DesiredCount)
{
started = true;
return;
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
var hatcheryCount = UnitCountService.EquivalentTypeCompleted(UnitTypes.ZERG_HATCHERY);
if (UnitCommanders.Count() >= hatcheryCount)
{
while (UnitCommanders.Count() > hatcheryCount)
{
UnitCommanders.Last().Claimed = false;
UnitCommanders.Remove(UnitCommanders.Last());
}
return;
}
foreach (var commander in commanders)
{
if (UnitCommanders.Count() < hatcheryCount)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.Unit.UnitType == (uint)UnitTypes.ZERG_QUEEN)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() == 0)
{
if (started)
{
Disable();
return;
}
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.Worker))
{
if (commander.Value.UnitCalculation.Unit.Orders.Any(o => !SharkyUnitData.MiningAbilities.Contains((Abilities)o.AbilityId)))
{
}
else
{
commander.Value.Claimed = true;
commander.Value.UnitRole = UnitRole.Scout;
UnitCommanders.Add(commander.Value);
started = true;
return;
}
}
}
}
}
IEnumerable <SC2APIProtocol.Action> MoveToProxyLocation(int frame)
{
var commands = new List <SC2APIProtocol.Action>();
foreach (var commander in UnitCommanders.Where(c => !c.UnitCalculation.Unit.Orders.Any(o => SharkyUnitData.BuildingData.Values.Any(b => (uint)b.Ability == o.AbilityId))))
{
if (commander.UnitRole != UnitRole.Proxy && commander.UnitRole != UnitRole.Build)
{
commander.UnitRole = UnitRole.Proxy;
}
if (Vector2.DistanceSquared(new Vector2(MacroData.Proxies[ProxyName].Location.X, MacroData.Proxies[ProxyName].Location.Y), commander.UnitCalculation.Position) > MacroData.Proxies[ProxyName].MaximumBuildingDistance)
{
List <SC2APIProtocol.Action> action;
if (IndividualMicroController.NavigateToTarget(commander, MacroData.Proxies[ProxyName].Location, null, null, Formation.Normal, frame, out action))
{
if (action != null)
{
commands.AddRange(action);
}
}
}
}
return(commands);
}
void RemoveLostWorkers()
{
foreach (var commander in UnitCommanders.Where(c => c.UnitRole == UnitRole.Minerals))
{
if (!BaseData.SelfBases.Any(selfBase => selfBase.MineralMiningInfo.Any(i => i.Workers.Any(w => w.UnitCalculation.Unit.Tag == commander.UnitCalculation.Unit.Tag))))
{
commander.UnitRole = UnitRole.None;
}
}
foreach (var commander in UnitCommanders.Where(c => c.UnitRole == UnitRole.Gas))
{
if (!BaseData.SelfBases.Any(selfBase => selfBase.GasMiningInfo.Any(i => i.Workers.Any(w => w.UnitCalculation.Unit.Tag == commander.UnitCalculation.Unit.Tag))))
{
commander.UnitRole = UnitRole.None;
}
}
foreach (var selfBase in BaseData.SelfBases)
{
foreach (var info in selfBase.MineralMiningInfo)
{
info.Workers.RemoveAll(w => w.UnitRole != UnitRole.Minerals || !UnitCommanders.Any(c => c.UnitCalculation.Unit.Tag == w.UnitCalculation.Unit.Tag));
}
foreach (var info in selfBase.GasMiningInfo)
{
info.Workers.RemoveAll(w => w.UnitRole != UnitRole.Gas || !UnitCommanders.Any(c => c.UnitCalculation.Unit.Tag == w.UnitCalculation.Unit.Tag));
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < DesiredWorkers)
{
if (started && DesiredWorkers == 1)
{
Disable();
return;
}
foreach (var commander in commanders.OrderBy(c => c.Value.UnitCalculation.Unit.BuffIds.Count()))
{
if ((!commander.Value.Claimed || commander.Value.UnitRole == UnitRole.Minerals) && commander.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.Worker))
{
if (commander.Value.UnitCalculation.Unit.Orders.Any(o => !SharkyUnitData.MiningAbilities.Contains((Abilities)o.AbilityId)))
{
}
else
{
commander.Value.UnitRole = UnitRole.Proxy;
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
started = true;
return;
}
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.ArmyUnit))
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
}
}
void ReclaimBuliders(int frame)
{
var incompleteRefineries = ActiveUnitData.SelfUnits.Where(u => SharkyUnitData.GasGeyserRefineryTypes.Contains((UnitTypes)u.Value.Unit.UnitType) && u.Value.Unit.BuildProgress < .99).Select(u => u.Key);
var workers = UnitCommanders.Where(c => c.UnitRole == UnitRole.Build && c.LastOrderFrame < frame - 5 && (c.UnitCalculation.Unit.Orders.Count() == 0 || !c.UnitCalculation.Unit.Orders.Any(o => SharkyUnitData.BuildingData.Values.Any(b => (uint)b.Ability == o.AbilityId))));
foreach (var worker in workers)
{
worker.UnitRole = UnitRole.None;
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
foreach (var commander in commanders)
{
if (commander.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.Worker) && !UnitCommanders.Any(c => c.UnitCalculation.Unit.Tag == commander.Key))
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
}
}
public override IEnumerable <SC2APIProtocol.Action> PerformActions(int frame)
{
if (ScoutLocations == null)
{
GetScoutLocations();
}
var commands = new List <SC2APIProtocol.Action>();
if (!UnitCommanders.Any(c => c.UnitCalculation.Unit.IsHallucination && c.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_PHOENIX))
{
foreach (var commander in UnitCommanders)
{
if (commander.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_SENTRY && commander.UnitCalculation.Unit.Energy >= 75)
{
var action = commander.Order(frame, Abilities.HALLUCINATION_PHOENIX);
if (action != null)
{
commands.AddRange(action);
}
}
}
}
else
{
foreach (var commander in UnitCommanders)
{
if (commander.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_PHOENIX)
{
if (Vector2.DistanceSquared(new Vector2(ScoutLocations[ScoutLocationIndex].X, ScoutLocations[ScoutLocationIndex].Y), commander.UnitCalculation.Position) < 2)
{
ScoutLocationIndex++;
if (ScoutLocationIndex >= ScoutLocations.Count())
{
ScoutLocationIndex = 0;
}
}
else
{
var action = commander.Order(frame, Abilities.MOVE, ScoutLocations[ScoutLocationIndex]);
if (action != null)
{
commands.AddRange(action);
}
}
}
}
}
return(commands);
}
public override IEnumerable <SC2APIProtocol.Action> PerformActions(int frame)
{
var actions = new List <SC2APIProtocol.Action>();
if (lastFrameTime > 5)
{
lastFrameTime = 0;
return(actions);
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var attackingEnemies = ActiveUnitData.SelfUnits.Where(u => u.Value.Attributes.Contains(Attribute.Structure)).SelectMany(u => u.Value.NearbyEnemies).Distinct().Where(e => ActiveUnitData.EnemyUnits.ContainsKey(e.Unit.Tag));
if (attackingEnemies.Count() > 0)
{
if (UnitCommanders.Count() == 0)
{
actions.AddRange(DefendWithWorkers(attackingEnemies, frame));
}
else
{
StopDefendingWithWorkers();
}
foreach (var commander in UnitCommanders)
{
if (commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.Retreat || commander.UnitCalculation.TargetPriorityCalculation.TargetPriority == TargetPriority.FullRetreat)
{
commander.UnitCalculation.TargetPriorityCalculation.TargetPriority = TargetPriority.Attack;
}
}
actions.AddRange(ArmySplitter.SplitArmy(frame, attackingEnemies, TargetingData.MainDefensePoint, UnitCommanders, true));
stopwatch.Stop();
lastFrameTime = stopwatch.ElapsedMilliseconds;
return(actions);
}
else
{
actions = MicroController.Attack(UnitCommanders, TargetingData.MainDefensePoint, TargetingData.ForwardDefensePoint, TargetingData.MainDefensePoint, frame);
}
StopDefendingWithWorkers();
stopwatch.Stop();
lastFrameTime = stopwatch.ElapsedMilliseconds;
return(actions);
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed)
{
var unitType = commander.Value.UnitCalculation.Unit.UnitType;
foreach (var desiredUnitClaim in DesiredUnitsClaims)
{
if ((uint)desiredUnitClaim.UnitType == unitType && !commander.Value.UnitCalculation.Unit.IsHallucination && UnitCommanders.Count(u => u.UnitCalculation.Unit.UnitType == (uint)desiredUnitClaim.UnitType) < desiredUnitClaim.Count)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < DesiredCount)
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.Unit.UnitType == (uint)UnitTypes.TERRAN_BANSHEE)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
if (UnitCommanders.Count() == DesiredCount)
{
return;
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < DesiredCount)
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && (commander.Value.UnitCalculation.Unit.IsFlying || commander.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.ArmyUnit)))
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
if (UnitCommanders.Count() == DesiredCount)
{
return;
}
}
}
}
List <MiningInfo> GetSplitAssignments()
{
var miningAssignments = new List <MiningInfo>();
foreach (var mineralField in BaseData.MainBase.MineralFields)
{
miningAssignments.Add(new MiningInfo(mineralField, BaseData.MainBase.ResourceCenter.Pos));
}
var workersPerField = UnitCommanders.Count() / (float)miningAssignments.Count();
foreach (var worker in UnitCommanders)
{
worker.UnitRole = UnitRole.Minerals;
miningAssignments.Where(m => m.Workers.Count < Math.Ceiling(workersPerField)).OrderBy(m => m.Workers.Count()).ThenBy(m => Vector2.DistanceSquared(new Vector2(m.ResourceUnit.Pos.X, m.ResourceUnit.Pos.Y), worker.UnitCalculation.Position)).First().Workers.Add(worker);
}
return(miningAssignments);
}
void AssignHarassers()
{
if (HarassInfos == null)
{
HarassInfos = new List <HarassInfo>();
foreach (var baseLocation in BaseData.BaseLocations.Where(b => b.ResourceCenter == null || b.ResourceCenter.Alliance != SC2APIProtocol.Alliance.Self).Reverse())
{
HarassInfos.Add(new HarassInfo {
BaseLocation = baseLocation, Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1
});
}
}
else
{
foreach (var baseLocation in BaseData.SelfBases)
{
HarassInfos.RemoveAll(h => h.BaseLocation.Location.X == baseLocation.Location.X && h.BaseLocation.Location.Y == baseLocation.Location.Y);
}
foreach (var harassInfo in HarassInfos)
{
harassInfo.Harassers.RemoveAll(h => !UnitCommanders.Any(u => u.UnitCalculation.Unit.Tag == h.UnitCalculation.Unit.Tag));
}
}
if (HarassInfos.Count() > 0)
{
var unasignedCommanders = UnitCommanders.Where(u => !HarassInfos.Any(info => info.Harassers.Any(h => h.UnitCalculation.Unit.Tag == u.UnitCalculation.Unit.Tag))).ToList();
while (unasignedCommanders.Count() > 0)
{
foreach (var info in HarassInfos.OrderBy(h => h.Harassers.Count()).ThenBy(h => HighestFrame(h)))
{
var commander = unasignedCommanders.First();
info.Harassers.Add(commander);
unasignedCommanders.Remove(commander);
if (unasignedCommanders.Count() == 0)
{
return;
}
}
}
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < 2)
{
if (started)
{
Disable();
return;
}
if (!UnitCommanders.Any(c => c.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_SENTRY))
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_SENTRY)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
break;
}
}
}
if (!UnitCommanders.Any(c => c.UnitCalculation.Unit.IsHallucination && c.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_PHOENIX))
{
foreach (var commander in commanders)
{
if (!commander.Value.Claimed && commander.Value.UnitCalculation.Unit.IsHallucination && commander.Value.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_PHOENIX)
{
commander.Value.Claimed = true;
commander.Value.UnitRole = UnitRole.Scout;
UnitCommanders.Add(commander.Value);
break;
}
}
}
}
else
{
started = true;
}
}
public override void ClaimUnits(ConcurrentDictionary <ulong, UnitCommander> commanders)
{
if (UnitCommanders.Count() < 10 && WallPoints != null)
{
var point = WallPoints.FirstOrDefault();
if (point != null)
{
var vector = new Vector2(point.X, point.Y);
foreach (var commander in commanders.Where(c => !c.Value.Claimed && c.Value.UnitCalculation.UnitClassifications.Contains(UnitClassification.ArmyUnit)).OrderBy(c => Vector2.DistanceSquared(vector, c.Value.UnitCalculation.Position)))
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
if (UnitCommanders.Count() >= 10)
{
return;
}
}
}
}
}
List <SC2APIProtocol.Action> InjectLarva(int frame)
{
var actions = new List <SC2APIProtocol.Action>();
var hatcheries = ActiveUnitData.SelfUnits.Where(u => u.Value.UnitClassifications.Contains(UnitClassification.ResourceCenter) && u.Value.Unit.BuildProgress == 1 && !u.Value.Unit.BuffIds.Contains((uint)Buffs.QUEENSPAWNLARVATIMER));
foreach (var hatchery in hatcheries)
{
var closestQueen = UnitCommanders.Where(u => u.UnitCalculation.Unit.Energy >= 25).OrderBy(u => Vector2.DistanceSquared(u.UnitCalculation.Position, hatchery.Value.Position)).FirstOrDefault();
if (closestQueen != null)
{
var action = closestQueen.Order(frame, Abilities.EFFECT_INJECTLARVA, null, hatchery.Key);
if (action != null)
{
actions.AddRange(action);
return(actions);
}
}
}
return(actions);
}
IEnumerable <UnitCommander> GetIdleWorkers()
{
return(UnitCommanders.Where(c => c.UnitRole == UnitRole.None));
}
void AssignHarassers()
{
if (HarassInfos == null)
{
HarassInfos = new List <HarassInfo>();
foreach (var baseLocation in BaseData.BaseLocations.Where(b => b.ResourceCenter == null || b.ResourceCenter.Alliance != SC2APIProtocol.Alliance.Self).Reverse())
{
HarassInfos.Add(new HarassInfo {
BaseLocation = baseLocation, Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1
});
}
}
else
{
foreach (var baseLocation in BaseData.SelfBases)
{
HarassInfos.RemoveAll(h => h.BaseLocation.Location.X == baseLocation.Location.X && h.BaseLocation.Location.Y == baseLocation.Location.Y);
}
foreach (var harassInfo in HarassInfos)
{
harassInfo.Harassers.RemoveAll(h => !UnitCommanders.Any(u => u.UnitCalculation.Unit.Tag == h.UnitCalculation.Unit.Tag));
}
}
if (ScoutInfos == null)
{
ScoutInfos = new List <ScoutInfo>();
ScoutInfos.Add(new ScoutInfo {
Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1, Location = new SC2APIProtocol.Point2D {
X = 5, Y = 5
}
});
ScoutInfos.Add(new ScoutInfo {
Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1, Location = new SC2APIProtocol.Point2D {
X = MapDataService.MapData.MapWidth - 5, Y = 5
}
});
ScoutInfos.Add(new ScoutInfo {
Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1, Location = new SC2APIProtocol.Point2D {
X = 5, Y = MapDataService.MapData.MapHeight - 5
}
});
ScoutInfos.Add(new ScoutInfo {
Harassers = new List <UnitCommander>(), LastClearedFrame = -1, LastDefendedFrame = -1, LastPathFailedFrame = -1, Location = new SC2APIProtocol.Point2D {
X = MapDataService.MapData.MapWidth - 5, Y = MapDataService.MapData.MapHeight - 5
}
});
}
else
{
foreach (var scoutInfo in ScoutInfos)
{
scoutInfo.Harassers.RemoveAll(h => !UnitCommanders.Any(u => u.UnitCalculation.Unit.Tag == h.UnitCalculation.Unit.Tag));
}
}
var unasignedCommanders = UnitCommanders.Where(u => !HarassInfos.Any(info => info.Harassers.Any(h => h.UnitCalculation.Unit.Tag == u.UnitCalculation.Unit.Tag) || ScoutInfos.Any(info => info.Harassers.Any(h => h.UnitCalculation.Unit.Tag == u.UnitCalculation.Unit.Tag)))).ToList();
foreach (var scoutInfo in ScoutInfos)
{
if (unasignedCommanders.Count() > 0)
{
foreach (var info in ScoutInfos.Where(h => h.Harassers.Count() == 0))
{
var commander = unasignedCommanders.FirstOrDefault(c => c.UnitCalculation.Unit.IsFlying);
if (commander != null)
{
info.Harassers.Add(commander);
unasignedCommanders.Remove(commander);
if (unasignedCommanders.Count() == 0)
{
return;
}
}
}
}
}
if (HarassInfos.Count() > 0)
{
while (unasignedCommanders.Count() > 0)
{
foreach (var info in HarassInfos.OrderBy(h => h.Harassers.Count()).ThenBy(h => HighestFrame(h)))
{
var commander = unasignedCommanders.First();
info.Harassers.Add(commander);
unasignedCommanders.Remove(commander);
if (unasignedCommanders.Count() == 0)
{
return;
}
}
}
}
}
List <SC2APIProtocol.Action> BalanceGasWorkers(int frame)
{
var actions = new List <SC2APIProtocol.Action>();
var gasSaturationCount = 3;
if (BuildOptions.StrictWorkersPerGas)
{
gasSaturationCount = BuildOptions.StrictWorkersPerGasCount;
foreach (var selfBase in BaseData.SelfBases)
{
foreach (var info in selfBase.GasMiningInfo)
{
while (info.Workers.Count() > gasSaturationCount)
{
info.Workers.RemoveAt(0);
}
}
}
}
var refinereries = ActiveUnitData.SelfUnits.Where(u => SharkyUnitData.GasGeyserRefineryTypes.Contains((UnitTypes)u.Value.Unit.UnitType) && u.Value.Unit.BuildProgress >= .99 && BaseData.SelfBases.Any(b => b.GasMiningInfo.Any(g => g.ResourceUnit.Tag == u.Value.Unit.Tag)));
var unsaturatedRefineries = refinereries.Where(u => BaseData.SelfBases.Any(b => b.GasMiningInfo.Any(g => g.ResourceUnit.VespeneContents > 0 && g.ResourceUnit.Tag == u.Value.Unit.Tag && g.Workers.Count() < gasSaturationCount)));
var unsaturatedMinerals = BaseData.SelfBases.Any(b => b.ResourceCenter.BuildProgress == 1 && b.MineralMiningInfo.Any(m => m.Workers.Count() < 2));
if (LowMineralsHighGas)
{
if (MacroData.Minerals > 1000 || MacroData.VespeneGas < 300)
{
LowMineralsHighGas = false;
}
}
else
{
if (MacroData.Minerals < 1000 && MacroData.VespeneGas > 2500)
{
LowMineralsHighGas = true;
}
else if (MacroData.Minerals < 500 && MacroData.VespeneGas > 600)
{
LowMineralsHighGas = true;
}
}
if (LowMineralsHighGas && unsaturatedMinerals)
{
foreach (var selfBase in BaseData.SelfBases.Where(b => b.MineralMiningInfo.Any(m => m.Workers.Count() < 2)))
{
foreach (var info in selfBase.GasMiningInfo)
{
if (info.Workers.Count() > 0)
{
foreach (var worker in info.Workers)
{
worker.UnitRole = UnitRole.None;
}
info.Workers.Clear();
}
}
}
}
else if (unsaturatedRefineries.Count() > 0)
{
foreach (var selfBase in BaseData.SelfBases)
{
foreach (var info in selfBase.GasMiningInfo.Where(g => g.ResourceUnit.VespeneContents > 0))
{
if (info.Workers.Count() < gasSaturationCount)
{
var idleWorkers = GetIdleWorkers();
if (idleWorkers.Count() == 0 && !LowMineralsHighGas)
{
var gasVector = new Vector2(info.ResourceUnit.Pos.X, info.ResourceUnit.Pos.Y);
if (ActiveUnitData.SelfUnits.ContainsKey(info.ResourceUnit.Tag))
{
var unitCalculation = ActiveUnitData.SelfUnits[info.ResourceUnit.Tag];
var workers = unitCalculation.NearbyAllies.Where(c => c.UnitClassifications.Contains(UnitClassification.Worker) && !c.Unit.BuffIds.Any(b => SharkyUnitData.CarryingMineralBuffs.Contains((Buffs)b)));
idleWorkers = UnitCommanders.Where(c => c.UnitRole == UnitRole.Minerals && workers.Any(w => w.Unit.Tag == c.UnitCalculation.Unit.Tag)).OrderBy(c => Vector2.DistanceSquared(gasVector, c.UnitCalculation.Position));
}
}
if (idleWorkers.Count() > 0)
{
var worker = idleWorkers.FirstOrDefault();
worker.UnitRole = UnitRole.Gas;
info.Workers.Add(worker);
return(actions);
}
}
}
}
}
return(actions);
}
public override IEnumerable <SC2APIProtocol.Action> PerformActions(int frame)
{
var actions = new List <SC2APIProtocol.Action>();
if (lastFrameTime > 5)
{
lastFrameTime = 0;
return(actions);
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var mainUnits = UnitCommanders.Where(c => MainAttackers.Contains((UnitTypes)c.UnitCalculation.Unit.UnitType));
var otherUnits = UnitCommanders.Where(c => !MainAttackers.Contains((UnitTypes)c.UnitCalculation.Unit.UnitType));
DistractionSquadService.UpdateDistractionSquad(otherUnits);
DistractionSquadService.Enabled = UnitCommanders.Count() > 25;
IEnumerable <UnitCommander> supportUnits;
if (DistractionSquadService.DistractionSquadState == DistractionSquadState.NotDistracting)
{
supportUnits = otherUnits;
}
else
{
supportUnits = otherUnits.Where(c => !DistractionSquadService.DistractionSquad.Any(d => d.UnitCalculation.Unit.Tag == c.UnitCalculation.Unit.Tag));
}
var hiddenBase = TargetingData.HiddenEnemyBase;
if (mainUnits.Count() > 0)
{
AttackData.ArmyPoint = TargetingService.GetArmyPoint(mainUnits);
}
else
{
AttackData.ArmyPoint = TargetingService.GetArmyPoint(supportUnits);
}
TargetingData.AttackPoint = TargetingService.UpdateAttackPoint(AttackData.ArmyPoint, TargetingData.AttackPoint);
var attackingEnemies = ActiveUnitData.SelfUnits.Where(u => u.Value.UnitClassifications.Contains(UnitClassification.ResourceCenter) || u.Value.UnitClassifications.Contains(UnitClassification.ProductionStructure) || u.Value.UnitClassifications.Contains(UnitClassification.DefensiveStructure)).SelectMany(u => u.Value.NearbyEnemies).Distinct();
if (attackingEnemies.Count() > 0)
{
var armyPoint = new Vector2(AttackData.ArmyPoint.X, AttackData.ArmyPoint.Y);
var distanceToAttackPoint = Vector2.DistanceSquared(armyPoint, new Vector2(TargetingData.AttackPoint.X, TargetingData.AttackPoint.Y));
var closerEnemies = attackingEnemies;
if (AttackData.Attacking)
{
closerEnemies = attackingEnemies.Where(e => Vector2.DistanceSquared(e.Position, armyPoint) < distanceToAttackPoint);
}
if (closerEnemies.Count() > 0)
{
actions = ArmySplitter.SplitArmy(frame, closerEnemies, TargetingData.AttackPoint, mainUnits.Concat(supportUnits), false);
stopwatch.Stop();
lastFrameTime = stopwatch.ElapsedMilliseconds;
return(actions);
}
}
if (!hiddenBase && TargetingData.HiddenEnemyBase)
{
ResetClaimedUnits();
if (MicroTaskData.MicroTasks.ContainsKey("FindHiddenBaseTask"))
{
MicroTaskData.MicroTasks["FindHiddenBaseTask"].Enable();
}
}
else if (hiddenBase && !TargetingData.HiddenEnemyBase)
{
if (MicroTaskData.MicroTasks.ContainsKey("FindHiddenBaseTask"))
{
MicroTaskData.MicroTasks["FindHiddenBaseTask"].Disable();
}
}
actions.AddRange(DistractionSquadService.TakeAction(frame));
if (mainUnits.Count() > 0)
{
if (AttackData.Attacking)
{
actions.AddRange(MicroController.Attack(mainUnits, TargetingData.AttackPoint, TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame));
actions.AddRange(MicroController.Support(supportUnits, mainUnits, TargetingData.AttackPoint, TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame));
}
else
{
var cleanupActions = EnemyCleanupService.CleanupEnemies(mainUnits.Concat(supportUnits), TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame);
if (cleanupActions != null)
{
actions.AddRange(cleanupActions);
}
else
{
actions.AddRange(MicroController.Retreat(mainUnits, TargetingData.ForwardDefensePoint, null, frame));
actions.AddRange(MicroController.Retreat(supportUnits, TargetingData.ForwardDefensePoint, null, frame));
}
}
}
else
{
if (AttackData.Attacking)
{
actions.AddRange(MicroController.Attack(supportUnits, TargetingData.AttackPoint, TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame));
}
else
{
var cleanupActions = EnemyCleanupService.CleanupEnemies(supportUnits, TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame);
if (cleanupActions != null)
{
actions.AddRange(cleanupActions);
}
else
{
actions.AddRange(MicroController.Retreat(supportUnits, TargetingData.ForwardDefensePoint, AttackData.ArmyPoint, frame));
}
}
}
stopwatch.Stop();
lastFrameTime = stopwatch.ElapsedMilliseconds;
return(actions);
}
public override IEnumerable <SC2APIProtocol.Action> PerformActions(int frame)
{
SetLocations();
var actions = new List <SC2APIProtocol.Action>();
if (lastFrameTime > 5)
{
lastFrameTime = 0;
return(actions);
}
var stopwatch = new Stopwatch();
stopwatch.Start();
CheckComplete();
var warpPrisms = UnitCommanders.Where(c => c.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_WARPPRISM || c.UnitCalculation.Unit.UnitType == (uint)UnitTypes.PROTOSS_WARPPRISMPHASING);
var attackers = UnitCommanders.Where(c => c.UnitCalculation.Unit.UnitType != (uint)UnitTypes.PROTOSS_WARPPRISM && c.UnitCalculation.Unit.UnitType != (uint)UnitTypes.PROTOSS_WARPPRISMPHASING);
var droppedAttackers = attackers.Where(c => AreaService.InArea(c.UnitCalculation.Unit.Pos, DropArea));
var unDroppedAttackers = attackers.Where(c => !AreaService.InArea(c.UnitCalculation.Unit.Pos, DropArea));
if (warpPrisms.Count() > 0)
{
foreach (var commander in warpPrisms)
{
var action = OrderWarpPrism(commander, droppedAttackers, unDroppedAttackers, frame);
if (action != null)
{
actions.AddRange(action);
}
}
// move into the loading position
foreach (var commander in unDroppedAttackers)
{
var action = commander.Order(frame, Abilities.ATTACK, LoadingLocation);
if (action != null)
{
actions.AddRange(action);
}
}
//actions.AddRange(MicroController.Retreat(unDroppedAttackers, LoadingLocation, null, frame));
}
else
{
if (droppedAttackers.Count() > 0)
{
// don't wait for another warp prism, just attack
actions.AddRange(MicroController.Attack(unDroppedAttackers, TargetLocation, DefensiveLocation, null, frame));
}
else
{
// wait for a warp prism
actions.AddRange(MicroController.Retreat(unDroppedAttackers, DefensiveLocation, null, frame));
}
}
actions.AddRange(MicroController.Attack(droppedAttackers, TargetLocation, DefensiveLocation, null, frame));
stopwatch.Stop();
lastFrameTime = stopwatch.ElapsedMilliseconds;
return(actions);
}
