public ResultsData(EDivision InDiv, ERound InRound, EPool InPool)
{
Division = InDiv;
Round = InRound;
Pool = InPool;
}
public PoolData GetPool(EDivision division, ERoundJudgeDisplay round, int controlIndex)
{
if (round == ERoundJudgeDisplay.Finals || round == ERoundJudgeDisplay.Semifinals)
{
return(GetPool(division, EnumConverter.ConvertRoundValue(round), (EPool)controlIndex));
}
else if (round != ERoundJudgeDisplay.None)
{
// If round is Quarter or Prelim
int divisionIndex = (int)division;
if (divisionIndex >= 0 && divisionIndex < (int)EDivision.Max)
{
int roundIndex = (int)EnumConverter.ConvertRoundValue(round);
if (roundIndex >= 0 && roundIndex < (int)ERoundJudgeDisplay.None)
{
int PoolIndex = 2 * controlIndex +
(round == ERoundJudgeDisplay.QuarterfinalsBD ? 1 : 0) +
(round == ERoundJudgeDisplay.PrelimsBD ? 1 : 0);
if (PoolIndex >= 0 && PoolIndex < divisions[divisionIndex].rounds[roundIndex].pools.Count)
{
return(divisions[divisionIndex].rounds[roundIndex].pools[PoolIndex]);
}
}
}
}
return(new PoolData());
}
void OnJudgesPoolChange(EDivision division, ERoundJudgeDisplay round)
{
if (division != EDivision.None && round != ERoundJudgeDisplay.None)
{
parentWindow.GetPlayingTeams(division, round, controlIndex, out playingTeams);
PoolTeamsControl.ItemsSource = playingTeams;
string poolString = "";
if (round == ERoundJudgeDisplay.Finals)
{
if (controlIndex == 0)
{
PoolNameLabel.Content = division.ToString() + " - " + round.ToString();
}
else
{
PoolNameLabel.Content = "";
}
}
else
{
poolString = EnumConverter.ConvertPoolValue(round, controlIndex).ToString();
PoolNameLabel.Content = division.ToString() + " - " + round.ToString() + " - Pool " + poolString;
}
}
else
{
PoolTeamsControl.ItemsSource = null;
PoolNameLabel.Content = "";
}
}
private void ImportItem_Click(object sender, RoutedEventArgs e)
{
Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog();
if (dialog.ShowDialog() == true)
{
string namesXmlFilename = (new FileInfo(dialog.FileName)).DirectoryName + "\\names.xml";
if (TryImportNames(namesXmlFilename))
{
XmlDocument xml = new XmlDocument();
xml.Load(dialog.FileName);
XmlNode root = xml.LastChild.FirstChild;
TournamentData importedData = new TournamentData();
EDivision division = EDivision.Open;
foreach (XmlNode divisionNode in root.ChildNodes) // DivisionData
{
ImportDivisionData(importedData, divisionNode, division);
division += 1;
}
tournamentData = importedData;
Init();
}
}
}
public AIData(EDivision InDiv, ERound InRound, EPool InPool, int InTeam)
{
Division = InDiv;
Round = InRound;
Pool = InPool;
Team = InTeam;
}
public DiffData(int InNumScores, EDivision InDiv, ERound InRound, EPool InPool, int InTeam)
{
NumScores = InNumScores;
Division = InDiv;
Round = InRound;
Pool = InPool;
Team = InTeam;
}
void OnJudgesPoolChange(EDivision inDivision, ERoundJudgeDisplay inRound)
{
division = inDivision;
round = inRound;
PoolData pd = parentWindow.tournamentData.GetPool(division, round, controlIndex);
judgeData.CopyFrom(pd.judgesData, parentWindow);
}
public static TeamData GetTeamData(EDivision InDiv, ERound InRound, EPool InPool, int InTeam)
{
if (!DataExists(InDiv, InRound, InPool, InTeam))
{
return(null);
}
return(Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools[(int)InPool].Teams[InTeam].Data);
}
private void FillPoolTeams(EDivision division, ERound round, List <TeamData> teams, bool bClearPreviousTeams)
{
int rawPoolIndex = 0;
int adjustedPoolIndex = 0;
bool bReversePoolAssignmentDirection = false;
RoundData rd = tournamentData.GetRound(division, round);
int maxPoolCount = rd.pools.Count;
if (bClearPreviousTeams)
{
for (int poolIndex = 0; poolIndex < maxPoolCount; ++poolIndex)
{
PoolData pd = tournamentData.GetPool(division, round, (EPool)poolIndex);
pd.teamList.teams.Clear();
}
}
for (int teamIndex = 0; teamIndex < teams.Count; ++teamIndex)
{
if (rawPoolIndex >= maxPoolCount)
{
bReversePoolAssignmentDirection = !bReversePoolAssignmentDirection;
rawPoolIndex = 0;
if (bReversePoolAssignmentDirection)
{
adjustedPoolIndex = maxPoolCount - 1;
}
else
{
adjustedPoolIndex = 0;
}
}
PoolData pd = tournamentData.GetPool(division, round, (EPool)adjustedPoolIndex);
pd.teamList.teams.Add(teams[teamIndex]);
if (bReversePoolAssignmentDirection)
{
--adjustedPoolIndex;
}
else
{
++adjustedPoolIndex;
}
++rawPoolIndex;
}
// Reverse the teams in the pool so first play is at the top
foreach (PoolData pd in rd.pools)
{
pd.teamList.teams = new ObservableCollection <TeamData>(pd.teamList.teams.Reverse());
}
PoolsUpdateBindings();
}
public static bool DataExists(EDivision InDiv, ERound InRound, EPool InPool, int InTeam)
{
if (Global.AllData == null || InPool == EPool.None || (int)InPool >= Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools.Count ||
InTeam < 0 || InTeam >= Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools[(int)InPool].Teams.Count)
{
return(false);
}
return(true);
}
private bool TryGetAutoGeneratePools(EDivision division, ERound round, EPool pool, out PoolData pool1, out PoolData pool2, out PoolData nextPool)
{
if (round == ERound.Quarterfinals)
{
if (pool == EPool.A || pool == EPool.C)
{
pool1 = tournamentData.GetPool(division, ERound.Quarterfinals, EPool.A);
pool2 = tournamentData.GetPool(division, ERound.Quarterfinals, EPool.C);
nextPool = tournamentData.GetPool(division, ERound.Semifinals, EPool.A);
}
else
{
pool1 = tournamentData.GetPool(division, ERound.Quarterfinals, EPool.B);
pool2 = tournamentData.GetPool(division, ERound.Quarterfinals, EPool.D);
nextPool = tournamentData.GetPool(division, ERound.Semifinals, EPool.B);
}
}
else if (round == ERound.Semifinals)
{
pool1 = tournamentData.GetPool(division, ERound.Semifinals, EPool.A);
pool2 = tournamentData.GetPool(division, ERound.Semifinals, EPool.B);
nextPool = tournamentData.GetPool(division, ERound.Finals, EPool.A);
}
else
{
pool1 = null;
pool2 = null;
nextPool = null;
return(false);
}
if (pool1.resultRank.Count > 0 && pool2.resultRank.Count > 0)
{
foreach (int rank in pool1.resultRank)
{
if (rank == 0)
{
return(false);
}
}
foreach (int rank in pool2.resultRank)
{
if (rank == 0)
{
return(false);
}
}
return(true);
}
return(false);
}
private void RemoveJudgeFromPoolData(JudgeInventoryItemData judge, EDivision division, ERound round, EPool pool)
{
PoolData pd = parentWindow.tournamentData.GetPool(division, round, pool);
RegisteredPlayer rp;
if (parentWindow.TryFindRegisteredPlayer(judge.PlayerName, out rp))
{
pd.judgesData.Remove(rp);
}
}
public static EDivisionDisplay ConvertDivisionValue(EDivision division)
{
if (division == EDivision.None)
{
return(EDivisionDisplay.None);
}
else
{
return((EDivisionDisplay)division);
}
}
public ObservableCollection <TeamData> GetAllTeams(EDivision division)
{
int divisionIndex = (int)division;
if (divisionIndex >= 0 && divisionIndex < (int)EDivision.Max)
{
return(divisions[divisionIndex].teamList.teams);
}
return(new ObservableCollection <TeamData>());
}
public DivisionData GetDivision(EDivision division)
{
int divisionIndex = (int)division;
if (divisionIndex >= 0 && divisionIndex < (int)EDivision.Max)
{
return(divisions[(int)division]);
}
return(new DivisionData());
}
public ExData(ExData InData)
{
JudgeNameId = InData.JudgeNameId;
Division = InData.Division;
Round = InData.Round;
Pool = InData.Pool;
Team = InData.Team;
Point1Count = InData.Point1Count;
Point2Count = InData.Point2Count;
Point3Count = InData.Point3Count;
Point5Count = InData.Point5Count;
}
public static TeamData GetTeamData(EDivision InDiv, ERound InRound, int InPool, int InTeam)
{
if ((int)InDiv < Global.AllData.AllDivisions.Length &&
(int)InRound < Global.AllData.AllDivisions[(int)InDiv].Rounds.Length &&
InPool < Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools.Count &&
InTeam < Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools[InPool].Teams.Count)
{
return(Global.AllData.AllDivisions[(int)InDiv].Rounds[(int)InRound].Pools[InPool].Teams[InTeam].Data);
}
return(null);
}
public void GenerateFuturePools()
{
for (EDivision division = EDivision.Open; division < EDivision.Max; ++division)
{
for (ERound round = ERound.Finals; round != ERound.Max; ++round)
{
for (EPool pool = EPool.A; pool != EPool.Max; ++pool)
{
GenerateNextPool(division, round, pool);
}
}
}
}
public static bool IsValid(EDivision InDivision, ERound InRound, EPool InPool, int InTeam)
{
if ((int)InDivision >= 0 && (int)InRound >= 0 && InPool >= 0 && InTeam >= 0 &&
(int)InDivision < Global.AllData.AllDivisions.Length &&
(int)InRound < Global.AllData.AllDivisions[(int)InDivision].Rounds.Length &&
(int)InPool < Global.AllData.AllDivisions[(int)InDivision].Rounds[(int)InRound].Pools.Count &&
InTeam < Global.AllData.AllDivisions[(int)InDivision].Rounds[(int)InRound].Pools[(int)InPool].Teams.Count)
{
return(true);
}
return(false);
}
public DiffData(DiffData InData)
{
JudgeNameId = InData.JudgeNameId;
Division = InData.Division;
Round = InData.Round;
Pool = InData.Pool;
Team = InData.Team;
NumScores = InData.NumScores;
for (int i = 0; i < InData.DiffScores.Length; ++i)
{
DiffScores[i] = InData.DiffScores[i];
ConsecScores[i] = InData.ConsecScores[i];
}
}
public void InitMaxTeams(EDivision inDivision, ERound inRound)
{
if (inRound == ERound.Finals)
{
if (inDivision == EDivision.Coop || inDivision == EDivision.Women || inDivision == EDivision.Mixed)
{
maxTeams = 6;
return;
}
}
maxTeams = 8;
}
public AIData(AIData InData)
{
JudgeNameId = InData.JudgeNameId;
Division = InData.Division;
Round = InData.Round;
Pool = InData.Pool;
Team = InData.Team;
Variety = InData.Variety;
Teamwork = InData.Teamwork;
Music = InData.Music;
Flow = InData.Flow;
Form = InData.Form;
General = InData.General;
}
public void GetPlayingTeams(EDivision division, ERoundJudgeDisplay round, int controlIndex, out ObservableCollection <TeamData> outPlayingTeams)
{
EPool pool = EnumConverter.ConvertPoolValue(round, controlIndex);
if (pool != EPool.None)
{
PoolData pd = tournamentData.GetPool(division, EnumConverter.ConvertRoundValue(round), pool);
outPlayingTeams = pd.teamList.teams;
}
else
{
outPlayingTeams = null;
}
}
public RoundData GetRound(EDivision division, ERound round)
{
int divisionIndex = (int)division;
if (divisionIndex >= 0 && divisionIndex < (int)EDivision.Max)
{
int roundIndex = (int)round;
if (roundIndex >= 0 && roundIndex < (int)ERound.Max)
{
return(divisions[divisionIndex].rounds[roundIndex]);
}
}
return(new RoundData());
}
// Update is called once per frame
public void Update()
{
Global.NetObj.UpdateUdpListener();
Global.NetObj.UpdateHeadJudgeState();
CurDivision = (EDivision)DivisionCombo.GetSelectedItemIndex();
CurRound = (ERound)RoundCombo.GetSelectedItemIndex();
UpdateConnectedJudgeList(ref AIJudges);
UpdateConnectedJudgeList(ref ExJudges);
UpdateConnectedJudgeList(ref DiffJudges);
UpdateActiveJudgingJudgersCount();
}
public static ResultsData FindResultsData(EDivision InDiv, ERound InRound, EPool InPool)
{
if (Global.AllData.ResultsList == null)
{
return(null);
}
foreach (ResultsData rd in Global.AllData.ResultsList)
{
if (rd.Division == InDiv && rd.Round == InRound && rd.Pool == InPool)
{
return(rd);
}
}
return(null);
}
void ImportDivisionData(TournamentData importedData, XmlNode node, EDivision division)
{
DivisionData divisionData = new DivisionData(division);
foreach (XmlNode roundNode in node.ChildNodes) // Rounds
{
ERound round = ERound.Finals;
foreach (XmlNode roundDataNode in roundNode.ChildNodes)
{
RoundData roundData = new RoundData(division, round);
EPool pool = EPool.A;
foreach (XmlNode poolDataNode in roundDataNode.FirstChild.ChildNodes) // Pools
{
PoolData poolData = new PoolData(pool);
foreach (XmlNode poolDataChildNode in poolDataNode.ChildNodes)
{
if (poolDataChildNode.Name == "PoolName")
{
poolData.pool = (EPool)Enum.Parse(typeof(EPool), poolDataChildNode.FirstChild.Value);
}
else if (poolDataChildNode.Name == "Teams")
{
ImportTeams(importedData, divisionData, poolData, poolDataChildNode);
ImportJudges(importedData, divisionData, poolData, poolDataChildNode);
}
else if (poolDataChildNode.Name == "ResultsByTeamIndex")
{
ImportPoolResults(poolData, poolDataChildNode);
}
}
roundData.pools.Add(poolData);
++pool;
}
divisionData.rounds.Add(roundData);
++round;
}
}
importedData.divisions.Add(divisionData);
}
public PoolData GetPool(EDivision division, ERound round, EPool pool)
{
int divisionIndex = (int)division;
if (divisionIndex >= 0 && divisionIndex < (int)EDivision.Max)
{
int roundIndex = (int)round;
if (roundIndex >= 0 && roundIndex < (int)ERound.Max)
{
int PoolIndex = (int)pool;
if (PoolIndex >= 0 && PoolIndex < divisions[divisionIndex].rounds[roundIndex].pools.Count)
{
return(divisions[divisionIndex].rounds[roundIndex].pools[PoolIndex]);
}
}
}
return(new PoolData());
}
private void PoolsRandomizePlayOrder(EDivision division, ERound round)
{
RoundData rd = tournamentData.GetRound(poolsDivision, round);
foreach (PoolData pd in rd.pools)
{
ObservableCollection <TeamData> teams = pd.teamList.teams;
ObservableCollection <TeamData> newTeamList = new ObservableCollection <TeamData>();
while (teams.Count > 0)
{
int pickIndex = random.Next(0, teams.Count());
newTeamList.Add(teams[pickIndex]);
teams.RemoveAt(pickIndex);
}
pd.teamList.teams = newTeamList;
}
PoolsUpdateBindings();
}
public double GetMultiplier(EDivision division, int points, EOrderType orderType)
{
double multiplier = 1.25;
multiplier -= ((int)division * 0.10);
multiplier += points * 0.001;
switch (orderType)
{
case EOrderType.GamesBoost:
{
multiplier *= 0.80;
break;
}
case EOrderType.DuoQWinsBoost:
{
multiplier *= 1.25;
break;
}
}
return(multiplier);
}
