/// <summary>
/// Add a new point to this set
/// </summary>
/// <param name="newPoint"></param>
public void Add(TennisPoint newPoint)
{
//Update statistics
Statistics.Add(newPoint);
//Start new game if necessary
if (currentGame() != null)
{
if (currentGame().State == TennisGame.StateEnum.sFinished)
{
StartNewGame();
}
}
else
{
StartNewGame();
}
//Add this new point to the game
if (currentGame().GetType() == typeof(TennisTiebreak))
{
TennisTiebreak currentTiebreak = (TennisTiebreak)currentGame();
currentTiebreak.Add(newPoint);
}
else
{
currentGame().Add(newPoint);
}
//Check the score if the game is finished
if (currentGame().State == TennisGame.StateEnum.sFinished)
{
RebuildScore();
//Check if there is a winner for this set
int GamesPerSet = PartOf.NumberGamesPerSet;
if ((ScoreContestant1 >= GamesPerSet && ScoreContestant2 < ScoreContestant1 - 1) ||
(ScoreContestant2 >= GamesPerSet && ScoreContestant1 < ScoreContestant2 - 1) ||
(currentGame().GetType() == typeof(TennisTiebreak)))
{
Duration.End();
Winner = currentGame().Winner;
}
if (Winner == 0)
{
StartNewGame();
}
}
}
public TennisPoint Undo()
{
if (Points.Count == 0)
{
return(null); // can't undo.
}
TennisPoint PointUndone = Points.Last();
Points.Remove(PointUndone);
State = StateEnum.sProgress;
Winner = 0;
RebuildScore();
return(PointUndone);
}
public void ReadXmlBase(System.Xml.XmlReader reader, String Node)
{
String _ID = reader.GetAttribute("ID");
String _Winner = reader.GetAttribute("Winner");
String _Server = reader.GetAttribute("Server");
String _Receiver = reader.GetAttribute("Receiver");
String _PointsServer = reader.GetAttribute("PointsServer");
String _PointsReceiver = reader.GetAttribute("PointsReceiver");
String _ScoreServer = reader.GetAttribute("ScoreServer");
String _ScoreReceiver = reader.GetAttribute("ScoreReceiver");
String _State = reader.GetAttribute("State");
String _StartTime = reader.GetAttribute("StartTime");
String _EndTime = reader.GetAttribute("EndTime");
String _PointsPerGame = reader.GetAttribute("PointsPerGame");
ID = long.Parse(_ID);
Winner = int.Parse(_Winner);
Server = int.Parse(_Server);
Receiver = int.Parse(_Receiver);
PointsServer = int.Parse(_PointsServer);
PointsReceiver = int.Parse(_PointsReceiver);
ScoreServer = (ScoreEnum)System.Enum.Parse(typeof(ScoreEnum), _ScoreServer);
ScoreReceiver = (ScoreEnum)System.Enum.Parse(typeof(ScoreEnum), _ScoreReceiver);
State = (StateEnum)System.Enum.Parse(typeof(StateEnum), _State);
StartTime = DateTime.Parse(_StartTime);
if (_EndTime != null)
{
EndTime = DateTime.Parse(_EndTime);
}
PointsPerGame = int.Parse(_PointsPerGame);
//Process points
while (reader.Read() && !(reader.Name == Node && reader.NodeType == System.Xml.XmlNodeType.EndElement))
{
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (reader.Name == "Point")
{
TennisPoint _newPoint = new TennisPoint();
_newPoint.PartOf = this;
_newPoint.ReadXml(reader);
Points.Add(_newPoint);
}
}
}
}
public Boolean Add(TennisPoint newPoint)
{
if (State != StateEnum.sProgress)
{
throw new Exception("This game is not in progress");
}
Points.Add(newPoint);
if (newPoint.Winner == Server)
{
PointsServer++;
if (PointsServer >= PointsPerGame && PointsServer > PointsReceiver + 1)
{
End(Server);
}
if (PointsServer >= PointsPerGame && this.PartOf.PartOf.DeuceSuddenDeath)
{
End(Server);
}
}
else
{
PointsReceiver++;
if (PointsReceiver >= PointsPerGame && PointsReceiver > PointsServer + 1)
{
End(Receiver);
}
if (PointsReceiver >= PointsPerGame && this.PartOf.PartOf.DeuceSuddenDeath)
{
End(Receiver);
}
}
if (PointsServer == PointsPerGame && PointsReceiver == PointsPerGame) //Return to deuce.
{
PointsServer--;
PointsReceiver--;
}
ScoreServer = ConvertScore(PointsServer);
ScoreReceiver = ConvertScore(PointsReceiver);
return(true);
}
public Boolean Add(TennisPoint newPoint)
{
if (State != StateEnum.sProgress)
{
throw new Exception("This game is not in progress");
}
Points.Add(newPoint);
RebuildScore();
if ((PointsServer >= PointsPerGame && PointsReceiver < PointsServer - 1) ||
(PointsReceiver >= PointsPerGame && PointsServer < PointsReceiver - 1))
{
End(PointsServer > PointsReceiver ? startServer : startReceiver);
}
return(true);
}
/// <summary>
/// Undo the last point
/// </summary>
public void Undo()
{
//If game is abnormally ended, reset the status
if (Status == MatchStatus.Terminated || Status == MatchStatus.Resigned)
{
Winner = 0;
Duration.Start(); // start a new session
Status = MatchStatus.InProgress;
}
else
{
//If no points have been played, ignore
if (Points.Count == 0)
{
return;
}
//Remove the last point
TennisPoint point = Points.Last();
Points.Remove(point);
//Remove the points from the statistics
Statistics.Remove(point);
//If there was a winner, reset the status
if (Winner != 0)
{
Winner = 0;
Duration.Start();
Status = MatchStatus.InProgress;
}
while (!currentSet().Undo())
{
Sets.Remove(currentSet());
}
}
//Make sure the next server is properly set. It is unknown if the current game has changed
//so we set this every time.
NextContestantToServe = currentGame().Server == 1 ? Contestant1 : Contestant2;
}
/// <summary>
/// Create a new point / rally instance
/// </summary>
/// <returns></returns>
public TennisPoint CreateNewPoint()
{
TennisPoint newPoint = null;
if (Winner == 0)
{
newPoint = new TennisPoint();
newPoint.PartOf = currentGame();
newPoint.Server = currentGame().Server;
if (currentGame().BreakPoint())
{
newPoint.Type.Add(TennisPoint.PointType.BreakPoint);
}
if (currentGame().GamePoint())
{
newPoint.Type.Add(TennisPoint.PointType.GamePoint);
}
if (CheckSetPoint() != 0)
{
newPoint.Type.Add(TennisPoint.PointType.SetPoint);
if (currentGame().GamePoint())
{
newPoint.Type.Add(TennisPoint.PointType.SetPointServer);
}
}
if (CheckMatchPoint() != 0)
{
newPoint.Type.Add(TennisPoint.PointType.MatchPoint);
if (currentGame().GamePoint())
{
newPoint.Type.Add(TennisPoint.PointType.MatchPointServer);
}
}
}
return(newPoint);
}
/// <summary>
/// Add the given point to this match
/// </summary>
/// <param name="newPoint"></param>
public void Add(TennisPoint newPoint)
{
if (Winner != 0)
{
return;
}
if (currentSet() == null)
{
StartNewSet();
}
newPoint.PartOf = currentGame();
Points.Add(newPoint);
currentSet().Add(newPoint);
//Update statistics
Statistics.Add(newPoint);
if (currentSet().Winner != 0)
{
//the set is finished. Is the match finished?
int NumberOfSetsToWin = (BestOutOf / 2) + 1;
GetContestant(currentSet().Winner).SetsWon++;
if (GetContestant(currentSet().Winner).SetsWon == NumberOfSetsToWin)
{
Winner = currentSet().Winner;
End(MatchStatus.Completed);
}
else
{
StartNewSet();
}
}
}
private void ProcessPoint(TennisPoint point, int Server, int Returner, int Delta)
{
//Total Points
IncrementItem(Statistics.TotalPoints, Server, Delta);
IncrementItem(Statistics.TotalPoints, Returner, Delta);
IncrementItem(Statistics.TotalPointsWon, point.Winner, Delta);
//Service and Return Points
IncrementItem(Statistics.TotalServicePoints, Server, Delta);
IncrementItem(Statistics.TotalReturnPoints, Returner, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.TotalServicePointsWon, Server, Delta);
}
else
{
IncrementItem(Statistics.TotalReturnPointsWon, Returner, Delta);
}
//First services and return points
if (point.Serve == TennisPoint.PointServe.FirstServe)
{
IncrementItem(Statistics.FirstServicesPlayed, Server, Delta);
IncrementItem(Statistics.FirstReturnPlayed, Returner, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.FirstServicesWon, Server, Delta);
}
else
{
IncrementItem(Statistics.FirstReturnWon, Returner, Delta);
}
}
//Second services and return points
if (point.Serve == TennisPoint.PointServe.SecondServe)
{
IncrementItem(Statistics.SecondServicesPlayed, Server, Delta);
IncrementItem(Statistics.SecondReturnPlayed, Returner, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.SecondServicesWon, Server, Delta);
}
else
{
IncrementItem(Statistics.SecondReturnWon, Returner, Delta);
}
}
//Aces and Double Faults
if (point.Shot.Contains(TennisPoint.PointShot.Ace))
{
IncrementItem(Statistics.Aces, Server, Delta);
}
if (point.Error == TennisPoint.PointError.DoubleFault)
{
IncrementItem(Statistics.DoubleFaults, Server, Delta);
}
//Break points
if (point.Type.Contains(TennisPoint.PointType.BreakPoint))
{
IncrementItem(Statistics.ServiceBreakPointsPlayed, Server, Delta);
IncrementItem(Statistics.ReturnBreakPointsPlayed, Returner, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.ServiceBreakPointsWon, Server, Delta);
}
else
{
IncrementItem(Statistics.ReturnBreakPointsWon, Returner, Delta);
}
}
//Set points
if (point.Type.Contains(TennisPoint.PointType.SetPoint))
{
if (point.Type.Contains(TennisPoint.PointType.SetPointServer))
{
IncrementItem(Statistics.ServiceSetPointsPlayed, Server, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.ServiceSetPointsConverted, Server, Delta);
}
}
if (!point.Type.Contains(TennisPoint.PointType.SetPointServer))
{
IncrementItem(Statistics.ReturnSetPointsPlayed, Returner, Delta);
if (point.Winner == Returner)
{
IncrementItem(Statistics.ReturnSetPointsConverted, Returner, Delta);
}
}
}
//Match points
if (point.Type.Contains(TennisPoint.PointType.MatchPoint))
{
if (point.Type.Contains(TennisPoint.PointType.MatchPointServer))
{
IncrementItem(Statistics.ServiceMatchPointsPlayed, Server, Delta);
if (point.Winner == Server)
{
IncrementItem(Statistics.ServiceMatchPointsConverted, Server, Delta);
}
}
if (!point.Type.Contains(TennisPoint.PointType.MatchPointServer))
{
IncrementItem(Statistics.ReturnMatchPointsPlayed, Returner, Delta);
if (point.Winner == Returner)
{
IncrementItem(Statistics.ReturnMatchPointsConverted, Returner, Delta);
}
}
}
//Shots
if (point.ResultType == TennisPoint.PointResultType.Winner)
{
IncrementItem(Statistics.PointWinners, point.Winner, Delta);
foreach (TennisPoint.PointShot _shot in point.Shot)
{
switch (_shot)
{
case TennisPoint.PointShot.Forehand:
IncrementItem(Statistics.ForehandWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.Backhand:
IncrementItem(Statistics.BackhandWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.Volley:
IncrementItem(Statistics.VolleyWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.OverheadShot:
IncrementItem(Statistics.OverheadWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.Dropshot:
IncrementItem(Statistics.DropshotWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.Passing:
IncrementItem(Statistics.PassingWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.Lob:
IncrementItem(Statistics.LobWinner, point.Winner, Delta);
break;
case TennisPoint.PointShot.ApproachShot:
IncrementItem(Statistics.ApproachShotWinner, point.Winner, Delta);
break;
default:
break;
}
}
}
if (point.ResultType == TennisPoint.PointResultType.ForcedError)
{
IncrementItem(Statistics.PointForcedErrors, 3 - point.Winner, Delta);
foreach (TennisPoint.PointShot _shot in point.Shot)
{
switch (_shot)
{
case TennisPoint.PointShot.Forehand:
IncrementItem(Statistics.ForehandForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Backhand:
IncrementItem(Statistics.BackhandForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Volley:
IncrementItem(Statistics.VolleyForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.OverheadShot:
IncrementItem(Statistics.OverheadForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Dropshot:
IncrementItem(Statistics.DropshotForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Passing:
IncrementItem(Statistics.PassingForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Lob:
IncrementItem(Statistics.LobForcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.ApproachShot:
IncrementItem(Statistics.ApproachShotForcedError, 3 - point.Winner, Delta);
break;
default:
break;
}
}
}
if (point.ResultType == TennisPoint.PointResultType.UnforcedError)
{
IncrementItem(Statistics.PointUnforcedErrors, 3 - point.Winner, Delta);
foreach (TennisPoint.PointShot _shot in point.Shot)
{
switch (_shot)
{
case TennisPoint.PointShot.Forehand:
IncrementItem(Statistics.ForehandUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Backhand:
IncrementItem(Statistics.BackhandUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Volley:
IncrementItem(Statistics.VolleyUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.OverheadShot:
IncrementItem(Statistics.OverheadUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Dropshot:
IncrementItem(Statistics.DropshotUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Passing:
IncrementItem(Statistics.PassingUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.Lob:
IncrementItem(Statistics.LobUnforcedError, 3 - point.Winner, Delta);
break;
case TennisPoint.PointShot.ApproachShot:
IncrementItem(Statistics.ApproachShotUnforcedError, 3 - point.Winner, Delta);
break;
default:
break;
}
}
}
//Number of games
if (point.Type.Contains(TennisPoint.PointType.GamePoint) && point.Winner == point.Server)
{
IncrementItem(Statistics.ServiceGamesWon, point.Server, Delta);
IncrementItem(Statistics.ServiceGamesPlayed, point.Server, Delta);
IncrementItem(Statistics.ReturnGamesPlayed, 3 - point.Server, Delta);
}
if (point.Type.Contains(TennisPoint.PointType.BreakPoint) && point.Winner != point.Server)
{
IncrementItem(Statistics.ServiceGamesPlayed, point.Server, Delta);
IncrementItem(Statistics.ReturnGamesWon, 3 - point.Server, Delta);
IncrementItem(Statistics.ReturnGamesPlayed, 3 - point.Server, Delta);
}
}
public void Remove(TennisPoint newPoint)
{
ProcessPoint(newPoint, newPoint.Server, 3 - newPoint.Server, -1);
}
public void Add(TennisPoint newPoint)
{
ProcessPoint(newPoint, newPoint.Server, 3 - newPoint.Server, 1);
AddDuration();
}