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 NoCardsTest()
{
var objectUnderTest = new PointsCalculator();
var result = objectUnderTest.GetPoints(Enumerable.Empty <Card>().ToList());
Assert.True(result == 0);
}
public ObjectsConnector(VirtualControl host, ObjectPort sPort, ObjectPort ePort) : base(host, sPort, ePort)
{
Wire.Background = sPort.StrokeBrush;
Host = host;
Type = ConnectorTypes.Object;
StartPort = sPort;
ePort.Linked = true;
sPort.Linked = true;
EndPort = ePort;
StartPort.CalcOrigin();
EndPort.CalcOrigin();
Sp = PointsCalculator.PortOrigin(StartPort);
Ep = PointsCalculator.PortOrigin(EndPort);
Wire.StartPoint = Sp;
Wire.EndPoint = Ep;
ePort.Linked = true;
sPort.Linked = true;
Host.Children.Add(Wire);
sPort.ParentNode.PropertyChanged += ParentNodeOnPropertyChanged;
ePort.ParentNode.PropertyChanged += ParentNodeOnPropertyChanged;
ePort.Data.Value = sPort.Data.Value;
StartPort = sPort;
EndPort = ePort;
Wire.ContextMenu = wireMenu();
}
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 Awake()
{
//prepare
Setup("[Points Calculation Test");
var calculator = new PointsCalculator();
//execute
var result1 = calculator.Calculate(3, 3, 2, 3);
//assert
Assert(() => result1).ShouldBe(6).Because("We send the count and min count as 3").Run();
//execute
var result2 = calculator.Calculate(4, 3, 2, 3);
//assert
Assert(() => result2).ShouldBe(12).Because("1 more element multiplied by 3 should give 6 + 6").Run();
//execute
var result3 = calculator.Calculate(10, 2, 3, 4);
//assert
Assert(() => result3).ShouldBe(102)
.Because("2 items multiplied by 3, and 8 bonus items multiplied by (3*4) gives 102").Run();
}
public void ParentNodeOnPropertyChanged(Port s, Port e)
{
var sp = PointsCalculator.PortOrigin(s);
var ep = PointsCalculator.PortOrigin(e);
StartPoint = sp;
EndPoint = ep;
}
public void StandardDeckTest()
{
var objectUnderTest = new PointsCalculator();
var entireDeck = new StandardDeck();
var result = objectUnderTest.GetPoints(entireDeck.Cards.Cards);
Assert.True(result == 96);
}
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));
}
public void ParentNodeOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
{
StartPort.CalcOrigin();
EndPort.CalcOrigin();
Sp = PointsCalculator.PortOrigin(StartPort);
Ep = PointsCalculator.PortOrigin(EndPort);
Wire.StartPoint = Sp;
Wire.EndPoint = Ep;
}
public TestContext()
{
ContextProvider.Subscribe(this);
OnPause = new UnityEvent <bool>();
PointsCalculator = new PointsCalculator();
AssetLoader = new AssetLoader();
SequenceChecker = new DefaultSequenceChecker(3);
}
public void SingleCardTest()
{
var objectUnderTest = new PointsCalculator();
var result = objectUnderTest.GetPoints(new List <Card> {
new Card {
Rank = "2", Suit = Constants.Suits.Clubs
}
});
Assert.True(result == 1);
}
public void AllStrikesButLastSpare_MatchExpectations(int frameNumber, int expectedPoints)
{
var game = Enumerable.Range(1, 9).Select(n => new FramePoints(10)).ToList();
game.Add(new FramePoints(9, 1, 1));
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(frameNumber);
points.Should().Be(expectedPoints);
}
public void SpareAndAdditionalRuns_SumOnly3rdRun()
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(5, 5, 2, 1),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(2);
points.Should().Be(17);
}
public void SpareAndNextFrame1_FullPoints()
{
var game = new List <FramePoints>
{
new FramePoints(3, 7),
new FramePoints(3, 2),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(2);
points.Should().Be(18);
}
public void StrikeAndAdditionalRuns_SumAll()
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(10, 0, 2, 1),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(2);
points.Should().Be(18);
}
public void SpareWithNoContinuation_OnlyActualPoints()
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(5, 5),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(2);
points.Should().Be(15);
}
public void TwoCardsWithABonusCardTest()
{
var objectUnderTest = new PointsCalculator();
var result = objectUnderTest.GetPoints(new List <Card> {
new Card {
Rank = "2", Suit = Constants.Suits.Clubs
},
new Card {
Rank = "J", Suit = Constants.Suits.Clubs
}
});
Assert.True(result == 3);
}
public void StrikeAndNextFrame_FullPoints()
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(10, 0),
new FramePoints(4, 2),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(2);
points.Should().Be(21);
}
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 RecalculateAllPointsForGamesWithNoPlayTime()
{
//--arrange
using (var dbContext = new NemeStatsDbContext())
{
using (var dataContext = new NemeStatsDataContext(dbContext, new SecuredEntityValidatorFactory()))
{
var weightTierCalculator = new WeightTierCalculator();
var weightBonusCalculator = new WeightBonusCalculator(weightTierCalculator);
var gameDurationBonusCalculator = new GameDurationBonusCalculator();
var pointsCalculator = new PointsCalculator(weightBonusCalculator, gameDurationBonusCalculator);
//--act
new GlobalPointsRecalculator().RecalculateAllPointsForGamesWithNoPlayTime(dataContext, pointsCalculator);
}
}
}
private void OnMouseLeftButtonDown(object o, MouseButtonEventArgs mouseButtonEventArgs)
{
if (mouseButtonEventArgs.LeftButton != MouseButtonState.Pressed)
{
return;
}
CalcOrigin();
Host.TempConn = new Wire
{
Background = StrokeBrush,
StartPoint = PointsCalculator.PortOrigin(this),
EndPoint = PointsCalculator.PortOrigin(this)
};
Host.TemExecPort = this;
Host.WireMode = WireMode.FirstPortSelected;
Host.MouseMode = MouseMode.DraggingPort;
Host.Children.Add(Host.TempConn);
mouseButtonEventArgs.Handled = true;
}
public Context()
{
ContextProvider.Subscribe(this);
OnPause = new UnityEvent <bool>();
LocalStorage = new LocalStorage();
AssetLoader = new AssetLoader();
GameSettings = AssetLoader.Load <GameSettings>($"Settings/{nameof(GameSettings)}");
SoundController = AssetLoader.LoadAndInstantiate <SoundController>($"Controllers/{nameof(SoundController)}");
InputController = AssetLoader.LoadAndInstantiate <InputController>($"Controllers/{nameof(InputController)}");
//since this creation is in context, we can easily change to another script with another formula
PointsCalculator = new PointsCalculator();
SequenceChecker = new DefaultSequenceChecker(GameSettings.MinItemsCount);
GameController = AssetLoader.LoadAndInstantiate <GameController>($"Controllers/{nameof(GameController)}");
GameController.Initialize(GameSettings, InputController, LocalStorage,
SoundController, SequenceChecker, PointsCalculator);
}
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));
}
public void InvalidFrameNumber_ThrowsOutOfRange(int frameNumber)
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(4, 5),
new FramePoints(6, 4),
new FramePoints(5, 5),
new FramePoints(10, 0),
new FramePoints(0, 1),
new FramePoints(7, 3),
new FramePoints(6, 4),
new FramePoints(10, 0),
new FramePoints(2, 8, 6),
};
var calculator = new PointsCalculator(game);
Action getPoints = () => calculator.GetPointsUpTo(frameNumber);
getPoints.Should().Throw <ArgumentOutOfRangeException>($"frame number must be from 1 to 10 but is {frameNumber}");
}
public void AFrame_MatchExpectations(int frameNumber, int expectedPoints)
{
var game = new List <FramePoints>
{
new FramePoints(1, 4),
new FramePoints(4, 5),
new FramePoints(6, 4),
new FramePoints(5, 5),
new FramePoints(10, 0),
new FramePoints(0, 1),
new FramePoints(7, 3),
new FramePoints(6, 4),
new FramePoints(10, 0),
new FramePoints(2, 8, 6),
};
var calculator = new PointsCalculator(game);
var points = calculator.GetPointsUpTo(frameNumber);
points.Should().Be(expectedPoints);
}
