void ImportTeams(TournamentData importedData, DivisionData divisionData, PoolData poolData, XmlNode node)
{
foreach (XmlNode teamDataNode in node.ChildNodes)
{
TeamData teamData = new TeamData();
foreach (XmlNode playerDataNode in teamDataNode.FirstChild.FirstChild.ChildNodes)
{
if (playerDataNode.Name == "PlayerData")
{
RegisteredPlayer newPlayer = new RegisteredPlayer();
if (tournamentData.FindOrAddImportedRegisterPlayer(int.Parse(playerDataNode.FirstChild.FirstChild.Value), ref newPlayer))
{
teamData.players.Add(newPlayer);
importedData.AddRegisteredPlayer(newPlayer);
}
}
}
poolData.teamList.teams.Add(teamData);
bool bNewTeam = true;
foreach (TeamData td in divisionData.teamList.teams)
{
if (td.Equals(teamData))
{
bNewTeam = false;
break;
}
}
if (bNewTeam)
{
divisionData.teamList.teams.Add(teamData);
}
}
}
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 bool TryGetAutoGeneratePools(ERound round, EPool pool, out PoolData pool1, out PoolData pool2, out PoolData nextPool)
{
return(TryGetAutoGeneratePools(poolsDivision, round, pool, out pool1, out pool2, out nextPool));
}
public void Init()
{
if (divisions.Count == 0)
{
for (int i = 0; i < (int)EDivision.Max; ++i)
{
DivisionData dd = new DivisionData((EDivision)i);
dd.CreateData();
divisions.Add(dd);
}
}
else
{
for (EDivision division = EDivision.Open; division < EDivision.Max; ++division)
{
if ((int)division < divisions.Count)
{
DivisionData dd = divisions[(int)division];
if (dd.division == EDivision.None)
{
dd.division = division;
}
for (ERound round = ERound.Finals; round < ERound.Max; ++round)
{
if ((int)round < dd.rounds.Count)
{
RoundData rd = dd.rounds[(int)round];
if (rd.round == ERound.None || rd.round == ERound.Max)
{
rd.round = round;
}
if (rd.maxTeams == 0)
{
rd.InitMaxTeams(division, round);
}
int poolCount = GetPoolCount(round);
for (EPool pool = EPool.A; (int)pool < poolCount; ++pool)
{
if ((int)pool < rd.pools.Count)
{
PoolData pd = rd.pools[(int)pool];
if (pd.pool == EPool.None)
{
pd.pool = pool;
}
}
else
{
PoolData pd = new PoolData(pool);
pd.CreateData();
rd.pools.Add(pd);
}
}
}
else
{
RoundData rd = new RoundData(division, round);
rd.CreateData();
dd.rounds.Add(rd);
}
}
}
else
{
DivisionData dd = new DivisionData(division);
dd.CreateData();
divisions.Add(dd);
}
}
}
}
