public override void Execute() => OwnWorkers.Where(w => w.IsIdle)
.Where(w => !MyUnits.TrackedUnits.ContainsKey(w) || !MyUnits.TrackedUnits[w].StartsWith("MoveDroneTo"))
.ForEach(w =>
{
MyUnits.SetActivity(w, nameof(IdleWorkersToMineral));
GatherClosestMineral(w);
});
public override void Execute()
{
if (Game.FrameCount % 5 != 0)
{
return;
}
var ownGroundRangedUnits = Game.Self.Units
.Where(u => u.UnitType.Type == UnitType.Zerg_Hydralisk).Where(u => !MyUnits.TrackedUnits.ContainsKey(u) || MyUnits.TrackedUnits[u] != nameof(RetreatIfOutnumbered));
foreach (var attacker in ownGroundRangedUnits)
{
var candidateTargets = EnemyUnitsInSight(attacker);
if (!candidateTargets.Any())
{
continue;
}
var target = GetHighestPrioTarget(attacker, candidateTargets);
if (ShouldKite(attacker, target))
{
Kite(attacker, target);
return;
}
MyUnits.SetActivity(attacker, nameof(RangedKite));
attacker.Attack(target, false);
}
}
public string Serialize()
{
var map = heights.StrJoin("|", row => row.StrJoin(""));
var my = MyUnits.StrJoin("|");
var his = HisUnits.StrJoin("|");
return(string.Join("|", map, my, his));
}
public override void Execute()
{
OwnFighters.Where(u => u.IsIdle).ForEach(u =>
{
u.Move(_rellyFightersTo, false);
MyUnits.SetActivity(u, nameof(FightersRallyPoint));
});
}
public string Serialize()
{
var map = Size.Times(y => Size.Times(x => heights[y, x]).StrJoin("")).StrJoin("|");
var my = MyUnits.StrJoin("|");
var his = HisUnits.StrJoin("|");
return(string.Join("|", map, my, his));
}
public override string ToString()
{
var map = Size.Times(y => Size.Times(x => heights[y, x]).StrJoin("")).StrJoin("\n");
var my = MyUnits.StrJoin("; ");
var his = HisUnits.StrJoin("; ");
return($"{map}\n{my}\n{his}\n{CurrentPlayer}");
}
public override string ToString()
{
var map = heights.StrJoin("\n", row => row.StrJoin(""));
var my = MyUnits.StrJoin("; ");
var his = HisUnits.StrJoin("; ");
return($"{map}\n{my}\n{his}\n{CurrentPlayer}");
}
private void RetreatToClosestReinforcement(Unit u)
{
MyUnits.SetActivity(u, nameof(RetreatIfOutnumbered));
var natural = _gameInfo.MyBases.FirstOrDefault(b => b.IsNatural);
var any = _gameInfo.MyBases.FirstOrDefault();
var retreatPoint = (natural ?? any)?.BaseRegion.ContentTiles.First().AsWalkTile().ToPixelTile() ?? _mapCenter;
u.Move(retreatPoint, false);
}
private void Start()
{
m_Deck = GetComponentInChildren <Deck>();
m_Hand = GetComponentInChildren <Hand>();
m_UnitsOnBoard = GetComponent <MyUnits>();
m_UnitsOnBoard.Init(this);
Register();
}
private static void AttackClosestEnemyBuilding(IReadOnlyCollection <Unit> idleUnitsOfWantedTypeInMyBase)
{
var closestEnemyBuilding = GameMemory.EnemyBuildings.MinBy(b =>
b.CalcApproximateDistance(idleUnitsOfWantedTypeInMyBase.First().Position));
idleUnitsOfWantedTypeInMyBase.ForEach(u =>
{
MyUnits.SetActivity(u, nameof(OrderIdleUnitsToAttack));
u.Attack(closestEnemyBuilding, false);
});
}
private static void Kite(Unit kiter, Unit target)
{
const int extraDistance = 32;
var retreatVector = GetRetreatVector(target, kiter);
var wantedDistance = kiter.SelfGroundRangePx() + extraDistance;
var fleeToX = Round(retreatVector.X * wantedDistance + target.Position.X);
var fleeToY = Round(retreatVector.Y * wantedDistance + target.Position.Y);
var fleeTo = new Position(fleeToX, fleeToY);
MyUnits.SetActivity(kiter, nameof(RangedKite));
kiter.Move(fleeTo, false);
}
private static void ShiftAttackAllStartLocations(IEnumerable <Unit> units)
{
var notMyBaseStartLocations = Game.StartLocations.Except(new[] { Game.Self.StartLocation })
.Select(loc => new Position(loc.X * 32, loc.Y * 32))
.ToList();
units.ForEach(u => notMyBaseStartLocations.ForEach(position =>
{
MyUnits.SetActivity(u, nameof(OrderIdleUnitsToAttack));
u.Attack(position, true);
}));
}
public override void Execute()
{
if (!EnemiesInBase.Any())
{
return;
}
OwnFighters.Where(u => u.IsIdle)
.ForEach(u =>
{
MyUnits.SetActivity(u, nameof(AttackEnemiesInBase));
u.Attack(EnemiesInBase.First().Position, false);
});
}
private void AITowerBeforeMove()
{
var potentialTargets = MyPositions.Where(p => IsMyBorder(p) && !IsDefended(p)).ToList();
var potentialTargetsExtended = new List <Position>();
foreach (var target in potentialTargets)
{
potentialTargetsExtended.AddRange(target.Arounds(true).Where(p => !IsDefended(p) && Map[p.X, p.Y].IsOwned).ToList());
}
// Make them distinct
potentialTargets = potentialTargetsExtended.GroupBy(i => (i.X, i.Y)).Select(x => x.First()).ToList();
potentialTargets.RemoveAll(p => p.Arounds(true).Where(pA => IsMyBorder(pA) && Map[pA.X, pA.Y].IsOccupied && !IsDefended(pA)).ToList().Count < 2);
potentialTargets.RemoveAll(p => Map[p.X, p.Y].HasMineSpot);
while (MyGold > BUILD_COST_TOWER && potentialTargets.Count > 0)
{
potentialTargets.Sort(delegate(Position p1, Position p2)
{
int count1 = p1.Arounds(true).Where(p => IsMyBorder(p) && Map[p.X, p.Y].IsOccupied && !IsDefended(p)).ToList().Count;
int count2 = p2.Arounds(true).Where(p => IsMyBorder(p) && Map[p.X, p.Y].IsOccupied && !IsDefended(p)).ToList().Count;
if (count1 != count2)
{
return(count2 - count1);
}
else
{
return((int)(Math.Abs(11 - (p1.X + p1.Y)) - Math.Abs(11 - (p2.X + p2.Y))));
}
// Or closer to our Hq ??
});
var target = potentialTargets[0];
int soldierCount = target.Arounds(true).Where(p => IsMyBorder(p) && Map[p.X, p.Y].IsOccupied && !IsDefended(p)).ToList().Count;
if (soldierCount < 2)
{
break;
}
else
{
List <Unit> onTheWayUnits = MyUnits.FindAll(u => u.Position.Arounds(true).Exists(p => p == target));
FreePlace(target);
Build("TOWER", target);
potentialTargets.RemoveAt(0);
}
//potentialTargets.RemoveAll(p => IsDefended(p));
potentialTargets.RemoveAll(p => p.Arounds(true).Where(pA => IsMyBorder(pA) && Map[pA.X, pA.Y].IsOccupied && !IsDefended(pA)).ToList().Count < 2);
}
}
public override void Execute()
{
var triggeringUnits = MyCombatUnits.Where(u => u.IsIdle).Where(IsOutsideOfBase).ToList();
if (!triggeringUnits.Any())
{
return;
}
var visibleEnemyUnits = Game.Enemy.Units
.Where(eu => eu.UnitType.Type != UnitType.Unknown)
.Where(eu => !eu.IsCloaked)
.ToList();
if (visibleEnemyUnits.Any())
{
triggeringUnits.ForEach(u =>
{
MyUnits.SetActivity(u, nameof(IdleFightersAttackClosestEnemy) + "Unit");
u.Attack(visibleEnemyUnits.ClosestTo(u).Position, false);
});
return;
}
if (!GameMemory.EnemyBuildings.Any())
{
triggeringUnits.ForEach(u =>
{
MyUnits.SetActivity(u, nameof(IdleFightersAttackClosestEnemy) + "Searching");
u.Attack(RandomResourceSitePosition, false);
});
return;
}
triggeringUnits.ForEach(u =>
{
var closestEnemyBuilding = GameMemory.EnemyBuildings.MinBy(b => u.Position.CalcApproximateDistance(b));
MyUnits.SetActivity(u, nameof(IdleFightersAttackClosestEnemy) + "Building");
u.Attack(closestEnemyBuilding, false);
});
}
public override void Execute()
{
OwnWorkers.Where(u => u.IsUnderAttack).ForEach(worker =>
{
var closeUnits = worker.UnitsInRadius(64);
var closeEnemyUnits = closeUnits.Where(Game.Enemy.Units.Contains).ToList();
if (!closeEnemyUnits.Any())
{
return;
}
var closeAlliedUnits = closeUnits.Where(Game.Self.Units.Contains)
.Where(w => w.IsGatheringMinerals || w.IsGatheringGas).Where(w => !ShouldFlee(w));
closeAlliedUnits.ForEach(u =>
{
MyUnits.SetActivity(u, nameof(WorkersAttackClosestEnemy));
u.Attack(closeEnemyUnits.First(), false);
});
if (ShouldFlee(worker))
{
GatherBaseMineralFarFromAttacker(worker, closeEnemyUnits.First());
}
});
}
private static bool MoveDroneToExpandLocation(Unit drone, Position expandLocation)
{
MyUnits.SetActivity(drone, "MoveDroneToExpansion");
return(drone.Move(expandLocation, false));
}
public void Scan(PlayerView view)
{
Me = view.Players.Single(p => p.Id == view.MyId);
EnemyPlayers = view.Players.Where(p => p.Id != view.MyId).ToList();
SpiceMilange = view.Entities.Where(e => e.EntityType == EntityType.Resource).ToList();
BusySpiceMilange = new List <Entity>();
EnemyEntities = view.Entities.Where(e => e.PlayerId != view.MyId && e.EntityType != EntityType.Resource).ToList();
MyEntities = view.Entities.Where(e => e.PlayerId == view.MyId).ToList();
MyBuildingsBroken = MyBuildings.Where(b => b.Health < view.EntityProperties.Single(ep => ep.Key == b.EntityType).Value.MaxHealth).ToList();
MyUnitsBroken = MyUnits.Where(b => b.Health < view.EntityProperties.Single(ep => ep.Key == b.EntityType).Value.MaxHealth).ToList();
// MyUnitsBusyWorkers = new List<Entity>();
// todo delete -1 in another round
HouseBuildingCost = view.EntityProperties.Single(ep => ep.Key == EntityType.House).Value.InitialCost + MyBuildingsHouses.Count();
WorkersBuildingCost = view.EntityProperties.Single(ep => ep.Key == EntityType.BuilderBase).Value.InitialCost + MyBuildingsWorkers.Count() - 1;
RangedBuildingCost = view.EntityProperties.Single(ep => ep.Key == EntityType.RangedBase).Value.InitialCost + MyBuildingsRanged.Count() - 1;
MeleeBuildingCost = view.EntityProperties.Single(ep => ep.Key == EntityType.MeleeBase).Value.InitialCost + MyBuildingsMelees.Count() - 1;
WallBuildingCost = view.EntityProperties.Single(ep => ep.Key == EntityType.Wall).Value.InitialCost + MyBuildingsWalls.Count();
WorkerUnitCost = view.EntityProperties.Single(ep => ep.Key == EntityType.BuilderUnit).Value.InitialCost + MyUnitsWorkers.Count() - 1;
RangedUnitCost = view.EntityProperties.Single(ep => ep.Key == EntityType.RangedUnit).Value.InitialCost + MyUnitsRanged.Count() - 1;
MeleeUnitCost = view.EntityProperties.Single(ep => ep.Key == EntityType.MeleeUnit).Value.InitialCost + MyUnitsMelees.Count() - 1;
TurretUnitCost = view.EntityProperties.Single(ep => ep.Key == EntityType.Turret).Value.InitialCost + MyUnitsTurrets.Count() - 1;
// SquareOfMyInterests = new Vec2Int(MyEntities.Max(e => e.Position.X) + 1,
// MyEntities.Max(e => e.Position.Y) + 1);
SquareOfMyInterests = new Vec2Int(35, 35);
PopulationProvide = 0;
PopulationUse = 0;
foreach (var entity in MyEntities)
{
PopulationProvide += view.EntityProperties.Single(ep => ep.Key == entity.EntityType).Value.PopulationProvide;
PopulationUse += view.EntityProperties.Single(ep => ep.Key == entity.EntityType).Value.PopulationUse;
}
NotFreePoints = new List <Vec2Int>();
foreach (var entity in view.Entities)
{
var size = view.EntityProperties.Single(ep => ep.Key == entity.EntityType).Value.Size;
if (MyBuildings.Contains(entity))
{
for (var x = 0; x < size + 2; x++)
{
for (var y = 0; y < size + 2; y++)
{
var _x = entity.Position.X + x - 1;
var _y = entity.Position.Y + y - 1;
NotFreePoints.CheckPointInsideAndSave(_x, _y);
}
}
}
else
{
for (var x = 0; x < size; x++)
{
for (var y = 0; y < size; y++)
{
NotFreePoints.Add(new Vec2Int(entity.Position.X + x,
entity.Position.Y + y));
}
}
}
}
ChooseBehavior();
}
