Exemple #1
0
double MiniMax(const Environment & tablero,int jug,int prof,int limite,Environment::ActionType & accion){
    const double INF=1000000000000.0, mINF=-1000000000000000.0, gano=999999999999999, pierdo=-999999999999999999;
    Environment::ActionType accion_anterior;
    double mejor, aux;
    if(prof==limite or tablero.JuegoTerminado()){
            return ValoracionTest(tablero,jug);
    }
    else{
        if(prof%2==0)
            mejor=mINF;
        else
            mejor=INF;
        int ult_act=-1;
        Environment hijo=tablero.GenerateNextMove(ult_act);
        while(!(hijo==tablero)){
            aux=MiniMax(hijo,jug,prof+1,limite,accion_anterior);
            if(prof%2==0){
                    if(aux>mejor){
                    mejor=aux;
                    accion=static_cast <Environment::ActionType>(ult_act);
                    }
                }
            else{
                if(aux<mejor){
                    mejor=aux;
                    accion=static_cast<Environment::ActionType>(ult_act);
                }
            }
            hijo=tablero.GenerateNextMove(ult_act);
        }
        return mejor;

        }
    }
Exemple #2
0
double Player::Poda_AlfaBeta(const Environment &tablero, int jugador, int prof, const int MAX_PROF,
    Environment::ActionType &accion, double alfa, double beta){
    if(prof==MAX_PROF || tablero.JuegoTerminado())
        return Valoracion(tablero, jugador);
    else{
        int last_accion=-1;
        double  temporal;
        Environment::ActionType accion_previa;
        Environment hijo=tablero.GenerateNextMove(last_accion);

        //NODO ALFA
        if((prof%2)==0){
            while(!(hijo==tablero)){
                temporal=Poda_AlfaBeta(hijo, jugador, prof+1,MAX_PROF, accion_previa, alfa, beta);
                // Si existe una jugada mejor, actualizamos el alfa.
                if(temporal > alfa){
                    alfa=temporal;
                    accion=static_cast<Environment::ActionType>(last_accion);
                }
                if(beta<=alfa){
                    break;
                }
                hijo=tablero.GenerateNextMove(last_accion);
            }
            return alfa;
        }

        //NODO BETA
        else{
            while(!(hijo==tablero)){
                temporal=Poda_AlfaBeta(hijo, jugador, prof+1,MAX_PROF, accion_previa, alfa, beta);
                // Si existe una jugada peor, actualizamos el beta.
                if(temporal < beta){
                    beta=temporal;
                    accion=static_cast<Environment::ActionType>(last_accion);
                }
                if(beta<=alfa){
                    break;
                }
                hijo=tablero.GenerateNextMove(last_accion);
            }
            return beta;
        }
    }
}
Exemple #3
0
double Poda_alphaBetha(const Environment & tablero,int jug,int prof,int limite,Environment::ActionType & accion,double alpha,double betha){
    Environment::ActionType accion_anterior=accion;
    double aux;
    if(prof==limite or tablero.JuegoTerminado()){
            return Valoracion(tablero,jug);
    }
    else{
        int ult_act=-1;
        Environment hijo=tablero.GenerateNextMove(ult_act);
        while(!(hijo==tablero)){
            aux=Poda_alphaBetha(hijo,jug,prof+1,limite,accion_anterior,alpha,betha);
            if(prof%2==0){
                if(aux>alpha){
                    alpha=aux;
                        if(prof==0)
                    		accion=static_cast <Environment::ActionType>(ult_act);
                }

            }
            else{
                if(aux<betha){
                    betha=aux;
                    //if(prof==0)
                       // accion=static_cast<Environment::ActionType>(ult_act);
                }

            }
            if(betha<=alpha)
                return alpha;
            hijo=tablero.GenerateNextMove(ult_act);
        }
	if (prof%2==0)
		return alpha;
	else
		return betha;

        }
    }
int valorMax(const Environment & actual, int jug, int profundidad, int limite_profundidad, int marcador) {

    int valor_max;

    Environment sigact[4];

    if (profundidad == limite_profundidad || !actual.a_movement_is_possible(jug))
        return Heuristica(actual, jug, marcador);

    else {
        int n_act = actual.GenerateNextMove(sigact, jug);
        valor_max = -INFINITO;
        for (int i = 0; i < n_act; i++) {
            valor_max = mayor(valor_max, valorMin(sigact[i], jug, profundidad+1, limite_profundidad, marcador));
        }
        return valor_max;
    }
}
/**
Esta funcion devuelve la siguiente mejor accion guiada por la heuristica usando el algoritmo minimax.
Devuelve: La siguiente accion a realizar.
Parametros:
    "actual" contiene el estado del tablero.
    "jug" indica que jugador esta pidiendo el valor heuristico.
    "limite_profundidad" establece el limite de exploracion del grafo.
OBSERVACION: esta parametrizacion es solo indicativa, y el alumno podra modificarla segun sus necesidades
*/
Environment::ActionType MiniMax(const Environment & actual, int jug, int limite_profundidad){
  Environment::ActionType accion;

  int mayor = -INFINITO, mayor_actual, profundidad = 0;

  Environment sigact[4];
  int n_act = actual.GenerateNextMove(sigact, jug);

  for (int i = 0; i < n_act; i++) {
        mayor_actual = valorMin(sigact[i], jug, profundidad+1, limite_profundidad, actual.Marcador(jug));
        if (mayor_actual > mayor) {
            mayor = mayor_actual;
            accion = static_cast<Environment::ActionType> (sigact[i].Last_Action(jug));
        }
  }
  cout << "Jugador: " << jug;
  cout << "     mayor " << mayor;
  cout << endl;
  return accion;
}
int valorMin(const Environment & actual, int jug, int profundidad, int limite_profundidad, int marcador) {

    int valor_min;
    int jug_adversario;

    if (jug == 1)
        jug_adversario = 2;
    else if (jug == 2)
        jug_adversario = 1;

    Environment sigact[4];

    if (profundidad == limite_profundidad || !actual.a_movement_is_possible(jug_adversario))
        return Heuristica(actual, jug, marcador);

    else {
        int n_act = actual.GenerateNextMove(sigact, jug_adversario);
        valor_min = INFINITO;
        for (int i = 0; i < n_act; i++) {
            valor_min = minimo(valor_min, valorMax(sigact[i], jug, profundidad+1, limite_profundidad, marcador));
        }
        return valor_min;
    }
}
Exemple #7
0
double PodaAlfaBeta(const Environment & tablero, int jugador, int profundidad, int profLimite, Environment::ActionType & accion, double alfa, double beta){
      Environment::ActionType ult_accion;
      

       //Profundidad máxima o fin del juego, se acabó
       if(profundidad == profLimite || tablero.JuegoTerminado())   
           return Valoracion(tablero, jugador);
       else{ // Hijos                                                                                                 
          int ult_act = -1;
          //Generar siguiente nodo tablero hijo
           Environment hijo = tablero.GenerateNextMove(ult_act);  

           //Profundidad par --> nodo MAX
          if(profundidad%2 == 0){                                                                             

           //Recorrido de nodos hijos
          while(!(hijo==tablero)){                                              

            double aux = PodaAlfaBeta(hijo, jugador, profundidad+1,profLimite,ult_accion,alfa,beta);

             // if (profundidad == 0)
                //cout << "Acción -> " << ult_act << endl;
              if(aux > alfa){
                alfa = aux;
                if (profundidad == 0)
                  accion = static_cast<Environment::ActionType> (ult_act);       
              } 

              if(beta <= alfa){                                                   
                return alfa; //poda
              } else {
             //Generación del siguiente nodo tablero hijo
                hijo = tablero.GenerateNextMove(ult_act); 
              }

          }

          return alfa; // no poda
          

          }else{                                                                     
            //Nivel impar -> nodo MIN
            while(!(hijo==tablero)){                                                

              double aux = PodaAlfaBeta(hijo, jugador, profundidad+1, profLimite, ult_accion, alfa, beta);

              if(aux < beta)
                beta = aux;       

              if(beta <= alfa){                                                 
                return beta;  //poda
              } else{
                hijo = tablero.GenerateNextMove(ult_act);          
              }                 

          }

          return beta; // no poda

      }


    }
}