public bool AddSquad(ISquad squad)
{
if (CheckSquad(squad))
{
_squads.Add(squad);
return(true);
}
return(false);
}
public bool CheckSquad(ISquad squad)
{
var inWorldSpace = squad.MinX >= 0 && squad.MaxX < MyView.SIZE &&
squad.MinY >= MyView.SIZE / 2 && squad.MaxY < MyView.SIZE;
return(inWorldSpace && (_squads.Count == 0 || _squads.All(val => squad == val ||
val.MaxX < squad.MinX || val.MinX > squad.MaxX ||
val.MinY > squad.MaxY || val.MaxY < squad.MinY)));
}
/// <summary>
/// Input with dimension, rover starting info, and commands.
/// Then it deploy and execute commands for each rover.
/// It will stop executing when an exception is thrown.
/// </summary>
public void Input(string input)
{
//split the lines
var lines = input.ToUpper().Trim().Split('\n');
//first line for the plateau size
var plateauLine = lines[0].Split(' ');
//validate coordinate input
if (plateauLine.Length != 2)
{
throw new InvalidInputException("Invalid input for coordinates");
}
var plateauX = ValidateCoordInput(plateauLine[0]);
var plateauY = ValidateCoordInput(plateauLine[1]);
//initialize the plateau and squad
_plateau = new Plateau(plateauX, plateauY);
_squad = new Squad();
//begin to deploy rovers, read two lines at a time
for (var i = 1; i < lines.Length; i = i + 2)
{
var roverLine = lines[i].Split(' ');
//validate coordinate input format
if (roverLine.Length != 3)
{
throw new InvalidInputException("Invalid input format for deployment!");
}
var roverX = ValidateCoordInput(roverLine[0]);
var roverY = ValidateCoordInput(roverLine[1]);
var roverD = ValidateDirInput(roverLine[2][0]);
//if a rover deployed out of plateau boundary, it's lost
if (_plateau.OutOfBound(roverX, roverY))
{
continue;
}
//deploy rover
var rover = _squad.DeployNew(roverX, roverY, roverD);
//read command letters
if (lines[i + 1] != null)
{
_commands = lines[i + 1].Trim().ToCharArray();
}
//execute commands for correct rover
foreach (var command in _commands)
{
ExecuteCommand(rover, command);
}
}
}
public CardDeck(ISquad owner, IEnumerable <ICardData> cards)
{
Owner = owner;
MaximumHandSize = 10;
_drawPile = new Stack <Card>(cards.OrderBy(_ => NetRand.Next()).Select((c, i) => new Card(i, c)));
_discardPile = new List <Card>();
_handCards = new List <Card>();
_bus = ServiceLocator.Instance.GetService <IMessageBus>();
}
public void UpdateDisplayedSquad(ISquad squad)
{
squadPanel.SetActive(!(squad is null));
if (squad is null)
{
return;
}
squadNameText.text = squad.Name;
IList <IUnit> units = squad.Units;
squadMembersText.text = string.Join("\n", units.EnumerateOverValues((unit) => unit.Name));
squadPanelTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 35 + 15 * units.Count);
}
public GroupTask GetTask(ArmyInfo opponent)
{
Analyze(opponent);
GroupTask task = null;
ISquad squad = null;
if (lastTask != null && Squads.TryGetValue(lastTask.group, out squad) && squad.Target != null &&
(lastTask.tick + lastTask.duration > tick && lastTask.action != ActionType.Scale ||
lastTask.tick + lastTask.duration > tick && lastTask.factor > 0 && lastTask.factor < 1 &&
!squad.IsCollapsed))
{
return(new GroupTask
{
action = ActionType.None
});
}
if (lastTask != null && lastTask.next != null && squad != null && squad.Target != null)
{
task = lastTask.next(opponent, strategy);
}
if (task != null)
{
return(task);
}
task = GetInitializationTask();
if (task != null)
{
return(task);
}
task = FormTacticalDefenseTask(opponent);
if (task != null)
{
return(task);
}
task = FormTacticalAttackTask(opponent);
if (task != null)
{
return(task);
}
task = Squads.Select(s => s.Value.FormTask(opponent, strategy)).Where(t => t != null)
.Where(t => !NotInitializedGroups.Any() || Squads[t.group].LastTask == null)
.OrderBy(t => t.priority).ThenBy(t => t.order)
.ThenBy(t => Squads[t.group].LastTask != null ? Squads[t.group].LastTask.tick : int.MinValue)
.ThenByDescending(t => (int)t.action).FirstOrDefault();
return(task);
}
public TurnRightCommand(ISquad squad)
{
_squad = squad;
}
public void SetSquad(ISquad squad)
{
Squad = squad;
}
public virtual bool FilterSquad(ISquad squad)
{
return(squad.Type == VehicleType.Tank || squad.Type == VehicleType.Arrv || squad.Type == VehicleType.Ifv);
}
protected virtual bool FilterNeighbors(ISquad squad)
{
return(squad.Id != Id && squad.Type != VehicleType.Helicopter && squad.Type != VehicleType.Fighter);
}
public SquadUpdatedEvent(ISquad Squad) => this.Squad = Squad;
public RoverController(ILogger <RoverController> logger, ISquad squad, IParse parse)
{
_logger = logger;
_squad = squad;
_parse = parse;
}
public DeployCommand(ISquad squad, Order order)
{
_squad = squad;
this.landingPosition = order.LandingPosition;
this.orientation = order.Orientation;
}
public void Update(World world)
{
BeforeUpdate();
tick = world.TickIndex;
var player = world.Players.First(p => p.Id == playerId);
score = player.Score;
isCrushed = player.IsStrategyCrashed;
strike = (player.NextNuclearStrikeTickIndex > 0)
? new NuclearStrike
{
target = new Coordinate {
X = player.NextNuclearStrikeX, Y = player.NextNuclearStrikeY
},
tick = player.NextNuclearStrikeTickIndex,
vehicleId = player.NextNuclearStrikeVehicleId
}
: null;
canTacticalNuclearAttack = player.RemainingNuclearStrikeCooldownTicks == 0;
foreach (var newVehicle in world.NewVehicles)
{
if (newVehicle.PlayerId == playerId)
{
All[newVehicle.Id] = newVehicle;
}
}
var needDequeueNotInitializedGroupId = 0;
foreach (var update in world.VehicleUpdates)
{
var id = update.Id;
Vehicle oldVehicle;
if (All.TryGetValue(id, out oldVehicle))
{
var newVehicle = new Vehicle(oldVehicle, update);
if (newVehicle.Durability == 0)
{
All.Remove(id);
ByType[newVehicle.Type].Remove(id);
foreach (var groupId in oldVehicle.Groups)
{
ISquad squad;
if (Squads.TryGetValue(groupId, out squad))
{
squad.RemoveVehicle(id);
}
}
continue;
}
All[id] = newVehicle;
ByType[oldVehicle.Type][id] = newVehicle;
foreach (var groupId in newVehicle.Groups)
{
ISquad squad;
if (Squads.TryGetValue(groupId, out squad))
{
squad.Vehicles[id] = newVehicle;
// recording vehicle speed and angles of motions
var speed = Sqrt(Pow(newVehicle.X - oldVehicle.X, 2) + Pow(newVehicle.Y - oldVehicle.Y, 2));
if (speed > 0.1)
{
squad.MovingVehicles[id] = new Coordinate {
X = newVehicle.X - oldVehicle.X, Y = newVehicle.Y - oldVehicle.Y
};
squad.Angles[id] = Geometry.GetAngle(oldVehicle.X, newVehicle.X, oldVehicle.Y, newVehicle.Y);
}
// recording fact of attack
if (newVehicle.Durability < oldVehicle.Durability)
{
squad.AttackedVehicles++;
}
}
else
{
// new group detecting ang squad creating
var nextGroup = NotInitializedGroups.Any() ? NotInitializedGroups.Peek() : null;
ISquad newSquad = null;
if (nextGroup != null && nextGroup.id == groupId)
{
needDequeueNotInitializedGroupId = groupId;
newSquad = Squad.Create(nextGroup.id, All, Squads, nextGroup.type);
}
else
{
newSquad = new Squad(groupId, All, Squads);
}
newSquad.AddOrUpdateVehicle(newVehicle);
Squads[groupId] = newSquad;
}
}
// removing vehicle from squad if it was dismissed
foreach (var squadId in oldVehicle.Groups.Where(g => !newVehicle.Groups.Contains(g)))
{
Squads[squadId].RemoveVehicle(id);
}
}
}
AfterUpdate(needDequeueNotInitializedGroupId);
}
public MoveForwardCommand(ISquad squad)
{
_squad = squad;
}
public TurnLeftCommand(ISquad squad)
{
_squad = squad;
}
protected override bool FilterNeighbors(ISquad squad)
{
return(squad.Id != Id && (squad.Type == VehicleType.Helicopter || squad.Type == VehicleType.Fighter));
}
public override bool FilterSquad(ISquad squad)
{
return(type == VehicleType.Helicopter ||
squad.Type == VehicleType.Helicopter || squad.Type == VehicleType.Fighter);
}
public override bool FilterSquad(ISquad squad)
{
return(squad.Id != Id && squad.Target != null && squad.Target.totalDurability < squad.Vehicles.Count * 100 * 0.8);
}
