IA.java

package ajedrez;

import java.util.*;

class IA{

int valorNecesario = -1;
int x = 0;
int y = 0;
int coorX = 0;
int coorY = 0;
boolean movimiento = false;
Random random = new Random();
int atributoFinal = 0;

/*IA(partida){
    this.partida = partida;
}*/

//metodo que busca una pieza dentro de la matriz
void getCoordenadas(){
    int i, j;
    int [][]temp = null;
    for(i = 0; i < 8; i++){
        for(j = 0; j < 8; j++){
        if((valorNecesario <= 0) && (valorNecesario >= -16)){
            if(temp[j][i] == valorNecesario){
            x = i;
            y = j;
            this.evaluacion(x, y);
            valorNecesario = valorNecesario - 1;
            }
            else{
            valorNecesario = valorNecesario - 1;
            }
        }}
    }
}

void evaluacion(int coordx, int coordy){
    int i, j;
    int [][]temp = null;
    int nuevoAtributo = 0;
    for(i = coordx; i >= 0; i--){
        for(j = 7; j >= 0; j--){
            //movimiento = checarColisiones();
            if((temp[j][i] == 1)||(temp[j][i] == 2)||(temp[j][i] == 3)||(temp[j][i] == 4)||(temp[j][i] == 5)||(temp[j][i] == 6)||(temp[j][i] == 7)||(temp[j][i] == 8)){
            nuevoAtributo = ganarAtributo(1);
            this.compararAtributo(nuevoAtributo, j, i);
            }
            if(temp[j][i] == 2){
                nuevoAtributo = ganarAtributo(2);
                this.compararAtributo(nuevoAtributo, j, i);
            }
            if(temp[j][i] == 3){
                nuevoAtributo = ganarAtributo(3);
                this.compararAtributo(nuevoAtributo, j, i);
            }
            if(temp[j][i] == 4){
                nuevoAtributo = ganarAtributo(4);
                this.compararAtributo(nuevoAtributo, j, i);
            }
            if(temp[j][i] == 5){
                nuevoAtributo = ganarAtributo(5);
                this.compararAtributo(nuevoAtributo, j, i);
            }
            if(temp[j][i] == 6){
                nuevoAtributo = ganarAtributo(6);
                this.compararAtributo(nuevoAtributo, j, i);
            }
        }
    }
}

void compararAtributo(int puntos, int x, int y){
    if(puntos > atributoFinal){
        atributoFinal = atributoFinal + puntos;
        this.destinoX(x);
        this.destinoY(y);
    }
    if((puntos == atributoFinal) && (puntos > 0) && (atributoFinal > 0)){
        this.destinoX(x);
        this.destinoX(y);
    }
    if((puntos == atributoFinal) && (puntos == 0) && (atributoFinal == 0)){
        this.destinoX(this.coordenadaRandom());
        this.destinoY(this.coordenadaRandom());
    }

}

void destinoX(int X){
    coorX = X;
}

void destinoY(int Y){
    coorY = Y;
}

int getCoordX(){
    return coorX;
}

int getCoordY(){
    return coorY;
}

/*boolean checarColisiones(){
    return true;
}*/
//en caso de no haber algun movimiento que beneficie a la computadora genera coordenadas random
int coordenadaRandom(){
return random.nextInt(8);
}

int ganarAtributo(int a){
    int atributo;
    if(a == 1){
        atributo = 1;
    }
    if(a == 2){
        atributo = 2;
    }
    if(a == 3){
        atributo = 3;
    }
    if(a == 4){
        atributo = 4;
    }
    if(a == 5){
        atributo = 5;
    }
    if(a == 6){
        atributo = 6;
    }
    else{
        atributo = 0;
    }
    return atributo;
}
}

/* En caso de que ningun puntaje sea mayor a 0 se genera un random y que suelte cualquier movimiento sin importar cual sea
int obtieneCoordenadas(int coordx, int coordy){
    mi variable x  = coordx
    mi variable y = coordy
}

int generomoviemiento(){

    if(mis coordenasSonValidas)
        generomovimientoaleatorio()
        if(movimientoaleatoriovalido == true)
        while(colision != true) //colision se refiere a chocar con los limites del tablero o encontrar una pieza enemiga o aliada
            sumarpuntajeporcasilla() //las piezas amigas sumaran negatvos al puntage las piezas enemigas sumaran enteros
        do
    if(puntajeNuevo > puntajeActual){
        puntajeActual = puntajeNuevo
        puntajeNuevo = 0;
        coordenadasFavorables = coordenadasGeneradas}
    else{
        puntajeNuevo = 0;
        coordenadasGeneradas = borrar //se igualan a cero o null
        }

regresarCoordenadas();
    regreso coordenadasFavorables()
}




  boolean mover( Posicion origen, Posicion destino, int turno){
    if( Posicion.esIgual(origen,destino)) return false;
    if( tablero[destino.x][destino.y] != 0) return false;
    if( (origen.x == destino.x) && (origen.y+turno==destino.y)) return true;
    return false;
  }

  boolean atacar( Posicion origen, Posicion destino, int turno){
    if( Posicion.esIgual(origen,destino)) return false;
    if( (tablero[destino.x][destino.y] == 0) ||
         ( ( tablero[destino.x][destino.y] != 0) &&
           ( (tablero[destino.x][destino.y]/Math.abs(tablero[destino.x][destino.y])) == turno )
           )
        )return false;

    if(  ((origen.x+1 == destino.x) || (origen.x-1 == destino.x) ) &&
       ( origen.y+turno == destino.y)
       )return true;

    return false;
  }
*/