예제 #1
0
        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;
                    }
                }
            }
        }
예제 #2
0
        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;
                        }
                    }
                }
            }
        }
예제 #3
0
        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;
                        }
                    }
                }
            }
        }
예제 #4
0
        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);
                    }
                }
            }
        }
예제 #5
0
 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);
         }
     }
 }
예제 #6
0
 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);
         }
     }
 }
예제 #7
0
 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;
             }
         }
     }
 }
예제 #8
0
 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() < 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;
            }
        }
예제 #11
0
        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;
                        }
                    }
                }
            }
        }