public static string DisplayName(this TrackConfiguration trackConfiguration)
{
switch (trackConfiguration)
{
case TrackConfiguration.Track1:
return("Track 1 (T1)");
case TrackConfiguration.Track2:
return("Track 2 (T2)");
case TrackConfiguration.Track3:
return("Track 3 (T3)");
case TrackConfiguration.Track4:
return("Track 4 (T4)");
case TrackConfiguration.Track5:
return("Track 5 (T5)");
case TrackConfiguration.Track6:
return("Track 6 (T6)");
case TrackConfiguration.Track7:
return("Track 7 (T7)");
default:
throw new InvalidOperationException();
}
}
public OnvifSetTrackConfiguration(string uri, string userName, string password, string recordingToken, string trackToken, TrackConfiguration config)
: base(uri, userName, password)
{
RecordingToken = recordingToken;
TrackToken = trackToken;
Config = config;
}
public static void RedSlimeTwoYCrossesXYY2_ProgenyACrossesY2_ProgenyBCrossesZ_TwoBlueDamageHasDisabledBattleBots_Survived()
{
var redPlayerActions = PlayerActionFactory.CreateDoubleActionList(new PlayerActionType?[]
{
PlayerActionType.MoveRed, PlayerActionType.ChangeDeck,
PlayerActionType.Charlie, null,
null, null,
PlayerActionType.BattleBots, null,
null, null,
null, null,
null, null,
null, null,
null, null,
PlayerActionType.BattleBots, null
}).ToList();
redPlayerActions.Add(new PlayerAction(PlayerActionType.MoveBlue, PlayerActionType.BattleBots, PlayerActionType.AdvancedSpecialization));
var players = new List <Player>
{
new Player(redPlayerActions, 0, PlayerColor.Red, PlayerSpecialization.SpecialOps),
new Player(PlayerActionFactory.CreateSingleActionList(ComputerMaintenanceActions), 1, PlayerColor.Green)
};
const TrackConfiguration internalTrack = TrackConfiguration.Track7;
const int timeAppears = 4;
const int blueDamage = 2;
const int whiteDamage = 0;
const int redDamage = 0;
const bool isDefeated = false;
const bool isSurvived = true;
const bool battleBotsDisabled = false;
SlimeBHelper(isDefeated, isSurvived, internalTrack, timeAppears, players, blueDamage, redDamage, whiteDamage, battleBotsDisabled);
}
public static void RedSlimeTwoYCrossesXYY2Z_ProgenyACrossesY2Z_ProgenyBCrossesNoBreakpoints_TwoRedDamageTwoWhiteDamageHasDisabledBattleBots_Survived()
{
var players = new List <Player>
{
new Player(PlayerActionFactory.CreateSingleActionList(new PlayerActionType?[]
{
PlayerActionType.MoveBlue,
PlayerActionType.Charlie,
null,
PlayerActionType.ChangeDeck,
null,
null,
null,
null,
null,
PlayerActionType.BattleBots
}), 0, PlayerColor.Red),
new Player(PlayerActionFactory.CreateSingleActionList(ComputerMaintenanceActions), 1, PlayerColor.Green)
};
const TrackConfiguration internalTrack = TrackConfiguration.Track7;
const int timeAppears = 4;
const int blueDamage = 0;
const int whiteDamage = 2;
const int redDamage = 2;
const bool isDefeated = false;
const bool isSurvived = true;
const bool battleBotsDisabled = true;
SlimeBHelper(isDefeated, isSurvived, internalTrack, timeAppears, players, blueDamage, redDamage, whiteDamage, battleBotsDisabled);
}
public static void RedSlimeNoYCrossesX_NoDamageHasDisabledBattleBots_Defeated()
{
var players = new List <Player>
{
new Player(PlayerActionFactory.CreateDoubleActionList(new PlayerActionType?[]
{
PlayerActionType.MoveBlue, PlayerActionType.Charlie,
PlayerActionType.MoveRed, PlayerActionType.MoveRed,
PlayerActionType.ChangeDeck, null,
null, null,
PlayerActionType.BattleBots, null,
PlayerActionType.BattleBots, null
}), 0, PlayerColor.Blue, PlayerSpecialization.EnergyTechnician),
new Player(PlayerActionFactory.CreateSingleActionList(ComputerMaintenanceActions), 1, PlayerColor.Green)
};
const TrackConfiguration internalTrack = TrackConfiguration.Track1;
const int timeAppears = 3;
const int blueDamage = 0;
const int whiteDamage = 0;
const int redDamage = 0;
const bool isDefeated = true;
const bool isSurvived = false;
const bool battleBotsDisabled = true;
SlimeBHelper(isDefeated, isSurvived, internalTrack, timeAppears, players, blueDamage, redDamage, whiteDamage, battleBotsDisabled);
}
public Game(
IList <Player> players,
IList <InternalThreat> internalThreats,
IList <ExternalThreat> externalThreats,
IList <Threat> bonusThreats,
IDictionary <ZoneLocation, TrackConfiguration> externalTrackConfigurationsByZone,
TrackConfiguration internalTrackConfiguration,
ILookup <ZoneLocation, DamageToken> initialDamage)
{
EventMaster = new EventMaster();
GameStatus = GameStatus.InProgress;
NumberOfTurns = 12;
var externalTracksByZone = externalTrackConfigurationsByZone.ToDictionary(
trackConfigurationWithZone => trackConfigurationWithZone.Key,
trackConfigurationWithZone => new Track(trackConfigurationWithZone.Value));
var internalTrack = new Track(internalTrackConfiguration);
ThreatController = new ThreatController(externalTracksByZone, internalTrack, externalThreats, internalThreats, EventMaster);
ThreatController.PhaseStarting += (sender, args) => PhaseStarting(this, args);
SittingDuck = new SittingDuck(ThreatController, this, initialDamage);
var allThreats = bonusThreats.Concat(internalThreats).Concat(externalThreats);
foreach (var threat in allThreats)
{
threat.Initialize(SittingDuck, ThreatController, EventMaster);
}
SittingDuck.SetPlayers(players);
Players = players;
foreach (var player in players)
{
player.Initialize(SittingDuck);
}
PadPlayerActions();
}
public override string CreateTrack(string RecordingToken, TrackConfiguration TrackConfiguration)
{
ParametersValidation validation = new ParametersValidation();
validation.Add(ParameterType.String, "RecordingToken", RecordingToken);
// ToDo: add parameters from configuration passed
return((string)ExecuteGetCommand(validation, RecordingServiceTest.CreateTrackTest));
}
protected string CreateTrack(string token, TrackConfiguration configuration, string stepName)
{
string result = string.Empty;
RunStep(() => { result = Client.CreateTrack(token, configuration); },
stepName);
DoRequestDelay();
return(result);
}
public static void SixBasicThreats()
{
var players = GetPlayers();
var externalTracksByZone = new Dictionary <ZoneLocation, TrackConfiguration>
{
{ ZoneLocation.Blue, TrackConfiguration.Track1 },
{ ZoneLocation.Red, TrackConfiguration.Track2 },
{ ZoneLocation.White, TrackConfiguration.Track3 },
};
const TrackConfiguration internalTrack = TrackConfiguration.Track4;
var destroyer = new Destroyer();
destroyer.SetInitialPlacement(4, ZoneLocation.Blue);
var fighter1 = new Fighter();
fighter1.SetInitialPlacement(5, ZoneLocation.Red);
var fighter2 = new Fighter();
fighter2.SetInitialPlacement(6, ZoneLocation.White);
var externalThreats = new ExternalThreat[] { destroyer, fighter1, fighter2 };
var skirmishers = new SkirmishersA();
skirmishers.SetInitialPlacement(4);
var fissure = new Fissure();
fissure.SetInitialPlacement(2);
var nuclearDevice = new NuclearDevice();
nuclearDevice.SetInitialPlacement(6);
var internalThreats = new InternalThreat[] { skirmishers, fissure, nuclearDevice };
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(4, game.SittingDuck.BlueZone.TotalDamage);
Assert.AreEqual(3, game.SittingDuck.RedZone.TotalDamage);
Assert.AreEqual(3, game.SittingDuck.WhiteZone.TotalDamage);
Assert.AreEqual(3, game.ThreatController.DefeatedThreats.Count());
Assert.AreEqual(3, game.ThreatController.SurvivedThreats.Count());
Assert.AreEqual(30, game.TotalPoints);
Assert.AreEqual(3, game.SittingDuck.Zones.ElementAt(0).CurrentDamageTokens.Count);
Assert.AreEqual(3, game.SittingDuck.Zones.ElementAt(1).CurrentDamageTokens.Count);
Assert.AreEqual(4, game.SittingDuck.Zones.ElementAt(2).CurrentDamageTokens.Count);
}
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);
}
}
protected TrackConfiguration GetTrackConfiguration(string recordingToken, string trackToken)
{
TrackConfiguration trackConfiguration = null;
RunStep(() => { trackConfiguration = Client.GetTrackConfiguration(recordingToken, trackToken); },
string.Format("Get track configuration (recording token = '{0}', track token = '{1}')",
recordingToken, trackToken));
DoRequestDelay();
return(trackConfiguration);
}
private void CompareTrackConfigurations(TrackConfiguration recordingTrackConfig, TrackConfiguration trackConfig)
{
StringBuilder logger = new StringBuilder();
bool ok = true;
if (recordingTrackConfig.Description != trackConfig.Description)
{
ok = false;
logger.Append(string.Format("Description are different", Environment.NewLine));
}
if (recordingTrackConfig.TrackType != trackConfig.TrackType)
{
ok = false;
logger.Append(string.Format("Track types are different", Environment.NewLine));
}
Assert(ok, logger.ToStringTrimNewLine(), "Verify track configuration");
}
public static void RedSlimeOneYCrossesXYZ_ProgenyACrossesZ_TwoRedDamageTwoWhiteDamageHasDisabledBattleBots_Survived()
{
var players = new List <Player>
{
new Player(PlayerActionFactory.CreateSingleActionList(ComputerMaintenanceActions), 0, PlayerColor.Green)
};
const TrackConfiguration internalTrack = TrackConfiguration.Track4;
const int timeAppears = 3;
const int blueDamage = 0;
const int whiteDamage = 2;
const int redDamage = 2;
const bool isDefeated = false;
const bool isSurvived = true;
const bool battleBotsDisabled = true;
SlimeBHelper(isDefeated, isSurvived, internalTrack, timeAppears, players, blueDamage, redDamage, whiteDamage, battleBotsDisabled);
}
private void CheckRecordingTrack(GetTracksResponseItem track, TrackConfiguration conf)
{
bool ok = true;
StringBuilder logger = new StringBuilder();
if (track.Configuration.Description != conf.Description)
{
ok = false;
logger.Append(string.Format("Description is invalid{0}", Environment.NewLine));
}
if (track.Configuration.TrackType != conf.TrackType)
{
ok = false;
logger.Append(string.Format("Track type is invalid{0}", Environment.NewLine));
}
Assert(ok, logger.ToStringTrimNewLine(),
"Check that configuration parameters of new track are valid");
}
public override TrackConfiguration GetTrackConfiguration(string RecordingToken, string TrackToken)
{
var recording = Search.SearchStorage.Instance.Recordings.Where(r => r.RecordingToken == RecordingToken).FirstOrDefault();
if (recording == null)
{
ReturnFault(new string[] { "Sender", "InvalidArgVal", "UnknownToken" });
}
var track = recording.Track.Where(t => t.TrackToken == TrackToken).FirstOrDefault();
if (track == null)
{
ReturnFault(new string[] { "Sender", "InvalidArgVal", "UnknownToken" });
}
TrackConfiguration trackConfig = new TrackConfiguration()
{
Description = track.Description,
TrackType = (TrackType)((int)track.TrackType)
};
return(trackConfig);
}
public static void JustAFighterNoActions()
{
var players = Enumerable.Range(0, 1).Select(index => new Player(new List <PlayerAction>(), 0, PlayerColor.Blue)).ToList();
var externalTracksByZone = new Dictionary <ZoneLocation, TrackConfiguration>
{
{ ZoneLocation.Blue, TrackConfiguration.Track1 },
{ ZoneLocation.Red, TrackConfiguration.Track5 },
{ ZoneLocation.White, TrackConfiguration.Track3 }
};
const TrackConfiguration internalTrack = TrackConfiguration.Track4;
var fighter = new Fighter();
fighter.SetInitialPlacement(5, ZoneLocation.Red);
var externalThreats = new ExternalThreat[] { fighter };
var internalThreats = new InternalThreat[0];
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(0, game.SittingDuck.BlueZone.TotalDamage);
Assert.AreEqual(5, game.SittingDuck.RedZone.TotalDamage);
Assert.AreEqual(0, game.SittingDuck.WhiteZone.TotalDamage);
Assert.AreEqual(0, game.ThreatController.DefeatedThreats.Count());
Assert.AreEqual(1, game.ThreatController.SurvivedThreats.Count());
Assert.AreEqual(2, game.TotalPoints);
Assert.AreEqual(5, game.SittingDuck.Zones.ElementAt(0).CurrentDamageTokens.Count);
Assert.AreEqual(0, game.SittingDuck.Zones.ElementAt(1).CurrentDamageTokens.Count);
Assert.AreEqual(0, game.SittingDuck.Zones.ElementAt(2).CurrentDamageTokens.Count);
}
protected string CreateTrack(string token, TrackConfiguration configuration)
{
return(CreateTrack(token, configuration, "Create track"));
}
public void DynamicTrackConfigurationTest()
{
string recordingToken = string.Empty;
string trackTypeStr = string.Empty;
string trackToken = string.Empty;
bool isTrackDeleted = false;
bool isTrackCreated = false;
bool isRecordingCreated = false;
TrackConfiguration deletedTrackConf = null;
RunTest(() =>
{
// A.14 - Selection of Recording for track creation
GetRecordingForTrackCreation(out recordingToken,
out trackTypeStr,
out isRecordingCreated,
out isTrackDeleted, out deletedTrackConf);
TrackType trackType = (trackTypeStr == "Video" ? TrackType.Video :
(trackTypeStr == "Audio" ? TrackType.Audio :
(trackTypeStr == "Metadata" ? TrackType.Metadata : TrackType.Extended)));
// prepare track configuration
var trackConf = new TrackConfiguration();
trackConf.Description = "New Track";
trackConf.TrackType = trackType;
// get initial recordings
GetRecordingsResponseItem[] recordingsInitial = GetRecordings();
Assert(recordingsInitial != null, "Recording list is empty", "Check that recording list is not empty");
// create track
trackToken = CreateTrack(recordingToken, trackConf);
isTrackCreated = true;
// check that created track token is not presented in selected recording (from initial track list)
GetRecordingsResponseItem recordingInitial = recordingsInitial.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
GetTracksResponseItem track = null;
if (recordingInitial.Tracks.Track != null)
{
track = recordingInitial.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track == null,
String.Format("Track (token = {0}) has already presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that new track (token = {0}) wasn't presented in recording (token = {1})", trackToken, recordingToken));
// get updated recordings (after CreateTrack)
GetRecordingsResponseItem[] recordingsUpdated = GetRecordings();
Assert(recordingsUpdated != null, "Recording list is empty", "Check that recording list is not empty");
// check that created track token is presented in selected recording (from updated track list)
GetRecordingsResponseItem recordingUpdated = recordingsUpdated.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
Assert(recordingUpdated != null, "Recording is not found",
string.Format("Check that recording (token = {0}) exists in updated recording list", recordingToken));
GetTracksResponseItem track2 = null;
if (recordingUpdated.Tracks.Track != null)
{
track2 = recordingUpdated.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track2 != null,
String.Format("Track (token = {0}) isn't presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that new track (token = {0}) is presented in recording (token = {1})", trackToken, recordingToken));
// check track parameters
CheckRecordingTrack(track2, trackConf);
// check that all other tracks for initial selected recording
// have the same parameters as for updated selected recording
GetTracksResponseItem[] trackInitialOther = null;
if (recordingInitial.Tracks.Track != null)
{
trackInitialOther = (recordingInitial.Tracks.Track.Where(tr => tr.TrackToken != trackToken)).ToArray <GetTracksResponseItem>();
}
GetTracksResponseItem[] trackUpdatedOther = null;
if (recordingUpdated.Tracks.Track != null)
{
trackUpdatedOther = (recordingUpdated.Tracks.Track.Where(tr => tr.TrackToken != trackToken)).ToArray <GetTracksResponseItem>();
}
if (trackInitialOther != null && trackInitialOther.Length == 0)
{
trackInitialOther = null;
}
if (trackUpdatedOther != null && trackUpdatedOther.Length == 0)
{
trackUpdatedOther = null;
}
CheckTrackListChanged(trackInitialOther, trackUpdatedOther,
string.Format("Check that initial track list of recording (token = {0}) wasn't changed", recordingInitial.RecordingToken));
// check that all other recordings have the same parameters value
// as before creating a track
GetRecordingsResponseItem[] recordingsInitialOther = null;
if (recordingsInitial != null)
{
recordingsInitialOther = (recordingsInitial.Where(rec => rec.RecordingToken != recordingToken)).ToArray <GetRecordingsResponseItem>();
}
GetRecordingsResponseItem[] recordingsUpdatedOther = null;
if (recordingsUpdated != null)
{
recordingsUpdatedOther = (recordingsUpdated.Where(rec => rec.RecordingToken != recordingToken)).ToArray <GetRecordingsResponseItem>();
}
if (recordingsInitialOther != null && recordingsInitialOther.Length == 0)
{
recordingsInitialOther = null;
}
if (recordingsUpdatedOther != null && recordingsUpdatedOther.Length == 0)
{
recordingsUpdatedOther = null;
}
// check that after CreateTrack
// all tracks of all other recordings are the same
CheckTrackListChanged_AllRecordings(recordingsInitialOther, recordingsUpdatedOther,
"Check that initial track list of other existing recordings wasn't changed after CreateTrack");
// delete track
DeleteTrack(recordingToken, trackToken);
isTrackCreated = false;
// get updated recordings (after DeleteTrack)
GetRecordingsResponseItem[] recordingsUpdated2 = GetRecordings();
Assert(recordingsUpdated2 != null, "Recording list is empty", "Check that recording list is not empty");
// check that deleted track token is no longer presented in selected recording (from updated track list after deletion)
GetRecordingsResponseItem recordingUpdated2 = recordingsUpdated2.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
Assert(recordingUpdated2 != null, "Recording is not found",
string.Format("Check that recording (token = {0}) exists in updated recording list", recordingToken));
GetTracksResponseItem track3 = null;
if (recordingUpdated2.Tracks.Track != null)
{
track3 = recordingUpdated2.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track3 == null,
String.Format("Track (token = {0}) is still presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that deleted track (token = {0}) is no longer presented in recording (token = {1})", trackToken, recordingToken));
// check that before CreateTrack all other tracks in selected recording
// have the same parameters as after DeleteTrack
CheckTrackListChanged(recordingInitial.Tracks.Track, recordingUpdated2.Tracks.Track,
string.Format("Check that initial track list of recording (token = {0}) wasn't changed", recordingInitial.RecordingToken));
// check that afteer CreateTrack + DeleteTrack
// all tracks of all recordings are the same
CheckTrackListChanged_AllRecordings(recordingsInitial, recordingsUpdated2,
"Check that initial track list of existing recordings wasn't changed");
}, () =>
{
if (isTrackCreated || isRecordingCreated || isTrackDeleted)
{
LogTestEvent(string.Format("Restoring the initial settings...{0}", Environment.NewLine));
}
// reverting changes made during test
if (isTrackCreated && !string.IsNullOrEmpty(trackToken))
{
DeleteTrack(recordingToken, trackToken);
}
// reverting changes made during A.14
if (isRecordingCreated && !string.IsNullOrEmpty(recordingToken))
{
DeleteRecording(recordingToken);
}
// reverting changes made during A.14
if (isTrackDeleted && !string.IsNullOrEmpty(recordingToken) && deletedTrackConf != null)
{
CreateTrack(recordingToken, deletedTrackConf);
}
});
}
public static void Seed(AllTheWayUpDbContext context)
{
ArtistConfiguration.Seed(context);
TrackConfiguration.Seed(context);
}
public static void EzraDoubleActionsCampaignMission1()
{
var players = new List <Player>
{
CreateBluePlayerDoubleActionsCampaignMission1(),
CreateGreenPlayerDoubleActionsCampaignMission1(),
CreateYellowPlayerDoubleActionsCampaignMission1(),
CreateRedPlayerDoubleActionsCampaignMission1()
};
var externalTracksByZone = new Dictionary <ZoneLocation, TrackConfiguration>
{
{ ZoneLocation.Blue, TrackConfiguration.Track6 },
{ ZoneLocation.White, TrackConfiguration.Track2 },
{ ZoneLocation.Red, TrackConfiguration.Track5 },
};
const TrackConfiguration internalTrack = TrackConfiguration.Track7;
var armoredGrappler = new ArmoredGrappler();
armoredGrappler.SetInitialPlacement(1, ZoneLocation.Blue);
var meteoroid = new Meteoroid();
meteoroid.SetInitialPlacement(4, ZoneLocation.Blue);
var dimensionSpider = new DimensionSpider();
dimensionSpider.SetInitialPlacement(2, ZoneLocation.White);
var gunship = new Gunship();
gunship.SetInitialPlacement(6, ZoneLocation.White);
var asteroid = new Asteroid();
asteroid.SetInitialPlacement(5, ZoneLocation.Red);
var destroyer = new Destroyer();
destroyer.SetInitialPlacement(8, ZoneLocation.Red);
var externalThreats = new ExternalThreat[] { armoredGrappler, meteoroid, dimensionSpider, gunship, asteroid, destroyer };
var shambler = new Shambler();
shambler.SetInitialPlacement(4);
var internalThreats = new InternalThreat[] { shambler };
var bonusThreats = new Threat[0];
var game = new Game(players, internalThreats, externalThreats, bonusThreats, externalTracksByZone, internalTrack, null);
game.StartGame();
try
{
for (var currentTurn = 0; currentTurn < game.NumberOfTurns + 1; currentTurn++)
{
game.PerformTurn();
}
}
catch (LoseException loseException)
{
Assert.AreEqual(destroyer, loseException.Threat);
Assert.AreEqual(GameStatus.Lost, game.GameStatus);
Assert.AreEqual(0, game.SittingDuck.BlueZone.TotalDamage);
Assert.AreEqual(9, game.SittingDuck.RedZone.TotalDamage);
Assert.AreEqual(0, game.SittingDuck.WhiteZone.TotalDamage);
Assert.AreEqual(6, game.ThreatController.DefeatedThreats.Count());
Assert.AreEqual(0, game.ThreatController.SurvivedThreats.Count());
Assert.AreEqual(0, players.Count(player => player.IsKnockedOut));
Assert.AreEqual(0, game.SittingDuck.BlueZone.CurrentDamageTokens.Count);
Assert.AreEqual(6, game.SittingDuck.RedZone.CurrentDamageTokens.Count);
Assert.AreEqual(0, game.SittingDuck.WhiteZone.CurrentDamageTokens.Count);
}
}
public override void SetTrackConfiguration(string RecordingToken, string TrackToken, TrackConfiguration TrackConfiguration)
{
throw new NotImplementedException();
}
protected Track(TrackConfiguration trackConfiguration)
{
ThreatPositions = new Dictionary <T, int>();
breakpoints = trackConfiguration.TrackBreakpoints().ToDictionary(breakpoint => breakpoint.Position);
sections = trackConfiguration.TrackSections();
}
public override string CreateTrack(string RecordingToken, TrackConfiguration TrackConfiguration)
{
throw new NotImplementedException();
}
public ExternalTrack(TrackConfiguration trackConfiguration, Zone zone) : base(trackConfiguration)
{
Zone = zone;
}
public static void EzraDoubleActionsCampaignMission2()
{
var players = new List <Player>
{
CreateBluePlayerDoubleActionsCampaignMission2(),
CreateGreenPlayerDoubleActionsCampaignMission2(),
CreateYellowPlayerDoubleActionsCampaignMission2(),
CreateRedPlayerDoubleActionsCampaignMission2()
};
var externalTracksByZone = new Dictionary <ZoneLocation, TrackConfiguration>
{
{ ZoneLocation.Blue, TrackConfiguration.Track7 },
{ ZoneLocation.White, TrackConfiguration.Track2 },
{ ZoneLocation.Red, TrackConfiguration.Track5 }
};
const TrackConfiguration internalTrack = TrackConfiguration.Track4;
var interstellarOctopus = new InterstellarOctopus();
interstellarOctopus.SetInitialPlacement(3, ZoneLocation.Blue);
var meteoroid = new Meteoroid();
meteoroid.SetInitialPlacement(8, ZoneLocation.Blue);
var amoeba = new Amoeba();
amoeba.SetInitialPlacement(2, ZoneLocation.White);
var stealthFighter = new StealthFighter();
stealthFighter.SetInitialPlacement(4, ZoneLocation.White);
var spinningSaucer = new SpinningSaucer();
spinningSaucer.SetInitialPlacement(7, ZoneLocation.White);
var armoredGrappler = new ArmoredGrappler();
armoredGrappler.SetInitialPlacement(1, ZoneLocation.Red);
var externalThreats = new ExternalThreat[] { interstellarOctopus, meteoroid, amoeba, stealthFighter, spinningSaucer, armoredGrappler };
var commandosB = new CommandosB();
commandosB.SetInitialPlacement(5);
var hackedShieldsB = new HackedShieldsB();
hackedShieldsB.SetInitialPlacement(8);
var internalThreats = new InternalThreat[] { commandosB, hackedShieldsB };
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(2, game.SittingDuck.BlueZone.TotalDamage);
Assert.AreEqual(0, game.SittingDuck.RedZone.TotalDamage);
Assert.AreEqual(5, game.SittingDuck.WhiteZone.TotalDamage);
Assert.AreEqual(6, game.ThreatController.DefeatedThreats.Count());
Assert.AreEqual(2, game.ThreatController.SurvivedThreats.Count());
Assert.AreEqual(0, players.Count(player => player.IsKnockedOut));
Assert.AreEqual(2, game.SittingDuck.BlueZone.CurrentDamageTokens.Count);
Assert.AreEqual(0, game.SittingDuck.RedZone.CurrentDamageTokens.Count);
Assert.AreEqual(5, game.SittingDuck.WhiteZone.CurrentDamageTokens.Count);
}
internal Track(TrackConfiguration trackConfiguration)
{
Breakpoints = trackConfiguration.TrackBreakpoints();
Sections = trackConfiguration.TrackSections();
TrackConfiguration = trackConfiguration;
}
public static IDictionary <int, TrackBreakpointType> TrackBreakpoints(this TrackConfiguration trackConfiguration)
{
switch (trackConfiguration)
{
case TrackConfiguration.Track1:
return(new Dictionary <int, TrackBreakpointType>
{
{ 5, TrackBreakpointType.X },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track2:
return(new Dictionary <int, TrackBreakpointType>
{
{ 8, TrackBreakpointType.X },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track3:
return(new Dictionary <int, TrackBreakpointType>
{
{ 8, TrackBreakpointType.X },
{ 3, TrackBreakpointType.Y },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track4:
return(new Dictionary <int, TrackBreakpointType>
{
{ 9, TrackBreakpointType.X },
{ 5, TrackBreakpointType.Y },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track5:
return(new Dictionary <int, TrackBreakpointType>
{
{ 11, TrackBreakpointType.X },
{ 7, TrackBreakpointType.Y },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track6:
return(new Dictionary <int, TrackBreakpointType>
{
{ 10, TrackBreakpointType.X },
{ 7, TrackBreakpointType.Y },
{ 3, TrackBreakpointType.Y },
{ 1, TrackBreakpointType.Z }
});
case TrackConfiguration.Track7:
return(new Dictionary <int, TrackBreakpointType>
{
{ 12, TrackBreakpointType.X },
{ 8, TrackBreakpointType.Y },
{ 5, TrackBreakpointType.Y },
{ 1, TrackBreakpointType.Z }
});
default:
throw new InvalidOperationException();
}
}
public InternalTrack(TrackConfiguration trackConfiguration) : base(trackConfiguration)
{
}
public static List <Component> TrackMaker(SubAssemblyBase subassembly, int PanelCount, int positions, TrackConfiguration configuration)
{
List <Component> result = new List <Component>();
switch (configuration)
{
case TrackConfiguration.Telescoping:
#region Track Blades
for (int i = 0; i < PanelCount; i++)
{
Component p = new Component(3345, "Blade-" + i.ToString(), subassembly, 1, subassembly.SubAssemblyWidth + 3.0m);
result.Add(p);
}
#endregion
break;
case TrackConfiguration.BiComponenting:
break;
default:
break;
}
return(result);
}
public static IList <TrackSection> TrackSections(this TrackConfiguration trackConfiguration)
{
switch (trackConfiguration)
{
case TrackConfiguration.Track1:
return(new[]
{
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track2:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 1
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track3:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 2
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track4:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 3
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track5:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 4
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track6:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 5
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
case TrackConfiguration.Track7:
return(new[]
{
new TrackSection {
DistanceFromShip = 3, Length = 6
},
new TrackSection {
DistanceFromShip = 2, Length = 5
},
new TrackSection {
DistanceFromShip = 1, Length = 5
}
});
default:
throw new InvalidOperationException();
}
}
