public void HaveAName()
{
var sut = new TennisPlayer(2);
Assert.IsNotNull(sut.Name);
Assert.IsNotEmpty(sut.Name);
}
public static void Main(string[] args)
{
TennisPlayer P1 = new TennisPlayer();
P1.GetPlayerDetails();
P1.PrintPlayerDetails();
}
public void DecreaseScoreByOne(int currentScore)
{
var sut = new TennisPlayer(currentScore);
sut.DecreaseScore();
var expectedScore = (TennisScore)(currentScore - 1);
Assert.AreEqual(expectedScore, sut.GetScore());
}
private void changeRoles()
{
TennisPlayer tennisPlayer = this.receiver;
this.receiver = this.launcher;
this.receiver.setProbabilityWin(new ProbabilityWinReceiver());
this.launcher = tennisPlayer;
this.launcher.setProbabilityWin(new ProbabilityWinLauncher());
}
private static void GameResultShouldBe(string expected, TennisPlayer _firstPlayer, TennisPlayer _secondPlayer)
{
var gameScoreboard = new GameScoreBoard(_firstPlayer, _secondPlayer);
// act
var gameResult = gameScoreboard.GetGameResult();
// assert
Assert.AreEqual(expected, gameResult);
}
private void AddTwoPlayers(int player1Score, int player2Score, string player1Name = "", string player2Name = "")
{
_firstPlayer = new TennisPlayer()
{
Score = player1Score, Name = player1Name
};
_secondPlayer = new TennisPlayer()
{
Score = player2Score, Name = player2Name
};
}
static void Main(string[] args)
{
Player player = new TennisPlayer();
player.FirstName = "Walter";
player.LastName = "Olivares";
// player.AssignTeam(new Team { Name = "Santos" });
player.SetCategory(PlayerCategory.Amateur);
Console.Write($"{player.FirstName} {player.LastName} categoria {player.Category}");
Console.ReadLine();
}
private void InitialPlayer(TennisScore homeCurrentScore, TennisScore awayTennisScore)
{
this.HomePlayer = new TennisPlayer()
{
TennisPlayerType = TennisPlayerType.HomePlayer,
TennisCurrentScore = homeCurrentScore
};
this.AwayPlayer = new TennisPlayer()
{
TennisPlayerType = TennisPlayerType.AwayPlayer,
TennisCurrentScore = awayTennisScore
};
}
private void resetAndFillStats()
{
if (this.isFirstPlayerTheLauncher())
{
this.launcher = new Launcher(this.players[0].Name, this.players[0].NumberPlayer);
this.receiver = new Receiver(this.players[1].Name, this.players[1].NumberPlayer);
}
else
{
this.launcher = new Launcher(this.players[1].Name, this.players[1].NumberPlayer);
this.receiver = new Receiver(this.players[0].Name, this.players[0].NumberPlayer);
}
}
public static void LCPExample()
{
//IPlayerTeam player = new FootballPlayer();
Player player = new TennisPlayer();
player.FirstName = "Walter";
player.LastName = "Montillo";
//player.AssignTeam(new Team { Name = "U de Chile" });
player.SetCategory(PlayerCategory.Professional);
WriteLine($"{player.FirstName} {player.LastName} Categoria {player.Category}");
ReadLine();
}
private Boolean manageTieBreak(TennisPlayer playerWonPoint)
{
Boolean hasWon = false;
int position = this.VpositionPlayers[playerWonPoint.NumberPlayer];
int pointsTB = ++this.marker.tieBreak[position];
if (pointsTB >= 7)
{
int pointsTBEnemy = this.marker.tieBreak[this.marker.getPositionPlayerEnemy(position)];
if (pointsTB - 2 >= pointsTBEnemy)
{
hasWon = true;
}
}
return(hasWon);
}
public void Score(TennisPlayer player)
{
TennisPlayer otherPlayer = TennisPlayer.PlayerA;
if (player == TennisPlayer.PlayerA)
otherPlayer = TennisPlayer.PlayerB;
this.scores[player] += 1;
if (this.scores[otherPlayer] != TennisScore.Forty &&
this.scores[player] == TennisScore.Advantage)
{
this.scores[player] = TennisScore.Game;
this.IsGameOver = true;
}
}
public GameScoreBoard(TennisPlayer firstPlayer, TennisPlayer secondPlayer)
{
_firstPlayer = firstPlayer;
_secondPlayer = secondPlayer;
InitGameScoreBoard();
}
private static bool IsTwoPlayerSameScore(TennisPlayer firstPlayer, TennisPlayer secondPlayer)
{
return(firstPlayer.Score == secondPlayer.Score);
}
public static void Main(string[] args)
{
TennisPlayer P1=new TennisPlayer();
P1.GetPlayerDetails();
P1.PrintPlayerDetails();
}
public virtual void Start()
{
tennisPlayer = FindObjectOfType <TennisPlayer> ();
}
public void SetScoreToZeroAsDefault()
{
var sut = new TennisPlayer();
Assert.AreEqual(TennisScore.Love, sut.GetScore());
}
public TennisScore Points(TennisPlayer player)
{
return scores[player];
}
public void When_Players_Are_In_Deuce_One_Player_Scores(TennisPlayer player)
{
TennisGame game = new TennisGame();
TennisPlayer otherPlayer = TennisPlayer.PlayerA;
if (player == TennisPlayer.PlayerA)
otherPlayer = TennisPlayer.PlayerB;
game.Score(player);
game.Score(player);
game.Score(player);
game.Score(otherPlayer);
game.Score(otherPlayer);
game.Score(otherPlayer);
game.Score(otherPlayer);
Assert.That(game.Points(otherPlayer), Is.EqualTo(TennisScore.Advantage));
}
public void When_PlayerA_scores_4times_PointsA_Equals_Game(TennisPlayer player)
{
TennisGame game = new TennisGame();
game.Score(player);
game.Score(player);
game.Score(player);
game.Score(player);
Assert.That(game.Points(player), Is.EqualTo(TennisScore.Game));
}
public void ThrowExceptionWhenInvalidScoreIsIncreased()
{
var sut = new TennisPlayer(5);
Assert.Throws <IndexOutOfRangeException>(() => sut.IncrementScore());
}
public void ReturnCorrectScoreConversion(int score, TennisScore expectedConversion)
{
var sut = new TennisPlayer(score);
Assert.AreEqual(expectedConversion, sut.GetScore());
}
public void Score(TennisPlayer tennisPlayer)
{
scores[tennisPlayer]++;
}
static void Main(string[] args)
{
SortedDictionary <string, TennisPlayer> tennisPlayersByColors = new SortedDictionary <string, TennisPlayer>();
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] inputParams = input.Split('|');
string color = inputParams[0];
if (!tennisPlayersByColors.ContainsKey(color))
{
tennisPlayersByColors[color] = new TennisPlayer();
}
if (inputParams[1] == "name")
{
string playerName = inputParams[2];
tennisPlayersByColors[color].Name = playerName;
}
else if (inputParams[1] == "age")
{
int age = int.Parse(inputParams[2]);
tennisPlayersByColors[color].Age = age;
}
else
{
bool isWin = inputParams[1] == "win";
string opponentName = inputParams[2];
tennisPlayersByColors[color].Opponents.Add(opponentName);
if (isWin)
{
tennisPlayersByColors[color].Wins++;
}
else
{
tennisPlayersByColors[color].Losses++;
}
}
}
int colorsWithoutNeededInfoCount = 0;
foreach (KeyValuePair <string, TennisPlayer> pair in tennisPlayersByColors)
{
string color = pair.Key;
TennisPlayer tennisPlayer = pair.Value;
if (tennisPlayer.Age == -1 || tennisPlayer.Name == string.Empty)
{
colorsWithoutNeededInfoCount++;
}
else
{
Console.WriteLine($"Color: {color}");
Console.WriteLine(tennisPlayer);
}
}
if (colorsWithoutNeededInfoCount == tennisPlayersByColors.Count)
{
Console.WriteLine("No data recovered.");
}
}
private Boolean managePoints(TennisPlayer playerWonPoint)
{
String name = playerWonPoint.Name;
Boolean hasWon = false;
int position = this.VpositionPlayers[playerWonPoint.NumberPlayer];
pointsTennis pointsPlayer = this.marker.Vpoints[position]++;
switch (pointsPlayer)
{
case pointsTennis.Ad:
hasWon = true;
// add game won at the winner
this.marker.addWonGame(position, this.numSet - 1);
if (this.manageSets(name))
{
String typeGame;
if (this.marker.WasThereTieBreak)
{
typeGame = "Tie Break";
this.marker.WasThereTieBreak = false;
int positionWinnerTieBreak = this.marker.PositionPlayerWonLastGame;
String nameWinnerTieBreak;
if ((this.VpositionPlayers[this.getLauncher().NumberPlayer]) == positionWinnerTieBreak)
{
nameWinnerTieBreak = this.getLauncher().Name;
}
else
{
nameWinnerTieBreak = this.getReceiver().Name;
}
this.createEventSet(nameWinnerTieBreak, positionWinnerTieBreak, typeGame);
}
else
{
typeGame = "juego";
this.createEventSet(name, position, typeGame);
}
this.marker.HasFinishedLastSet = true;
}
else
{
this.createEventGame(name);
}
break;
case pointsTennis.forty:
int positionPlayerEnemy = this.marker.getPositionPlayerEnemy(position);
if (this.marker.Vpoints[positionPlayerEnemy] == pointsTennis.Ad)
{
--this.marker.Vpoints[position];
--this.marker.Vpoints[positionPlayerEnemy];
this.createEventPoints(name);
}
else
{
if (this.marker.Vpoints[positionPlayerEnemy] != pointsTennis.forty)
{
hasWon = true;
// add game won at the winner
this.marker.addWonGame(position, this.numSet - 1);
if (this.manageSets(name))
{
String typeGame;
if (this.marker.WasThereTieBreak)
{
typeGame = "Tie Break";
this.marker.WasThereTieBreak = false;
int positionWinnerTieBreak = this.marker.PositionPlayerWonLastGame;
String nameWinnerTieBreak;
if ((this.VpositionPlayers[this.getLauncher().NumberPlayer]) == positionWinnerTieBreak)
{
nameWinnerTieBreak = this.getLauncher().Name;
}
else
{
nameWinnerTieBreak = this.getReceiver().Name;
}
this.createEventSet(nameWinnerTieBreak, positionWinnerTieBreak, typeGame);
}
else
{
typeGame = "juego";
this.createEventSet(name, position, typeGame);
}
this.marker.HasFinishedLastSet = true;
}
else
{
this.createEventGame(name);
}
}
else
{
this.createEventPoints(name);
}
}
break;
default:
this.createEventPoints(name);
break;
}
return(hasWon);
}
