/// <summary>
/// Below function is used for single challenge created when tie break occurs
/// </summary>
/// <param name="tournamentMatch"></param>
/// <returns></returns>
public static Challenge CreateChallenge(TournamentMatch tournamentMatch)
{
matchID = tournamentMatch.TournamentMatchID;
Challenge Challenge = new Challenge(tournamentMatch.Cxt, 0);
Challenge.ChallengerUserID = tournamentMatch.WhiteUserID;
Challenge.OpponentUserID = tournamentMatch.BlackUserID;
Challenge.RoomID = 7;
Challenge.ChessTypeIDE = tournamentMatch.Tournament.ChessTypeIDE;
Challenge.ChallengeTypeIDE = ChallengeTypeE.Challenge;
Challenge.ChallengeStatusIDE = ChallengeStatusE.Accepted;
Challenge.StatusIDE = StatusE.Inactive;
Challenge.ChallengeStatusIDE = ChallengeStatusE.Seeking;
Challenge.StatusIDE = StatusE.Active;
Challenge.IsRated = tournamentMatch.Tournament.Rated;
Challenge.WithClock = true;
Challenge.IsChallengerSendsGame = false;
Challenge.GameTypeIDE = Game.GetGameType(tournamentMatch.TimeMin, tournamentMatch.TimeSec);
Challenge.TimeMin = tournamentMatch.TimeMin;
Challenge.GainPerMoveMin = tournamentMatch.TimeSec;
Challenge.ColorIDE = ColorE.White;
Challenge.TournamentMatchID = tournamentMatch.TournamentMatchID;
Challenge.Cxt = tournamentMatch.Cxt;
return(Challenge);
}
public static void SaveTournamentMatch(Kv kv)
{
TournamentMatch TournamentMatch;
int tournamentMatchID = kv.GetInt32("TournamentMatchID");
if (tournamentMatchID > 0) // update existing match
{
TournamentMatch = new TournamentMatch(kv.Cxt, tournamentMatchID);
}
else // add new match
{
TournamentMatch = new TournamentMatch(kv.Cxt, 0);
}
TournamentMatch.TournamentID = kv.GetInt32("TournamentID");
TournamentMatch.WhiteUserID = kv.GetInt32("WhiteUserID");
TournamentMatch.BlackUserID = kv.GetInt32("BlackUserID");
TournamentMatch.Round = kv.GetInt32("Round");
TournamentMatch.TimeMin = kv.GetInt32("TimeMin");
TournamentMatch.TimeSec = kv.GetInt32("TimeSec");
TournamentMatch.MatchStartDate = kv.GetDateTime("MatchStartDate");
TournamentMatch.MatchStartTime = kv.GetDateTime("MatchStartTime");
TournamentMatch.ParentMatchID = kv.GetInt32("ParentMatchID");
TournamentMatch.TournamentMatchStatusID = kv.GetInt32("TournamentMatchStatusID");
TournamentMatch.TournamentMatchTypeID = kv.GetInt32("TournamentMatchTypeID");
TournamentMatch.StatusID = kv.GetInt32("StatusID");
TournamentMatch.Save();
}
public override void Save()
{
System.Data.SqlClient.SqlTransaction t = SqlHelper.BeginTransaction(Config.ConnectionString);
try
{
if (GameResultIDE != GameResultE.InProgress && GameResultIDE != GameResultE.None && GameResultIDE != GameResultE.NoResult)
{
if (GameResultIDE != GameResultE.WhiteBye || GameResultIDE != GameResultE.BlackBye)
{
Elo e = new Elo(this);
e.Update(t);
}
if (this.Challenge.Stake > 0 && this.Challenge.Flate != 0)
{
UserFini.UpdateFiniTransfer(t, base.Cxt, this, this.Challenge.Stake, this.Challenge.Flate);
}
if (this.IsTournamentMatch)
{
if (this.GameResultIDE == GameResultE.Draw)
{
this.TournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Draw;
this.TournamentMatch.GameResultID = this.GameResultID;
this.TournamentMatch.Save(t);
}
else
{
string matchID = this.TournamentMatch.TournamentMatchID.ToString();
this.TournamentMatch.GameResultID = this.GameResultID;
TournamentMatches.UpdateStatus(t, base.Cxt, TournamentMatchStatusE.Finsihed, matchID, this.GameResultIDE);
}
this.TournamentMatch.UpdateUserPoints(t);
}
}
base.Save(t);
SqlHelper.CommitTransaction(t);
if (IsFinished)
{
TournamentMatch.CreateChildMatchIfRequired(Cxt, this.TournamentMatch, null);
}
}
catch (Exception ex)
{
SqlHelper.RollbackTransaction(t);
Log.Write(Cxt, ex);
}
}
public static void CreateChildMatch(Tournament t, TournamentMatch m, TournamentMatchTypeE matchType)
{
Kv kv = null;
if (m != null)
{
kv = new Kv();
kv.Set("TournamentID", m.TournamentID);
kv.Set("WhiteUserID", m.BlackUserID);
kv.Set("BlackUserID", m.WhiteUserID);
kv.Set("Round", m.Round);
switch (matchType)
{
case TournamentMatchTypeE.Normal:
kv.Set("TimeMin", m.TimeMin);
kv.Set("TimeSec", m.TimeSec);
break;
case TournamentMatchTypeE.TieBreak:
kv.Set("TimeMin", t.TieBreakMin);
kv.Set("TimeSec", t.TieBreakSec);
break;
case TournamentMatchTypeE.SuddenDeath:
kv.Set("TimeMin", t.SuddenDeathWhiteMin);
kv.Set("TimeSec", t.SuddenDeathSec);
break;
default:
break;
}
kv.Set("MatchStartDate", DateTime.Now);
kv.Set("MatchStartTime", DateTime.Now);
kv.Set("ParentMatchID", m.ParentMatchID > 0 ? m.ParentMatchID : m.TournamentMatchID);
kv.Set("TournamentMatchStatusID", (int)TournamentMatchStatusE.Scheduled);
kv.Set("TournamentMatchTypeID", (int)matchType);
kv.Set("StatusID", (int)StatusE.Active);
}
App.Model.Db.TournamentMatch.SaveTournamentMatch(kv);
}
static void CreateKnockoutTournamentMatches(Cxt cxt, TournamentUsers tournamentUsers, TournamentMatches tournamentMatches, int round, Tournament Tournament)
{
if (tournamentUsers.Count > 0)
{
for (int i = 0; i < tournamentUsers.Count / 2; i++)
{
TournamentUser userW = new TournamentUser(cxt, tournamentUsers.DataTable.Rows[i]);
TournamentUser userB = new TournamentUser(cxt, tournamentUsers.DataTable.Rows[tournamentUsers.Count - i - 1]);
TournamentMatch tournamentMatch = new TournamentMatch(cxt, 0);
tournamentMatch.Round = round;
tournamentMatch.WhiteUserID = userW.UserID;
tournamentMatch.BlackUserID = userB.UserID;
tournamentMatch.TournamentID = Tournament.TournamentID;
tournamentMatch.TournamentMatchTypeE = TournamentMatchTypeE.Normal;
if (Tournament.TournamentStartDate > DateTime.Now)
{
tournamentMatch.MatchStartDate = Tournament.TournamentStartDate;
}
else
{
tournamentMatch.MatchStartDate = DateTime.Now;
}
if (Tournament.TournamentStartTime > DateTime.Now)
{
tournamentMatch.MatchStartTime = Tournament.TournamentStartTime;
}
else
{
tournamentMatch.MatchStartTime = DateTime.Now;
}
tournamentMatch.TimeMin = Tournament.TimeControlMin;
tournamentMatch.TimeSec = Tournament.TimeControlSec;
tournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Scheduled;
tournamentMatch.EloWhiteBefore = userW.EloBefore;
tournamentMatch.EloBlackBefore = userB.EloBefore;
tournamentMatch.CreatedBy = Ap.CurrentUserID;
tournamentMatch.DateCreated = DateTime.Now;
tournamentMatch.StatusID = (int)StatusE.Active;
tournamentMatches.Add(tournamentMatch);
}
}
}
public static Kv UpdateReplacePlayer(Cxt cxt, int tournamentID, int userID, int userID2)
{
Kv kv = new Kv();
SqlTransaction trans = null;
try
{
trans = SqlHelper.BeginTransaction(Config.ConnectionString);
bool result = TournamentMatch.GetTournamentMatchByTournamentUserID(cxt, tournamentID, userID);
if (result)
{
kv.Set("Result", (int)MsgE.ErrorTournamentPlayerReplaceUser);
return(kv);
}
TournamentUser tu = GetTournamentUserById(cxt, tournamentID, userID);
BaseCollection.Execute(trans, "UpdateTournamentMatchWithUser", tournamentID, userID, userID2, cxt.CurrentUserID, 3);
if (tu.UserID2 > 0)
{
userID = tu.UserID2;
}
BaseCollection.Execute(trans, "UpdateTournamentMatchWithUser", tournamentID, userID, userID2, cxt.CurrentUserID, 0);
BaseCollection.Execute(trans, "UpdateTournamentMatchWithUser", tournamentID, userID, userID2, cxt.CurrentUserID, 1);
SqlHelper.CommitTransaction(trans);
kv.Set("Result", 0);
}
catch (Exception ex)
{
SqlHelper.RollbackTransaction(trans);
Log.Write(cxt, ex);
}
return(kv);
}
static int GetRoundInProgress(Cxt cxt, Tournament tournament)
{
DataTable dt = TournamentMatches.GetTournamentsMatchByTournamentID(tournament.TournamentID);
DataTable dtTournamentUsers = TournamentUsers.GetTournamentUsersByTournamentID(StatusE.Active, tournament.TournamentID);
foreach (DataRow item in dt.Rows)
{
TournamentMatch tm = new TournamentMatch(cxt, item);
if (tm.TournamentMatchStatusE == TournamentMatchStatusE.InProgress || tm.TournamentMatchStatusE == TournamentMatchStatusE.Scheduled)
{
return((int)MsgE.ErrorTournamentNextRoundStarted);
}
}
object objId = dt.Compute("max(Round)", "");
int round = Convert.ToInt32(objId);
DataTable dtRounds = TournamentRounds.GetTournamentWinnersByRound(tournament.TournamentID, round);
if (round == 0 && TournamentMatch.IsPreliminaryRound(round, dtTournamentUsers)) // if it is prelimiry round
{
if (dtRounds.Rows.Count == TournamentMatch.CountPreliminaryRoundUsers(dtTournamentUsers))
{
return(0);
}
else
{
return((int)MsgE.ErrorTournamentNextRoundStarted);
}
}
DataTable dtUsers = TournamentUsers.GetTournamentUsersByRound(tournament.TournamentID, round);
if (dtRounds.Rows.Count != dtUsers.Rows.Count / 2)
{
return((int)MsgE.ErrorTournamentNextRoundStarted);
}
return(0);
}
private static void CreateSchavengenMatches(Cxt cxt, Tournament tournament, TournamentUsers TournamentUsers)
{
TournamentUser userW = null;
TournamentUser userB = null;
if (TournamentUsers.Count > 0)
{
DataTable dt = null;
if ((TournamentUsers.Count / 2) % 2 == 1)
{
dt = SchSystemsOdd(TournamentUsers.Count / 2);
}
else
{
dt = SchSystems(TournamentUsers.Count / 2);
}
foreach (DataRow item in dt.Rows)
{
userW = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player1"]) - 1]);
userB = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player2"]) - 1]);
TournamentMatch tournamentMatch = new TournamentMatch(cxt, 0);
tournamentMatch.Round = Convert.ToInt32(item["Round"]);
tournamentMatch.WhiteUserID = userW.UserID;
tournamentMatch.BlackUserID = userB.UserID;
tournamentMatch.TournamentID = tournament.TournamentID;
tournamentMatch.TournamentMatchTypeE = TournamentMatchTypeE.Normal;
if (tournament.TournamentStartDate > DateTime.Now)
{
tournamentMatch.MatchStartDate = tournament.TournamentStartDate;
}
else
{
tournamentMatch.MatchStartDate = DateTime.Now;
}
if (tournament.TournamentStartTime > DateTime.Now)
{
tournamentMatch.MatchStartTime = tournament.TournamentStartTime;
}
else
{
tournamentMatch.MatchStartTime = DateTime.Now;
}
tournamentMatch.TimeMin = tournament.TimeControlMin;
tournamentMatch.TimeSec = tournament.TimeControlSec;
tournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Scheduled;
tournamentMatch.EloWhiteBefore = userW.EloBefore;
tournamentMatch.EloBlackBefore = userB.EloBefore;
tournamentMatch.CreatedBy = cxt.CurrentUserID;
tournamentMatch.DateCreated = DateTime.Now;
tournament.TournamentMatches.Add(tournamentMatch);
}
}
}
private static void CreateSchavengenMatches(Cxt cxt, Tournament tournament, TournamentUsers TournamentUsers, bool isWhite, int counter,
int round, ref int val, ref int roundValue)
{
TournamentUser userW = null;
TournamentUser userB = null;
if (TournamentUsers.Count > 0)
{
DataTable dt = null;
if ((TournamentUsers.Count / 2) % 2 == 1)
{
dt = SchSystemsOdd(TournamentUsers.Count / 2);
}
else
{
dt = SchSystems(TournamentUsers.Count / 2);
}
//DataRow[] dr = dt.Select("1=1", "Round desc");
//int round = i + counter * Convert.ToInt32(dr[0]["Round"]);
foreach (DataRow item in dt.Rows)
{
if (val == round)
{
roundValue++;
val = 0;
}
if (isWhite)
{
userW = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player1"]) - 1]);
userB = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player2"]) - 1]);
}
else
{
userW = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player2"]) - 1]);
userB = new TournamentUser(Cxt.Instance, TournamentUsers[Convert.ToInt32(item["Player1"]) - 1]);
}
TournamentMatch tournamentMatch = new TournamentMatch(cxt, 0);
tournamentMatch.Round = roundValue;
tournamentMatch.WhiteUserID = userW.UserID;
tournamentMatch.BlackUserID = userB.UserID;
tournamentMatch.TournamentID = tournament.TournamentID;
tournamentMatch.TournamentMatchTypeE = TournamentMatchTypeE.Normal;
if (tournament.TournamentStartDate > DateTime.Now)
{
tournamentMatch.MatchStartDate = tournament.TournamentStartDate;
}
else
{
tournamentMatch.MatchStartDate = DateTime.Now;
}
if (tournament.TournamentStartTime > DateTime.Now)
{
tournamentMatch.MatchStartTime = tournament.TournamentStartTime;
}
else
{
tournamentMatch.MatchStartTime = DateTime.Now;
}
tournamentMatch.TimeMin = tournament.TimeControlMin;
tournamentMatch.TimeSec = tournament.TimeControlSec;
tournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Scheduled;
tournamentMatch.EloWhiteBefore = userW.EloBefore;
tournamentMatch.EloBlackBefore = userB.EloBefore;
tournamentMatch.CreatedBy = cxt.CurrentUserID;
tournamentMatch.DateCreated = DateTime.Now;
tournamentMatch.StatusID = (int)StatusE.Active;
tournament.TournamentMatches.Add(tournamentMatch);
val++;
}
}
}
public static Game CreateGame(Cxt cxt, DataSet gds)
{
Game g = null;
if (gds == null)
{
return(null);
}
if (gds.Tables["Game"] == null)
{
return(null);
}
if (gds.Tables["Game"].Rows.Count == 0)
{
return(null);
}
g = new App.Model.Db.Game(cxt, gds.Tables["Game"].Rows[0]);
if (gds.Tables["Challenge"] != null)
{
if (gds.Tables["Challenge"].Rows.Count > 0)
{
g.Challenge = new Challenge(cxt, gds.Tables["Challenge"].Rows[0]);
}
}
User uc = new User(cxt, gds.Tables["Users"].Rows[0]);
User uo = new User(cxt, gds.Tables["Users"].Rows[1]);
Engine ec = new Engine(cxt, gds.Tables["Engines"].Rows[0]);
Engine eo = new Engine(cxt, gds.Tables["Engines"].Rows[1]);
if (uc.EngineID == ec.EngineID)
{
uc.Engine = ec;
uo.Engine = eo;
}
else
{
uc.Engine = eo;
uo.Engine = ec;
}
if (g.WhiteUserID == uc.ID)
{
g.WhiteUser = uc;
g.BlackUser = uo;
}
else
{
g.WhiteUser = uo;
g.BlackUser = uc;
}
if (gds.Tables.Count > 4 && (gds.Tables.Contains("TournamentMatch") || gds.Tables.Contains("Tournament")))
{
TournamentMatch tm = new TournamentMatch(cxt, gds.Tables["TournamentMatch"].Rows[0]);
Tournament t = new Tournament(cxt, gds.Tables["Tournament"].Rows[0]);
tm.Tournament = t;
g.TournamentMatch = tm;
}
return(g);
}
public static decimal CalculatePlayerPoints(Cxt cxt, int playerId, DataRow[] drMatches)
{
double points = 0;
TournamentMatch tm = null;
foreach (DataRow drNormal in drMatches)
{
tm = new TournamentMatch(cxt, drNormal);
if (tm.WhiteUserID == playerId)
{
#region Check for White Player
switch (tm.GameResultIDE)
{
case GameResultE.None:
#region Check TournamentMatchStatusE
switch (tm.TournamentMatchStatusE)
{
case TournamentMatchStatusE.Draw:
case TournamentMatchStatusE.ForcedDraw:
points += 0.5;
break;
case TournamentMatchStatusE.ForcedWhiteWin:
case TournamentMatchStatusE.BlackBye:
points += 1;
break;
case TournamentMatchStatusE.ForcedWhiteLose:
case TournamentMatchStatusE.WhiteBye:
points += 0;
break;
default:
break;
}
#endregion
break;
case GameResultE.WhiteWin:
case GameResultE.BlackBye:
case GameResultE.ForcedWhiteWin:
points += 1;
break;
points += 0;
break;
case GameResultE.Draw:
case GameResultE.ForcedDraw:
points += 0.5;
break;
case GameResultE.WhiteLose:
case GameResultE.WhiteBye:
case GameResultE.ForcedWhiteLose:
points += 0;
break;
default:
break;
}
#endregion
}
else if (tm.BlackUserID == playerId)
{
#region Check for Black Player
switch (tm.GameResultIDE)
{
case GameResultE.None:
#region Check TournamentMatchStatusE
switch (tm.TournamentMatchStatusE)
{
case TournamentMatchStatusE.Draw:
case TournamentMatchStatusE.ForcedDraw:
points += 0.5;
break;
case TournamentMatchStatusE.ForcedWhiteWin:
case TournamentMatchStatusE.BlackBye:
points += 0;
break;
case TournamentMatchStatusE.ForcedWhiteLose:
case TournamentMatchStatusE.WhiteBye:
points += 1;
break;
default:
break;
}
#endregion
break;
case GameResultE.WhiteWin:
case GameResultE.BlackBye:
case GameResultE.ForcedWhiteWin:
points += 0;
break;
case GameResultE.WhiteLose:
case GameResultE.WhiteBye:
case GameResultE.ForcedWhiteLose:
points += 1;
break;
case GameResultE.Draw:
case GameResultE.ForcedDraw:
points += 0.5;
break;
default:
break;
}
#endregion
}
}
return((decimal)points);
}
public static void CreateChildMatchIfRequired(Cxt cxt, TournamentMatch m, DataTable dtTournamentUsers)
{
#region Entry Conditions
if (m == null)
{
return;
}
Tournament t = new Tournament(cxt, m.TournamentID);
if (t.TournamentTypeE != TournamentTypeE.Knockout)
{
return;
}
if (dtTournamentUsers == null)
{
dtTournamentUsers = TournamentUsers.GetTournamentUsersByTournamentID(StatusE.Active, t.TournamentID);
}
//if (m.Round == 0 && IsPreliminaryRound(m.Round, dtTournamentUsers)) // if it is prelimiry round
//{
// return;
//}
#endregion
#region DataMembers
DataTable dtMatches = App.Model.Db.TournamentMatches.GetTournamentMatchByRound(t.ID, m.Round);
DataRow[] drMatches = null;
int whiteUserId = m.WhiteUserID;
int blackUserId = m.BlackUserID;
decimal whitePoints = -1;
decimal blackPoints = -1;
string filter = "";
filter += "(WhiteUserId = " + whiteUserId + " or BlackUserId = " + whiteUserId;
filter += " or WhiteUserId = " + blackUserId + " or BlackUserId = " + blackUserId + ")";
#endregion
switch (m.TournamentMatchTypeE)
{
case TournamentMatchTypeE.Normal:
#region Normal Round Matches
drMatches = dtMatches.Select(filter + " and TournamentMatchTypeID = " + (int)TournamentMatchTypeE.Normal);
whitePoints = CalculatePlayerPoints(cxt, whiteUserId, drMatches);
blackPoints = CalculatePlayerPoints(cxt, blackUserId, drMatches);
if (drMatches.Length >= t.NoOfGamesPerRound) // NoOfGamesPerRound completed.
{
#region If NoOfGamesPerRound completed
if (whitePoints > blackPoints)
{
// white win
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, true);
}
else if (whitePoints < blackPoints)
{
// white lose
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, false);
}
else
{
// draw/tie, now start tie-break matches if required.
if (t.IsTieBreak && t.NoOfTieBreaks > 0)
{
CreateChildMatch(t, m, TournamentMatchTypeE.TieBreak);
}
}
#endregion
}
else // NoOfGamesPerRound not completed, so continue with round's matches if no player win yet.
{
#region if NoOfGamesPerRound not completed
decimal winningPoints = (decimal)(t.NoOfGamesPerRound / 2 + 0.5);
if (whitePoints >= winningPoints)
{
// white win
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, true);
}
else if (blackPoints >= winningPoints)
{
// white lose
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, false);
}
else
{
CreateChildMatch(t, m, TournamentMatchTypeE.Normal);
}
#endregion
}
#endregion
break;
case TournamentMatchTypeE.TieBreak:
#region Tie-Break Matches
drMatches = dtMatches.Select(filter + " and TournamentMatchTypeID = " + (int)TournamentMatchTypeE.TieBreak);
whitePoints = CalculatePlayerPoints(cxt, whiteUserId, drMatches);
blackPoints = CalculatePlayerPoints(cxt, blackUserId, drMatches);
if (drMatches.Length >= t.NoOfTieBreaks) // NoOfTieBreaks completed.
{
#region if NoOfTieBreaks completed
if (whitePoints > blackPoints)
{
// white win
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, true);
}
else if (whitePoints < blackPoints)
{
// white lose
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, false);
}
else
{
// draw/tie, now required SuddenDeath match
CreateChildMatch(t, m, TournamentMatchTypeE.SuddenDeath);
}
#endregion
}
else // NoOfTieBreaks not completed, so continue with tie-break's matches
{
decimal winningPoints = (decimal)(t.NoOfTieBreaks / 2 + 0.5);
if (whitePoints >= winningPoints)
{
// white win
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, true);
}
else if (blackPoints >= winningPoints)
{
// white lose
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, false);
}
else
{
CreateChildMatch(t, m, TournamentMatchTypeE.TieBreak);
}
}
#endregion
break;
case TournamentMatchTypeE.SuddenDeath:
#region SuddenDeath Match
bool isWhiteWin = false;
#region Check Result
switch (m.GameResultIDE)
{
case GameResultE.None:
#region Check TournamentMatchStatusE
switch (m.TournamentMatchStatusE)
{
case TournamentMatchStatusE.ForcedWhiteWin:
case TournamentMatchStatusE.BlackBye:
isWhiteWin = true;
break;
default:
break;
}
#endregion
break;
case GameResultE.WhiteWin:
case GameResultE.BlackBye:
case GameResultE.ForcedWhiteWin:
isWhiteWin = true;
break;
default:
break;
}
#endregion
if (isWhiteWin)
{
// white win
whitePoints = 1;
blackPoints = 0;
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, true);
}
else
{
// white lose
whitePoints = 0;
blackPoints = 1;
SaveTournamentRound(cxt, dtMatches, t.ID, m.Round, whiteUserId, blackUserId, whitePoints, blackPoints, false);
}
#endregion
break;
default:
break;
}
}
static void CalculateRoundRobinMatch(Cxt cxt, int tournamentID, Tournament tournament, List <DataRow> listTournamentUsers)
{
TournamentUser userW = null;
TournamentUser userB = null;
int dblRound = (tournament.DoubleRound) ? 2 : 1;
int moderound = (listTournamentUsers.Count % 2 == 1) ? listTournamentUsers.Count : listTournamentUsers.Count - 1;
for (int counter = 0; counter < dblRound; counter++)
{
DataTable dtCalculatePair = CalculateParing(listTournamentUsers.Count);
for (int i = 0; i < dtCalculatePair.Rows.Count; i++)
{
DataRow drCal = dtCalculatePair.Rows[i];
if (counter == 1)
{
userW = new TournamentUser(cxt, listTournamentUsers[Convert.ToInt32(drCal["Player2"]) - 1]);
userB = new TournamentUser(cxt, listTournamentUsers[Convert.ToInt32(drCal["Player1"]) - 1]);
}
else
{
userW = new TournamentUser(cxt, listTournamentUsers[Convert.ToInt32(drCal["Player1"]) - 1]);
userB = new TournamentUser(cxt, listTournamentUsers[Convert.ToInt32(drCal["Player2"]) - 1]);
}
int round = Convert.ToInt32(drCal["Round"]);
if (counter > 0)
{
round = round + moderound;
}
TournamentMatch tournamentMatch = new TournamentMatch(cxt, 0);
tournamentMatch.Round = round;
tournamentMatch.WhiteUserID = userW.UserID;
tournamentMatch.BlackUserID = userB.UserID;
tournamentMatch.TournamentID = tournamentID;
tournamentMatch.TournamentMatchTypeE = TournamentMatchTypeE.Normal;
if (tournament.TournamentStartDate > DateTime.Now)
{
tournamentMatch.MatchStartDate = tournament.TournamentStartDate;
}
else
{
tournamentMatch.MatchStartDate = DateTime.Now;
}
if (tournament.TournamentStartTime > DateTime.Now)
{
tournamentMatch.MatchStartTime = tournament.TournamentStartTime;
}
else
{
tournamentMatch.MatchStartTime = DateTime.Now;
}
tournamentMatch.TimeMin = tournament.TimeControlMin;
tournamentMatch.TimeSec = tournament.TimeControlSec;
tournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Scheduled;
if (userW.UserID == 2 || userB.UserID == 2)
{
tournamentMatch.TournamentMatchStatusE = TournamentMatchStatusE.Absent;
}
tournamentMatch.EloWhiteBefore = userW.EloBefore;
tournamentMatch.EloBlackBefore = userB.EloBefore;
tournamentMatch.CreatedBy = Ap.CurrentUserID;
tournamentMatch.DateCreated = DateTime.Now;
tournamentMatch.StatusID = (int)StatusE.Active;
tournament.TournamentMatches.Add(tournamentMatch);
}
}
}
static TournamentUsers GetTournamentPreliminaryWinners1(Cxt cxt, int tournamentID, int round, DataTable dtTournamentUsers)
{
TournamentUsers tuWinners = new TournamentUsers();
TournamentMatches tournamentMatches = new TournamentMatches(cxt, GetTournamntPlayers(tournamentID));
TournamentMatches tmW = new TournamentMatches();
TournamentUsers tuW = new TournamentUsers();
TournamentUsers tuL = new TournamentUsers();
int wCounter = 0, bCounter = 0, dCounter = 0;
foreach (DataRow item in tournamentMatches.DataTable.Rows)
{
TournamentMatch tournamentMatch = new TournamentMatch(cxt, item);
TournamentUser tournamentUserB = null;
TournamentUser tournamentUserW = null;
switch (tournamentMatch.GameResultIDE)
{
case GameResultE.None:
break;
case GameResultE.InProgress:
break;
case GameResultE.WhiteWin:
bCounter += 1;
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tuW.Add(tournamentUserW);
tuL.Add(tournamentUserB);
break;
case GameResultE.WhiteLose:
{
wCounter += 1;
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tuW.Add(tournamentUserB);
tuL.Add(tournamentUserW);
}
break;
case GameResultE.Draw:
dCounter += 1;
tmW.Add(tournamentMatch);
break;
case GameResultE.Absent:
break;
case GameResultE.NoResult:
break;
case GameResultE.WhiteBye:
wCounter += 1;
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tuW.Add(tournamentUserB);
tuL.Add(tournamentUserW);
break;
case GameResultE.BlackBye:
bCounter += 1;
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tuW.Add(tournamentUserW);
tuL.Add(tournamentUserB);
break;
case GameResultE.ForcedWhiteWin:
bCounter += 1;
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tuW.Add(tournamentUserW);
tuL.Add(tournamentUserB);
break;
case GameResultE.ForcedWhiteLose:
wCounter += 1;
tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tuW.Add(tournamentUserB);
tuL.Add(tournamentUserW);
break;
case GameResultE.ForcedDraw:
dCounter += 1;
tmW.Add(tournamentMatch);
break;
default:
break;
}
}
if (dCounter > 0)
{
foreach (DataRow item in tmW.DataTable.Rows)
{
TournamentMatch tournamentMatch = new TournamentMatch(cxt, item);
if (tournamentMatch.EloWhiteAfter > tournamentMatch.EloBlackAfter)
{
TournamentUser tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
TournamentUser tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
tuW.Add(tournamentUserW);
tuL.Add(tournamentUserB);
}
else if (tournamentMatch.EloBlackAfter > tournamentMatch.EloWhiteAfter)
{
TournamentUser tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
TournamentUser tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tuW.Add(tournamentUserB);
tuL.Add(tournamentUserW);
}
else
{
TournamentUser tournamentUserB = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.BlackUserID);
TournamentUser tournamentUserW = TournamentUser.GetTournamentUserById(cxt, tournamentID, tournamentMatch.WhiteUserID);
tuW.Add(tournamentUserB);
tuW.Add(tournamentUserW);
}
}
}
if (tuL.Count > 0)
{
foreach (DataRow item in dtTournamentUsers.Rows)
{
TournamentUser tu1 = new TournamentUser(cxt, item);
if (!tuL.Contains("UserID = " + tu1.UserID))
{
tuWinners.Add(tu1);
}
}
}
return(tuWinners);
}
public static int GetKnockoutTournamentMatchesCount(Cxt cxt, Tournament tournament)
{
DataTable dtTournamentUsers = TournamentUsers.GetTournamentUsersByTournamentID(StatusE.Active, tournament.TournamentID);
TournamentMatches tournamentMatches = new TournamentMatches();
TournamentUsers tournamentUsers = null;
if (tournament.TournamentCurrentRound > 0)
{
TournamentUsers ratedTournamentUsers = null;
if (TournamentMatch.IsPreliminaryRound(tournament.TournamentCurrentRound - 1, dtTournamentUsers))
{
ratedTournamentUsers = GetTournamentPreliminaryWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound, dtTournamentUsers);
}
else
{
ratedTournamentUsers = GetTournamentWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound);
}
if (ratedTournamentUsers.Count == 0)
{
return(0);
}
if (tournament.TournamentCurrentRound > 2) // make sure,"tournament.TournamentCurrentRound - 1" is not preliminary round
{
TournamentUsers previousRoundUsers = GetTournamentWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound - 1);
if (previousRoundUsers.Count == 2 && ratedTournamentUsers.Count == 2)
{
return(0);
}
}
CreateKnockoutTournamentMatches(cxt, ratedTournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
if (tournament.MaxWinners >= 3 && ratedTournamentUsers.Count == 2) // for multiple winners
{
ratedTournamentUsers = GetTournamentLosers(cxt, tournament.TournamentID, tournament.TournamentCurrentRound);
CreateKnockoutTournamentMatches(cxt, ratedTournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
}
}
else
{
if (dtTournamentUsers.Rows.Count == 0)
{
return(0);
}
if (tournament.TournamentCurrentRound == 0)
{
if (!TournamentMatch.IsPreliminaryRound(tournament.TournamentCurrentRound, dtTournamentUsers))
{
tournament.TournamentCurrentRound = 1;
tournamentUsers = new TournamentUsers(cxt, dtTournamentUsers);
//CreateKnockoutTournamentMatches(cxt, tournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
//break;
}
else
{
tournamentUsers = GetPreliminaryRound(cxt, tournament, dtTournamentUsers);
}
}
CreateKnockoutTournamentMatches(cxt, tournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
}
return(tournamentMatches.Count);
}
public static void CreateKnockoutTournamentMatches(Cxt cxt, SqlTransaction trans, Tournament tournament, DataTable dtTournamentUsers)
{
TournamentMatches tournamentMatches = new TournamentMatches();
TournamentUsers tournamentUsers = null;
if (tournament.TournamentCurrentRound > 0)
{
TournamentUsers ratedTournamentUsers = null;
if (TournamentMatch.IsPreliminaryRound(tournament.TournamentCurrentRound - 1, dtTournamentUsers))
{
ratedTournamentUsers = GetTournamentPreliminaryWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound, dtTournamentUsers);
}
else
{
ratedTournamentUsers = GetTournamentWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound);
}
if (ratedTournamentUsers.Count == 0)
{
return;
}
if (tournament.TournamentCurrentRound > 2) // make sure,"tournament.TournamentCurrentRound - 1" is not preliminary round
{
TournamentUsers previousRoundUsers = GetTournamentWinners(cxt, tournament.TournamentID, tournament.TournamentCurrentRound - 1);
if (previousRoundUsers.Count == 2 && ratedTournamentUsers.Count == 2)
{
return;
}
}
CreateKnockoutTournamentMatches(cxt, ratedTournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
if (tournament.MaxWinners >= 3 && ratedTournamentUsers.Count == 2) // for multiple winners
{
ratedTournamentUsers = GetTournamentLosers(cxt, tournament.TournamentID, tournament.TournamentCurrentRound);
CreateKnockoutTournamentMatches(cxt, ratedTournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
}
}
else
{
if (dtTournamentUsers.Rows.Count == 0)
{
return;
}
if (tournament.TournamentCurrentRound == 0)
{
if (!TournamentMatch.IsPreliminaryRound(tournament.TournamentCurrentRound, dtTournamentUsers))
{
tournament.TournamentCurrentRound = 1;
tournamentUsers = new TournamentUsers(cxt, dtTournamentUsers);
//CreateKnockoutTournamentMatches(cxt, tournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
//break;
}
else
{
tournamentUsers = GetPreliminaryRound(cxt, tournament, dtTournamentUsers);
}
}
CreateKnockoutTournamentMatches(cxt, tournamentUsers, tournamentMatches, tournament.TournamentCurrentRound, tournament);
}
if (tournamentMatches.Count > 0)
{
tournamentMatches.Save(trans);
}
}
