protected override void PerformZAction(int currentTurn)
{
foreach (var zoneLocation in EnumFactory.All <ZoneLocation>())
{
EnergyLeaksOutFromReactor(zoneLocation);
}
}
public InputModel NewGameInput()
{
var allExternalThreats = ExternalThreatFactory.AllExternalThreats
.Select(threat => new ExternalThreatModel(threat))
.ToList();
var allInternalThreats = InternalThreatFactory.AllInternalThreats
.Select(threat => new InternalThreatModel(threat))
.ToList();
var inputModel = new InputModel
{
SingleActions = ActionModel.AllSingleActionModels.OrderBy(action => action.FirstAction).ThenBy(action => action.SecondAction),
DoubleActions = ActionModel.AllSelectableDoubleActionModels.OrderBy(action => action.FirstAction).ThenBy(action => action.SecondAction),
SpecializationActions = PlayerSpecializationActionModel.AllPlayerSpecializationActionModels
.OrderBy(action => action.PlayerSpecialization)
.ThenBy(player => player.Hotkey),
Tracks = TrackFactory.CreateAllTracks()
.Select(track => new TrackSnapshotModel(track, new List <int>()))
.ToList(),
AllInternalThreats = new AllThreatsModel(allInternalThreats),
AllExternalThreats = new AllThreatsModel(allExternalThreats),
PlayerSpecializations = EnumFactory.All <PlayerSpecialization>().ToList(),
AllDamageTokens = EnumFactory.All <DamageToken>(),
DamageableZones = EnumFactory.All <ZoneLocation>()
};
return(inputModel);
}
public MainWindow()
{
threatsInGame = new ObservableCollection <ThreatInGame>();
threatsByType = new Dictionary <ThreatType, IList <Threat> >
{
{ ThreatType.MinorExternal, GetThreats(typeof(MinorWhiteExternalThreat)) },
{ ThreatType.SeriousExternal, GetThreats(typeof(SeriousWhiteExternalThreat)) },
{ ThreatType.MinorInternal, GetThreats(typeof(MinorWhiteInternalThreat)) },
{ ThreatType.SeriousInternal, GetThreats(typeof(SeriousWhiteInternalThreat)) }
};
var tracks = EnumFactory.All <TrackConfiguration>()
.Select(trackConfiguration => new Track
{
Name = trackConfiguration.DisplayName(),
TrackConfiguration = trackConfiguration
})
.ToList();
InitializeComponent();
DataContext = this;
RedTrackPicker.ItemsSource = WhiteTrackPicker.ItemsSource = BlueTrackPicker.ItemsSource = InternalTrackPicker.ItemsSource = tracks;
NewThreatZonePicker.ItemsSource = EnumFactory.All <ZoneLocation>();
MinorExternalRadioButton.IsChecked = true;
SelectedThreatList.ItemsSource = threatsInGame;
}
protected override void PerformZAction(int currentTurn)
{
foreach (var zone in EnumFactory.All <ZoneLocation>())
{
Attack(1 + SittingDuck.GetEnergyInReactor(zone));
}
}
protected override void PerformYAction(int currentTurn)
{
var stationsWithMultiplePlayers = EnumFactory.All <StationLocation>()
.Where(stationLocation => stationLocation.IsOnShip())
.Where(stationLocation => SittingDuck.GetPlayerCount(stationLocation) > 1);
SittingDuck.KnockOutPlayers(stationsWithMultiplePlayers);
}
private static void SlimeBHelper(bool isDefeated, bool isSurvived, TrackConfiguration internalTrack, int timeAppears,
List <Player> players, int blueDamage, int redDamage, int whiteDamage, bool battleBotsDisabled)
{
var totalPoints = 0;
if (isDefeated)
{
totalPoints = 6;
}
if (isSurvived)
{
totalPoints = 3;
}
var otherTracks = EnumFactory.All <TrackConfiguration>().Except(new[] { internalTrack }).ToList();
var externalTracksByZone = new Dictionary <ZoneLocation, TrackConfiguration>
{
{ ZoneLocation.Blue, otherTracks.First() },
{ ZoneLocation.Red, otherTracks.Skip(1).First() },
{ ZoneLocation.White, otherTracks.Skip(2).First() }
};
var externalThreats = new ExternalThreat[0];
var slimeB = new SlimeB();
slimeB.SetInitialPlacement(timeAppears);
var internalThreats = new InternalThreat[] { slimeB };
var bonusThreats = new Threat[0];
var game = new Game(players, internalThreats, externalThreats, bonusThreats, externalTracksByZone, internalTrack, null);
game.StartGame();
for (var currentTurn = 0; currentTurn < game.NumberOfTurns + 1; currentTurn++)
{
game.PerformTurn();
}
Assert.AreEqual(GameStatus.Won, game.GameStatus);
Assert.AreEqual(blueDamage, game.SittingDuck.BlueZone.TotalDamage);
Assert.AreEqual(redDamage, game.SittingDuck.RedZone.TotalDamage);
Assert.AreEqual(whiteDamage, game.SittingDuck.WhiteZone.TotalDamage);
Assert.AreEqual(0, players.Count(player => player.IsKnockedOut));
Assert.AreEqual(blueDamage, game.SittingDuck.BlueZone.CurrentDamageTokens.Count);
Assert.AreEqual(redDamage, game.SittingDuck.RedZone.CurrentDamageTokens.Count);
Assert.AreEqual(whiteDamage, game.SittingDuck.WhiteZone.CurrentDamageTokens.Count);
var battleBotsAreDisabledInPlace = game.SittingDuck.RedZone.LowerRedStation.BattleBotsComponent.BattleBots?.IsDisabled ?? false;
Assert.AreEqual(battleBotsDisabled, battleBotsAreDisabledInPlace);
Assert.AreEqual(isDefeated, game.ThreatController.DefeatedThreats.Any());
if (totalPoints != game.TotalPoints)
{
var errorMessage = $"Survived + points didn't match. Expected: {totalPoints} points, survived: {isSurvived}. Actual: {game.TotalPoints} points, survived: {game.ThreatController.SurvivedThreats.Any()}.";
Assert.Fail(errorMessage);
}
}
private IList <DamageToken> GetNewDamageTokens(int count)
{
var openTokens = EnumFactory.All <DamageToken>().Except(CurrentDamageTokens).ToList();
var newDamageTokens = new List <DamageToken>();
for (var i = 0; i < count; i++)
{
var selectedToken = openTokens[random.Next(openTokens.Count)];
openTokens.Remove(selectedToken);
newDamageTokens.Add(selectedToken);
}
return(newDamageTokens);
}
private void TeleportPlayersToOppositeDecks()
{
var playersByStation = EnumFactory.All <StationLocation>()
.Where(stationLocation => stationLocation.IsOnShip())
.Select(stationLocation => new
{
Players = SittingDuck.GetPlayersInStation(stationLocation).ToList(),
StationLocation = stationLocation
})
.ToList();
foreach (var playerList in playersByStation)
{
SittingDuck.TeleportPlayers(
playerList.Players,
playerList.StationLocation.OppositeStationLocation().GetValueOrDefault());
}
}
protected override void PerformZAction(int currentTurn)
{
SittingDuck.KnockOutPlayers(EnumFactory.All <StationLocation>().Where(stationLocation => stationLocation.IsOnShip()).Except(new[] { StationLocation.UpperWhite }));
}
protected override void PerformXAction(int currentTurn)
{
SittingDuck.KnockOutPlayersWithBattleBots(EnumFactory.All <StationLocation>().Where(stationLocation => stationLocation.IsOnShip()));
}
protected void DamageOtherTwoZones(int amount)
{
Damage(amount, EnumFactory.All <ZoneLocation>().Except(new[] { CurrentZone }).ToList());
}
public PlayerDamage PerformAttack()
{
return(new PlayerDamage(3, PlayerDamageType.Rocket, 2, EnumFactory.All <ZoneLocation>()));
}
protected void AttackOtherTwoZones(int amount, ThreatDamageType threatDamageType = ThreatDamageType.Standard)
{
Attack(amount, threatDamageType, EnumFactory.All <ZoneLocation>().Except(new[] { CurrentZone }).ToList());
}
protected override void PerformZAction(int currentTurn)
{
SittingDuck.KnockOutCaptain();
SittingDuck.ShiftPlayersAfterPlayerActions(EnumFactory.All <StationLocation>(), currentTurn + 1);
}
public override void PerformZAction()
{
sittingDuck.KnockOutPlayers(EnumFactory.All <StationLocation>().Except(new[] { StationLocation.UpperWhite }));
}
protected override void PerformZAction(int currentTurn)
{
SittingDuck.KnockOutPlayers(EnumFactory.All <StationLocation>());
}
public PulseCannon(Reactor source) : base(source, 1, 2, PlayerDamageType.Pulse, EnumFactory.All <ZoneLocation>())
{
}
protected override void PerformXAction(int currentTurn)
{
SittingDuck.ShiftPlayersAndRepeatPreviousAction(EnumFactory.All <StationLocation>(), currentTurn + 1);
}
protected override void PerformXAction(int currentTurn)
{
SittingDuck.DrainShields(EnumFactory.All <ZoneLocation>());
}
protected override void PerformXAction(int currentTurn)
{
SittingDuck.AddZoneDebuff(EnumFactory.All <ZoneLocation>(), ZoneDebuff.IneffectiveShields, this);
}
public PlayerDamage PerformAttack(Player performingPlayer)
{
return(new PlayerDamage(IsDoubleRocket ? 5 : 3, PlayerDamageType.Rocket, new [] { 1, 2 }, EnumFactory.All <ZoneLocation>(), performingPlayer));
}
protected override void OnHealthReducedToZero()
{
base.OnHealthReducedToZero();
SittingDuck.RemoveZoneDebuffForSource(EnumFactory.All <ZoneLocation>(), this);
}
public override void PerformYAction()
{
sittingDuck.DrainShields(EnumFactory.All <ZoneLocation>(), 1);
}
protected void AttackAllZones(int amount, ThreatDamageType threatDamageType = ThreatDamageType.Standard)
{
Attack(amount, threatDamageType, EnumFactory.All <ZoneLocation>());
}
private void OnJumpingToHyperspace(object sender, EventArgs args)
{
SittingDuck.KnockOutPlayers(EnumFactory.All <StationLocation>());
}
public static IEnumerable <Track> CreateAllTracks()
{
return(EnumFactory.All <TrackConfiguration>().Select(trackConfiguration => new Track(trackConfiguration)));
}
protected override void PerformYAction(int currentTurn)
{
SittingDuck.RemoveZoneDebuffForSource(EnumFactory.All <ZoneLocation>(), this);
SittingDuck.AddZoneDebuff(EnumFactory.All <ZoneLocation>(), ZoneDebuff.ReversedShields, this);
}
protected override void PerformYAction(int currentTurn)
{
SittingDuck.AddZoneDebuff(EnumFactory.All <ZoneLocation>(), ZoneDebuff.DoubleDamage, this);
}
protected override void PerformYAction(int currentTurn)
{
SittingDuck.DrainReactors(EnumFactory.All <ZoneLocation>(), 1);
}
protected override void OnThreatTerminated()
{
SittingDuck.RemoveZoneDebuffForSource(EnumFactory.All <ZoneLocation>(), this);
base.OnThreatTerminated();
}
