public void OnStep()
{
if (_scouting)
{
foreach (var unit in _intel.UnitsEnemyVisible.Where(u => u.UnitType != BlizzardConstants.Unit.Overlord || u.UnitType != BlizzardConstants.Unit.Overseer || u.UnitType != BlizzardConstants.Unit.OverlordTransport))
{
if (MathServices.EuclidianDistance(unit, _scout) < 10)
{
_combat.Move(_scout.Tag, GetFleePoint(_scout.Point, unit.Point));
_scouting = false;
}
}
}
if (!_scouting)
{
var sortedColonies = _intel.Colonies.OrderBy(c => MathServices.EuclidianDistance(c.Point, _eStart));
foreach (var colony in sortedColonies)
{
_combat.Move(_scout.Tag, colony.Point, true);
}
_scouting = true;
}
if (_scout.Orders.Count == 0)
{
_scouting = false;
}
}
private void TransferWorker(IUnit worker, IColony fromColony, IColony toColony)
{
fromColony.Workers.Remove(worker);
worker.Orders.Clear();
combatManager.Move(worker.Tag, toColony.Point);
toColony.Workers.Add(worker);
}
private void Attack()
{
// Ensure all in fleet
var fleetPos = Helpers.GetAvgLocation(fleet.Units);
foreach (var unit in loneUnits)
{
combatManager.Move(unit.Tag, fleetPos);
fleet.AddUnit(unit);
}
var units = fleet.Units.ToList();
if (fleetDeployed)
{
var nearbyUnits = intelManager.UnitsEnemyVisible.Where(u => fleetPos.Distance(u.Point) < 12).ToList();
if (nearbyUnits.Count < 3)
{
combatManager.UseTargetlessAbility(BlizzardConstants.Ability.LiberatorMorphtoAA, fleet);
fleetDeployed = false;
}
}
else if (units.Any(u => u.Orders.Count() == 0))
{
// Have we arrived?
if (snapshot.EnemyColonies.Any(p => p.Point.Distance(fleetPos) < 10))
{
combatManager.UseTargetlessAbility(BlizzardConstants.Ability.LiberatorMorphtoAG, fleet);
fleetDeployed = true;
}
// Go to enemy colony
else
{
combatManager.AttackMove(fleet, snapshot.EnemyColonies.First().Point);
}
}
}
public void OnStep()
{
// Now the Combat Manager is not as forgiving. It expects specific commands and when an
// invalid point/target/ability is given units will do nothing
if (_intel.GameLoop > 9000 && _intel.GameLoop < 9300)
{
if (_first)
{
_log?.LogMessage("performing invalid actions every loop"); _first = false;
}
// Bogous point - never do this
_combatManger.AttackMove(_lousBoys, new Point2D {
X = -400, Y = 500
});
_combatManger.Move(_lousBoys, new Point2D {
X = -400, Y = 500
});
// Bogous tag - never do this
_combatManger.Attack(_lousBoys, 500);
var BC = _lousBoys.Units.First(u => u.UnitType == BlizzardConstants.Unit.Battlecruiser);
_combatManger.UseTargetlessAbility(BlizzardConstants.Ability.GeneralStimpack, BC.Tag);
}
// However if you give it correct input it will execute the command as given
// even if you, like Lazy Lou dont want to attack the enemy, but your own base
else if (_intel.GameLoop > 9300)
{
if (_second)
{
_log?.LogMessage("attacking every loop"); _second = false;
}
var ownBuilding = _intel.StructuresSelf().FirstOrDefault();
if (ownBuilding != null)
{
_combatManger.Attack(_lousBoys, ownBuilding.Tag);
}
}
// Include the classname of this file in the setup file to see Lazy Lou get his battle cruiser (and a reprimand from the production manager)
}
public void Execute(CombatRequest request)
{
switch (request.CommandCase)
{
case CombatRequest.CommandOneofCase.MoveUnit:
_manager.Move(request.MoveUnit.UnitTag, request.MoveUnit.Point, request.MoveUnit.Queue);
break;
case CombatRequest.CommandOneofCase.MoveSquad:
_manager.Move(_repository.Get().First(s => s.Id.Equals(request.MoveSquad.Squad)),
request.MoveSquad.Point, request.MoveSquad.Queue);
break;
case CombatRequest.CommandOneofCase.AttackMoveUnit:
_manager.AttackMove(request.AttackMoveUnit.UnitTag, request.AttackMoveUnit.Point,
request.AttackMoveUnit.Queue);
break;
case CombatRequest.CommandOneofCase.AttackMoveSquad:
_manager.AttackMove(_repository.Get().First(s => s.Id.Equals(request.AttackMoveSquad.Squad)),
request.AttackMoveSquad.Point, request.AttackMoveSquad.Queue);
break;
case CombatRequest.CommandOneofCase.AttackUnit:
_manager.Attack(request.AttackUnit.SourceUnit, request.AttackUnit.TargetUnit,
request.AttackUnit.Queue);
break;
case CombatRequest.CommandOneofCase.AttackSquad:
_manager.Attack(_repository.Get().First(s => s.Id.Equals(request.AttackSquad.Squad)),
request.AttackSquad.TargetUnit, request.AttackSquad.Queue);
break;
case CombatRequest.CommandOneofCase.UseTargetedAbilityUnit:
_manager.UseTargetedAbility(request.UseTargetedAbilityUnit.AbilityId,
request.UseTargetedAbilityUnit.SourceUnit, request.UseTargetedAbilityUnit.TargetUnit,
request.UseTargetedAbilityUnit.Queue);
break;
case CombatRequest.CommandOneofCase.UseTargetedAbilitySquad:
_manager.UseTargetedAbility(request.UseTargetedAbilitySquad.AbilityId,
_repository.Get().First(s => s.Id.Equals(request.UseTargetedAbilitySquad.Squad)),
request.UseTargetedAbilitySquad.TargetUnit, request.UseTargetedAbilitySquad.Queue);
break;
case CombatRequest.CommandOneofCase.UsePointCenteredAbilityUnit:
_manager.UsePointCenteredAbility(request.UsePointCenteredAbilityUnit.AbilityId,
request.UsePointCenteredAbilityUnit.SourceUnit, request.UsePointCenteredAbilityUnit.Point);
break;
case CombatRequest.CommandOneofCase.UsePointCenteredAbilitySquad:
_manager.UsePointCenteredAbility(request.UsePointCenteredAbilitySquad.AbilityId,
_repository.Get().First(s => s.Id.Equals(request.UsePointCenteredAbilitySquad.Squad)),
request.UsePointCenteredAbilitySquad.Point, request.UsePointCenteredAbilitySquad.Queue);
break;
case CombatRequest.CommandOneofCase.UseTargetlessAbilityUnit:
_manager.UseTargetlessAbility(request.UseTargetlessAbilityUnit.AbilityId,
request.UseTargetlessAbilityUnit.SourceUnit, request.UseTargetlessAbilityUnit.Queue);
break;
case CombatRequest.CommandOneofCase.UseTargetlessAbilitySquad:
_manager.UseTargetlessAbility(request.UseTargetedAbilitySquad.AbilityId,
_repository.Get().First(s => s.Id.Equals(request.UseTargetedAbilitySquad.Squad)),
request.UseTargetedAbilitySquad.Queue);
break;
case CombatRequest.CommandOneofCase.SmartMoveUnit:
if (_intel.TryGet(request.SmartMoveUnit.UnitTag, out IUnit unit))
{
_manager.SmartMove(unit, request.SmartMoveUnit.Point, request.SmartMoveUnit.Queue);
}
break;
case CombatRequest.CommandOneofCase.SmartMoveSquad:
_manager.SmartMove(_repository.Get().First(s => s.Id.Equals(request.SmartMoveSquad.Squad)),
request.SmartMoveSquad.Point, request.SmartMoveSquad.Queue);
break;
case CombatRequest.CommandOneofCase.SmartAttackMoveUnit:
if (_intel.TryGet(request.SmartMoveUnit.UnitTag, out IUnit u))
{
_manager.SmartAttackMove(u, request.SmartAttackMoveUnit.Point, request.SmartAttackMoveUnit.Queue);
}
break;
case CombatRequest.CommandOneofCase.SmartAttackMoveSquad:
_manager.SmartAttackMove(
_repository.Get().First(s => s.Id.Equals(request.SmartAttackMoveSquad.Squad)),
request.SmartAttackMoveSquad.Point, request.SmartAttackMoveSquad.Queue);
break;
case CombatRequest.CommandOneofCase.SmartAttackUnit:
if (_intel.TryGet(request.SmartAttackUnit.SourceUnit, out IUnit un))
{
_manager.SmartAttack(un, request.SmartAttackUnit.TargetUnit, request.SmartAttackUnit.Queue);
}
break;
case CombatRequest.CommandOneofCase.SmartAttackSquad:
_manager.SmartAttack(_repository.Get().First(s => s.Id.Equals(request.SmartAttackSquad.Squad)),
request.SmartAttackSquad.TargetUnit, request.SmartAttackSquad.Queue);
break;
case CombatRequest.CommandOneofCase.SquadRequest:
var addUnits = request.SquadRequest.AddUnits;
var removeUnits = request.SquadRequest.RemoveUnits;
var createSquad = request.SquadRequest.CreateSquad;
var removeSquad = request.SquadRequest.RemoveSquad;
if (request.SquadRequest.AddUnits != null)
{
foreach (var tag in addUnits.Tags)
{
if (_intel.TryGet(tag, out var addedUnit))
{
_repository.Get().First(s => s.Id.Equals(request.SquadRequest.AddUnits.SquadId))
.AddUnit(addedUnit);
}
}
}
if (removeUnits != null)
{
foreach (var tag in removeUnits.Tags)
{
if (_intel.TryGet(tag, out var removedUnit))
{
_repository.Get().First(s => s.Id.Equals(request.SquadRequest.RemoveUnits.SquadId))
.RemoveUnit(removedUnit);
}
}
}
if (createSquad != null)
{
_repository.Create(createSquad.Squad.Name, createSquad.Squad.SquadId);
}
if (removeSquad != null)
{
_repository.Remove(removeSquad.SquadId);
}
break;
default:
throw new System.NotImplementedException();
}
}