public void ItGivesTwoPointsToEachPlayerIfEveryoneLost()
{
int losingRank = 2;
List <PlayerRank> playerRanks = new List <PlayerRank>();
playerRanks.Add(new PlayerRank
{
PlayerId = 11,
GameRank = losingRank
});
playerRanks.Add(new PlayerRank
{
PlayerId = 132,
GameRank = losingRank
});
playerRanks.Add(new PlayerRank
{
PlayerId = 13,
GameRank = losingRank
});
playerRanks.Add(new PlayerRank
{
PlayerId = 135,
GameRank = losingRank
});
Dictionary <int, int> actualPointsAwarded = PointsCalculator.CalculatePoints(playerRanks);
Assert.That(actualPointsAwarded.All(x => x.Value == 2));
}
public void ItWorksForOneWinnerAndTwoLosers()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
int winningPlayerId1 = 123;
int losingPlayerId1 = 124;
int losingPlayerId2 = 456;
playerRanks.Add(new PlayerRank
{
GameRank = FIRST_PLACE,
PlayerId = winningPlayerId1
});
playerRanks.Add(new PlayerRank
{
GameRank = SECOND_PLACE,
PlayerId = losingPlayerId1
});
playerRanks.Add(new PlayerRank
{
GameRank = SECOND_PLACE,
PlayerId = losingPlayerId2
});
Dictionary <int, int> actualPointsAwarded = PointsCalculator.CalculatePoints(playerRanks);
int expectedWinnerPoints = 15;
int expectedLoserPoints = 8;
Assert.That(actualPointsAwarded[winningPlayerId1], Is.EqualTo(expectedWinnerPoints));
Assert.That(actualPointsAwarded[losingPlayerId1], Is.EqualTo(expectedLoserPoints));
Assert.That(actualPointsAwarded[losingPlayerId2], Is.EqualTo(expectedLoserPoints));
}
public void CalculatePoints_Test(int killedEnemies, int killedAllies, int multiplicator, int expectedPoints)
{
var pointsCalculator = new PointsCalculator();
var points = pointsCalculator.CalculatePoints(killedEnemies, killedAllies, multiplicator);
Assert.That(points, Is.EqualTo(expectedPoints));
}
internal virtual List <PlayerGameResult> TransformNewlyCompletedGamePlayerRanksToPlayerGameResults(NewlyCompletedGame newlyCompletedGame)
{
var pointsDictionary = PointsCalculator.CalculatePoints(newlyCompletedGame.PlayerRanks);
var playerGameResults = newlyCompletedGame.PlayerRanks
.Select(playerRank => new PlayerGameResult()
{
PlayerId = playerRank.PlayerId,
GameRank = playerRank.GameRank,
NemeStatsPointsAwarded = pointsDictionary[playerRank.PlayerId],
PointsScored = playerRank.PointsScored
})
.ToList();
return(playerGameResults);
}
public void ItWorksForTwoWinnersTwoSecondPlayerAndOneLastPlace()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
int winningPlayerId1 = 100;
int winningPlayerId2 = 101;
int secondPlacePlayer1 = 200;
int secondPlacePlayer2 = 201;
int thirdPlacePlayerId = 300;
playerRanks.Add(new PlayerRank
{
GameRank = FIRST_PLACE,
PlayerId = winningPlayerId1
});
playerRanks.Add(new PlayerRank
{
GameRank = FIRST_PLACE,
PlayerId = winningPlayerId2
});
playerRanks.Add(new PlayerRank
{
GameRank = SECOND_PLACE,
PlayerId = secondPlacePlayer1
});
playerRanks.Add(new PlayerRank
{
GameRank = SECOND_PLACE,
PlayerId = secondPlacePlayer2
});
playerRanks.Add(new PlayerRank
{
GameRank = THIRD_PLACE,
PlayerId = thirdPlacePlayerId
});
Dictionary <int, int> actualPointsAwarded = PointsCalculator.CalculatePoints(playerRanks);
int expectedFirstPlacePoints = 18;
int expectedSecondPlacePoints = 7;
int expectedThirdPlacePoints = 3;
Assert.That(actualPointsAwarded[winningPlayerId1], Is.EqualTo(expectedFirstPlacePoints));
Assert.That(actualPointsAwarded[winningPlayerId2], Is.EqualTo(expectedFirstPlacePoints));
Assert.That(actualPointsAwarded[secondPlacePlayer1], Is.EqualTo(expectedSecondPlacePoints));
Assert.That(actualPointsAwarded[secondPlacePlayer2], Is.EqualTo(expectedSecondPlacePoints));
Assert.That(actualPointsAwarded[thirdPlacePlayerId], Is.EqualTo(expectedThirdPlacePoints));
}
public void ItThrowsAnArgumentExceptionIfThereAreMoreThan25Players()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
for (int i = 0; i < PlayerRankValidator.MAXIMUM_NUMBER_OF_PLAYERS + 1; i++)
{
playerRanks.Add(new PlayerRank
{
PlayerId = i,
GameRank = i + 1
});
}
Exception actualException = Assert.Throws <ArgumentException>(() => PointsCalculator.CalculatePoints(playerRanks));
Assert.That(actualException.Message, Is.EqualTo("There can be no more than 25 players."));
}
public void ItGivesOutTenPointsToEachPlayerWhenEveryoneWins()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
for (int i = 0; i < 13; i++)
{
playerRanks.Add(new PlayerRank
{
GameRank = FIRST_PLACE,
PlayerId = i
});
}
Dictionary <int, int> actualPointsAwarded = PointsCalculator.CalculatePoints(playerRanks);
Assert.That(actualPointsAwarded.All(x => x.Value == 10));
}
public void ItThrowsAnArgumentExceptionIfAGivenPlayerHasMultipleRanks()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
playerRanks.Add(new PlayerRank
{
PlayerId = 1,
GameRank = 1
});
playerRanks.Add(new PlayerRank
{
PlayerId = 1,
GameRank = 2
});
Exception actualException = Assert.Throws <ArgumentException>(() => PointsCalculator.CalculatePoints(playerRanks));
Assert.That(actualException.Message, Is.EqualTo("Each player can only have one PlayerRank record but one or more players have duplicate PlayerRank records."));
}
public void ItSetsnemeStatsPointsForEachPlayerGameResult()
{
int playerOneId = 1;
int playerTwoId = 2;
int playerOneGameRank = 1;
int playerTwoGameRank = 2;
List <PlayerRank> playerRanks = new List <PlayerRank>()
{
new PlayerRank()
{
PlayerId = playerOneId,
GameRank = playerOneGameRank
},
new PlayerRank()
{
PlayerId = playerTwoId,
GameRank = playerTwoGameRank
}
};
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
var pointsDictionary = PointsCalculator.CalculatePoints(playerRanks);
int playerOneExpectednemeStatsPoints = pointsDictionary[playerOneId];
ApplicationUser user = new ApplicationUser();
PlayedGame playedGame = autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, this.currentUser);
Assert.AreEqual(playerOneExpectednemeStatsPoints, playedGame.PlayerGameResults
.First(gameResult => gameResult.PlayerId == playerOneId)
.NemeStatsPointsAwarded);
int playerTwoExpectednemeStatsPoints = pointsDictionary[playerTwoId];
Assert.AreEqual(playerTwoExpectednemeStatsPoints, playedGame.PlayerGameResults
.First(gameResult => gameResult.PlayerId == playerTwoId)
.NemeStatsPointsAwarded);
}
public void ItGivesAboutTenPointsPerPlayerWhenRanksClumped(int numberOfPlayers)
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
for (int i = 0; i < numberOfPlayers; i++)
{
playerRanks.Add(new PlayerRank
{
GameRank = (i + 1) % 2,
PlayerId = i
});
}
Dictionary <int, int> actualPointsAwarded = PointsCalculator.CalculatePoints(playerRanks);
//each player could round up at most 1 integer value
int maxPointsAwarded = PointsCalculator.POINTS_PER_PLAYER * numberOfPlayers + numberOfPlayers;
Assert.That(actualPointsAwarded.Sum(x => x.Value), Is.InRange(PointsCalculator.POINTS_PER_PLAYER, maxPointsAwarded));
}
private static void RunSeasonPredictions()
{
var seasons = new[]
{
Season.Season1819,
Season.Season1920,
Season.Season2021,
};
foreach (var season in seasons)
{
Console.WriteLine(Display.Season(season));
var fixtures = FixtureRepository.GetAllCompletedFixtures(season);
foreach (var predictionStrategy in PredictionStrategies)
{
if (predictionStrategy.CanPredict(season))
{
var totalPoints = 0;
foreach (var fixture in fixtures)
{
var predicted = predictionStrategy.PredictScore(fixture, season);
var points = PointsCalculator.CalculatePoints(predicted, fixture.FinalScore);
totalPoints += points;
}
Console.WriteLine($"{predictionStrategy.Name}: {totalPoints}");
}
}
Console.WriteLine();
}
}