public void SetEfficiencyScore(IBattleAttribute battle, IWrittenByAttribute writtenBy, double efficiencyScore)
{
if (HasBattle(battle))
{
IBattleOutcome battleOutcome = GetBattleOutcome(battle);
//battleOutcome.SetEfficiencyScore(writtenBy, efficiencyScore);
}
}
private static void BenchmarkBattle(int index)
{
SelectedBattle = Factory.Get <IBattleCollection>().Get(index);
List <IPlayerBattleResult> battleResults = Factory.Get <IBenchmarkEngine>().PerformBenchmarking(SelectedBattle);
IEfficiencyCalculator efficiencyCalculator = Factory.Get <IEfficiencyCalculator>();
IEfficiencyRankCollection ranks = efficiencyCalculator.RankBattleResults(battleResults);
PrintBenchmarkingResults(ranks, efficiencyCalculator);
}
public void CreateBattle(IBattleAttribute battle, ISenseiAttribute sensei)
{
if (!HasBattle(battle))
{
IBattleOutcome battleOutcome = Factory.Get <IBattleOutcome>();
battleOutcome.Battle = battle;
battleOutcome.Sensei = sensei;
battles.Add(battleOutcome);
}
}
public void Run(IWrittenByAttribute writtenBy, IBattleAttribute battle)
{
Type[] allBattleTests = reflectionUtility.LoadTypesWithAttribute <WrittenByAttribute>("SamuraiDojo.Test")
.Where(test => attributeUtility.GetAttribute <WrittenByAttribute>(test) == writtenBy)?.ToArray();
Type battleTest = allBattleTests
.Where(testClass => attributeUtility.GetAttribute <UnderTestAttribute>(testClass).Type.FullName == battle.Type.FullName).FirstOrDefault();
RunTests(battleTest);
}
private void AssignSenseisToBattles()
{
// Load up all of the battles, assign their sensei, and send to the repository
Type[] types = reflectionUtility.LoadTypesWithAttribute <BattleAttribute>("SamuraiDojo");
foreach (Type type in types)
{
IBattleAttribute battle = attributeUtility.GetAttribute <BattleAttribute>(type);
ISenseiAttribute sensei = attributeUtility.GetAttribute <SenseiAttribute>(type);
battleRepository.CreateBattle(battle, sensei);
}
}
private void SetPreTestAction(ITestRunner testRunner)
{
testRunner.PreTest = (context) =>
{
ISenseiAttribute sensei = attributeUtility.GetAttribute <SenseiAttribute>(context.ClassUnderTest);
IBattleAttribute battle = attributeUtility.GetAttribute <BattleAttribute>(context.ClassUnderTest);
battle.Sensei = sensei;
playerRepository.CreatePlayer(sensei.Name);
battleRepository.CreateBattle(battle, sensei);
};
}
private void Load()
{
Type[] battleTypes =
reflectionUtility.LoadTypesWithAttribute <BattleAttribute>("SamuraiDojo")
.Where(type => !attributeUtility.HasAttribute <WrittenByAttribute>(type))
.OrderByDescending(type => attributeUtility.GetAttribute <BattleAttribute>(type).Deadline).ToArray();
for (int i = 0; i < battleTypes.Length; i++)
{
IBattleAttribute battleAttribute = attributeUtility.GetAttribute <BattleAttribute>(battleTypes[i]);
battleAttribute.Type = battleTypes[i];
All.Add(battleAttribute);
}
}
public List <IPlayerBattleResult> PerformBenchmarking(IBattleAttribute battle)
{
Summary summary = StartBenchmarking(benchmarkMap[battle.Type.Name]);
List <IPlayerBattleResult> battleResults = new List <IPlayerBattleResult>();
foreach (BenchmarkCase benchmark in summary.BenchmarksCases)
{
battleResults.Add(ProcessCase(benchmark, summary));
}
battleResults.OrderBy(result => result.Efficiency.AverageExecutionTime);
return(battleResults);
}
public void AssignAwardToPlayer(IWrittenByAttribute player, IBattleAttribute battle, IBonusPointsAttribute award)
{
if (HasBattle(battle))
{
IBattleOutcome battleOutcome = GetBattleOutcome(battle);
battleOutcome.AddAward(player, award);
}
else
{
IBattleOutcome battleOutcome = Factory.Get <IBattleOutcome>();
battleOutcome.Battle = battle;
battleOutcome.AddAward(player, award);
battles.Add(battleOutcome);
}
}
public void GrantPointsToPlayer(IBattleAttribute battle, IWrittenByAttribute writtenBy, int points = 1)
{
if (HasBattle(battle))
{
IBattleOutcome battleOutcome = GetBattleOutcome(battle);
battleOutcome.AddPoint(writtenBy, points);
}
else
{
IBattleOutcome battleResults = Factory.Get <IBattleOutcome>();
battleResults.Battle = battle;
battleResults.AddPoint(writtenBy, points);
battles.Add(battleResults);
}
}
private void SetPassedTestAction(ITestRunner testRunner)
{
testRunner.OnTestPass = (context) =>
{
IBattleAttribute battle = attributeUtility.GetAttribute <BattleAttribute>(context.ClassUnderTest);
ISenseiAttribute sensei = attributeUtility.GetAttribute <SenseiAttribute>(context.ClassUnderTest);
if (!sensei.Name.EqualsIgnoreCase(context.WrittenBy.Name))
{
int points = 1;
playerRepository.AddPointToHistoricalTotal(context.WrittenBy.Name, context.ClassUnderTest, points);
battleRepository.GrantPointsToPlayer(battle, context.WrittenBy, points);
}
};
}
private void ProcessAwards(Type battleType, List <IBonusPointsAttribute> awards)
{
IWrittenByAttribute player = attributeUtility.GetAttribute <WrittenByAttribute>(battleType);
IBattleAttribute battle = attributeUtility.GetAttribute <BattleAttribute>(battleType);
int bonusPoints = 0;
foreach (IBonusPointsAttribute award in awards)
{
bonusPoints += award.Points;
battleRepository.AssignAwardToPlayer(player, battle, award);
}
playerRepository.AddPointToHistoricalTotal(player.Name, battle.Type, bonusPoints);
battleRepository.GrantPointsToPlayer(battle, player, bonusPoints);
}
public bool HasBattle(IBattleAttribute battle)
{
bool hasBattle = GetBattleOutcome(battle) != null;
return(hasBattle);
}
public IBattleOutcome GetBattleOutcome(IBattleAttribute battle)
{
IBattleOutcome results = battles.Where((x) => x.Battle.Equals(battle))?.FirstOrDefault();
return(results);
}
