コード例 #1
0
        /// <summary>
        /// Organizar a lista Jornadas de modo a que esta tenha as jornadas e as jornadas uma lista de Jogos a seres jogados nessas jornadas
        /// </summary>
        /// <param name="Jogos"></param>
        /// <returns></returns>
        public static List <DadosJornada> OrganizarJornadas(List <DadosJogo> Jogos)
        {
            List <DadosJornada> Jornadas = new List <DadosJornada>();

            if (Jogos.Count != 0)
            {
                int numJogosJornada = 4;
                int numJogo         = 0;

                do
                {
                    DadosJornada jornada = new DadosJornada
                    {
                        Jogos = new List <DadosJogo>()
                    };

                    do
                    {
                        jornada.Jogos.Add(Jogos[numJogo]);
                        numJogo++;
                    } while (numJogo < numJogosJornada);

                    Jornadas.Add(jornada);
                    numJogosJornada += 4;
                } while (numJogo != 56);

                return(Jornadas);
            }

            return(Jornadas);
        }
コード例 #2
0
        /// <summary>
        /// Gravar informações da lista Jornadas no ficheiro xml jogoInfo
        /// </summary>
        /// <param name="Jornadas"></param>
        public static void GravarInfoJogo(List <DadosJornada> Jornadas)
        {
            string        ficheiro = "jogoInfo.xml";
            XmlSerializer serial   = new XmlSerializer(typeof(List <DadosJogo>));
            StreamWriter  sw       = new StreamWriter(ficheiro);

            if (Jornadas.Count == 0)
            {
                DadosJornada jornada = new DadosJornada();

                serial.Serialize(sw, jornada.Jogos);
            }
            else
            {
                DadosJornada jornada = new DadosJornada()
                {
                    Jogos = new List <DadosJogo>()
                };

                for (int i = 0; i < Jornadas.Count; i++)
                {
                    for (int j = 0; j < Jornadas[i].Jogos.Count; j++)
                    {
                        jornada.Jogos.Add(Jornadas[i].Jogos[j]);
                    }
                }
                serial.Serialize(sw, jornada.Jogos);
            }

            sw.Close();
        }
コード例 #3
0
        /// <summary>
        /// Preencher a lista Jogos a partir das lista voltas1 e voltas2
        /// </summary>
        /// <param name="dadosJornada"></param>
        /// <param name="voltas1"></param>
        /// <param name="voltas2"></param>
        /// <returns></returns>
        public static List <DadosJogo> PreencherListaJogos(DadosJornada dadosJornada, List <DadosJogo> voltas1, List <DadosJogo> voltas2)
        {
            dadosJornada.Jogos = new List <DadosJogo>();

            //Primeira volta
            for (int i = 0; i < voltas1.Count; i++)
            {
                dadosJornada.Jogos.Add(voltas1[i]);
            }

            //Segunda volta
            for (int i = 0; i < voltas2.Count; i++)
            {
                dadosJornada.Jogos.Add(voltas2[i]);
            }

            return(dadosJornada.Jogos);
        }
コード例 #4
0
        /// <summary>
        /// Procurar ficheiro xml jogoInfo, se não existir cria-se um novo ficheiro, se existir a lista Jornadas vai ser preenchida com a informação que estiver contida no ficheiro
        /// </summary>
        /// <param name="Jornadas"></param>
        /// <returns></returns>
        public static List <DadosJornada> LerFicheiroJogos(List <DadosJornada> Jornadas)
        {
            DadosJornada dadosJornada = new DadosJornada();
            string       ficheiro     = "jogoInfo.xml";

            if (!File.Exists(ficheiro))
            {
                GravarInfoJogo(Jornadas);
            }

            if (new FileInfo(ficheiro).Length == 0)
            {
                GravarInfoJogo(Jornadas);
            }

            XmlSerializer serial = new XmlSerializer(typeof(List <DadosJogo>));
            StreamReader  sr     = new StreamReader(ficheiro);

            dadosJornada.Jogos = (List <DadosJogo>)(serial.Deserialize(sr));
            sr.Close();

            return(OrganizarJornadas(dadosJornada.Jogos));
        }
コード例 #5
0
        /// <summary>
        /// Gerar todos os jogos do campeonato
        /// </summary>
        /// <param name="Clubes">Lista de clubes</param>
        /// <returns>Retorna uma lista de objetos do tipo jornada, tendo cada jornada uma lista de jogos a jogar nessa jornada</returns>
        public static List <DadosJornada> CriarJogosCampeonato(List <DadosClube> Clubes)
        {
            List <DadosJogo> voltas1      = new List <DadosJogo>();
            List <DadosJogo> voltas2      = new List <DadosJogo>();
            DadosJornada     dadosJornada = new DadosJornada();
            Random           rng          = new Random();
            int rnd;

            int max                  = 28; //número máximo de jogos por volta, verificações
            int maxJornada           = 3;  //número máximo do Count por jornada, verificações
            int jogosPrimeiraJornada = 4;  //número de jogos da primeira jornada, verificações
            int inicioJornada        = 0;  //número correspondente ao primeiro jogo de cada jornada(Count), verificações
            int jornadaAnterior      = 0;  //número correspondente ao primeiro jogo da jornada anterior(Count), verificações
            int mesmaJornada         = 4;  //número correspondente ao primeiro jogo da jornada(Count), verificações
            int novaJornada          = 8;  //verificações
            int numJogosPorJornada   = 4;  //número de jogos por jornada, verificações

            do
            {
                for (int i = 0; i < Clubes.Count - 1; i++)
                {
                    for (int j = i + 1; j < Clubes.Count; j++)
                    {
                        int contador = 0;
                        rnd = rng.Next(1, 11);

                        //1º jornda
                        if (voltas1.Count < jogosPrimeiraJornada)
                        {
                            primeriaJornada(voltas1, voltas2, Clubes, contador, maxJornada, inicioJornada, rnd, i, j);

                            if (voltas1.Count == jogosPrimeiraJornada)
                            {
                                maxJornada    += 4;
                                inicioJornada += 4;
                            }
                        }
                        else
                        {
                            //jornadas restantes
                            outrasJornadas(voltas1, voltas2, Clubes, contador, maxJornada, inicioJornada, rnd, i, j, jornadaAnterior, mesmaJornada);

                            if (voltas1.Count % numJogosPorJornada == 0 && voltas1.Count != jogosPrimeiraJornada && voltas1.Count == novaJornada)
                            {
                                maxJornada      += 4;
                                mesmaJornada    += 4;
                                inicioJornada   += 4;
                                jornadaAnterior += 4;
                                novaJornada     += 4;
                            }
                        }
                    }
                }
            } while (voltas1.Count != max);

            DataVolta1(voltas1);
            DataVolta2(voltas2);
            OrdenarListaVoltas(voltas1, voltas2);
            EstadioVoltas(voltas1, voltas2);
            FinalizarVoltas(voltas1, voltas2);
            dadosJornada.Jogos = PreencherListaJogos(dadosJornada, voltas1, voltas2);

            return(MetodosJornada.OrganizarJornadas(dadosJornada.Jogos));
        }