Esempio n. 1
0
 public void trocaAfobadaDeCarta(IA iA)
 {
     bool trocou = false;
     List<CartaTerritorio> cartasJogador = iA.getCartasJogador();
     if (cartasJogador.Count() >= 3)
     {
         for (int i = 0; i < cartasJogador.Count(); i++)
         {
             for (int j = 0; j < cartasJogador.Count(); j++)
             {
                 for (int k = 0; k < cartasJogador.Count(); k++)
                 {
                     if (i != k && i != j && j != k)
                     {
                         if (cartasJogador[i].Equals(cartasJogador[j]) && cartasJogador[i].Equals(cartasJogador[k]) && cartasJogador[k].Equals(cartasJogador[j]) && !trocou)
                         {
                             Console.WriteLine("IA trocando carta!");
                             iA.distribuirExercito(MaquinaDeRegras.efetuaTroca(cartasJogador[i], cartasJogador[j], cartasJogador[k]));
                             trocou = true;
                         }
                         if (!cartasJogador[i].Equals(cartasJogador[j]) && !cartasJogador[i].Equals(cartasJogador[k]) && !cartasJogador[k].Equals(cartasJogador[j]) && !trocou)
                         {
                             Console.WriteLine("IA trocando carta!");
                             iA.distribuirExercito(MaquinaDeRegras.efetuaTroca(cartasJogador[i], cartasJogador[j], cartasJogador[k]));
                             trocou = true;
                         }
                     }
                 }
             }
         }
     }
 }
Esempio n. 2
0
 public void distribuiExercitoFullRandom(int quantidade, IA iA)
 {
     Random random = new Random();
     int randomNumber;
     for (int i = 0; i < quantidade; i++)
     {
         randomNumber = random.Next(0, iA.getTerritorios().Count() - 1);
         iA.getTerritorios()[randomNumber].setNumeroExercitos(1 + iA.getTerritorios()[randomNumber].getNumeroExercito());
         iA.removeExercitoParacolocar();
     }
 }
Esempio n. 3
0
 public void distribuiExercitoTerritoriosBordaRandom(int quantidade, IA iA)
 {
     Random random = new Random();
     int randomNumber;
     List<Territorio> territoriosComBorda = iA.getTerritoriosBorda();
     for (int i = 0; i < quantidade; i++)
     {
         randomNumber = random.Next(0, iA.getTerritorios().Count() - 1);
         territoriosComBorda[randomNumber].setNumeroExercitos(1 + territoriosComBorda[randomNumber].getNumeroExercito());
         iA.removeExercitoParacolocar();
     }
 }
Esempio n. 4
0
 //Mantem os territorios de borda com o mesmo numero de tropas
 public void distribuiExercitoTerritoriosBorda(int quantidade, IA iA)
 {
     List<Territorio> territoriosComBorda = iA.getTerritoriosBorda();
     Territorio bordaMenosTerrit = territoriosComBorda[0];
     for (int i = 0; i < quantidade; i++)
     {
         foreach (Territorio territ in territoriosComBorda)
         {
             if (bordaMenosTerrit.getNumeroExercito() > territ.getNumeroExercito())
             {
                 bordaMenosTerrit = territ;
             }
         }
         bordaMenosTerrit.setNumeroExercitos(bordaMenosTerrit.getNumeroExercito()+1);
         iA.removeExercitoParacolocar();
     }
 }
Esempio n. 5
0
 public void remanejaFullRandom(IA iA)
 {
     int randomNumber;
     Random random = new Random();
     foreach(Territorio origem in iA.getTerritorios())
     {
         foreach(Territorio destino in iA.getTerritorios())
         {
             randomNumber = random.Next(0, origem.getNumeroExercitoRemanejavel());
             if (MaquinaDeRegras.validaMovimentoRemanejamento(origem, destino, randomNumber))
             {
                 origem.setNumeroExercitos(origem.getNumeroExercito() - randomNumber);
                 destino.setNumeroExercitos(destino.getNumeroExercito() + randomNumber);
                 origem.setNumeroExercitosRemanejavel(origem.getNumeroExercitoRemanejavel() - randomNumber);
             }
         }
     }
 }
Esempio n. 6
0
        //Mantem os territorios de borda com o mesmo numero de tropas do territorio vizinho inimigo
        public void distribuiExercitoTerritoriosEqualizandoInimigo(int quantidade, IA iA)
        {
            List<Territorio> territoriosComBorda = iA.getTerritoriosBorda();
            while (quantidade > 0)
            {
                Territorio inimigo = null;
                Territorio meu = null;
                int dif = 0;
                foreach (Territorio territ in territoriosComBorda)
                {
                    foreach (Territorio territVizinho in territ.getListaVizinhosInimigos())
                    {
                        if (territ.getNumeroExercito() < territVizinho.getNumeroExercito() && ((territ.getNumeroExercito() - territVizinho.getNumeroExercito()) > dif))
                        {
                            dif = territVizinho.getNumeroExercito() -territ.getNumeroExercito();
                            inimigo = territVizinho;
                            meu = territ;
                        }
                    }

                }
                if (meu != null)
                {
                    if (dif < quantidade)
                    {
                        meu.setNumeroExercitos(meu.getNumeroExercito() + dif);
                        iA.removeExercitoParacolocar();
                        quantidade = quantidade - dif;
                    }
                    else
                    {
                        meu.setNumeroExercitos(meu.getNumeroExercito() + quantidade);
                        for (int i = 0; i < quantidade; i++)
                        {
                            iA.removeExercitoParacolocar();
                        }
                        quantidade = 0;
                    }
                }
            }
        }