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;
}
}
}
}
}
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)
{
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)
{
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 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)
{
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;
}
}
}
}
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)
{
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 && UnitCommanders.Count(u => u.UnitCalculation.Unit.UnitType == (uint)desiredUnitClaim.UnitType) < desiredUnitClaim.Count)
{
commander.Value.Claimed = true;
UnitCommanders.Add(commander.Value);
}
}
}
}
}
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);
}
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;
}
}
}
}
}
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);
}
