0votos

Generar movimientos de ajedrez en lenguaje C y Bitboards en C

por josejuan hace 6 años

PEÓN. Ja, ja, ... muy bueno, aunque podías haber explicado un poco mejor el problema (eg. se supone una máquina con tamaño de palabra de 64 bits, el tipo de datos que tenemos sobre el movimiento, etc...). Eso me recuerda que para el tres en raya use bitboards (no conocía el nombre). Empiezo con el peón. (Sugiero poner cada "pieza" y/o "movimiento" en soluciones diferentes).

Hacer una función que genere de forma genérica los movimientos de las piezas de ajedrez. Olvidarse de validación de movimientos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# para sacar cualquier pieza del tablero es (ésto para todas las piezas en todos los movimientos) 
chesboard &= ~(1 << posicionActual); 
 
 
# avance "normal" de peón 
chesboard |= 1 << (posicionActual + 8); // blancas 
chesboard |= 1 << (posicionActual - 8); // negras 
 
# salida "doble" (no se como se llama el movimiento) inicial del peón 
chesboard |= 1 << (posicionActual + 16); // blancas 
chesboard |= 1 << (posicionActual - 16); // negras 
 
# peón come pieza "al paso" 
chesboard |= 1 << (posicionActual + 7); // blancas a izquierda 
chesboard |= 1 << (posicionActual + 9); // blancas a derecha 
chesboard |= 1 << (posicionActual - 7); // negras a derecha 
chesboard |= 1 << (posicionActual - 9); // negras a izquierda 
8 comentarios
0votos

Escrito por Arturo hace 6 años

Tienes toda la razón, aplicando bitboards para el tic tac toe ó gato lo hace mas eficiente y mucho mas fácil computar las posibiliades. Excelente respuesta! Aunque para la salida doble no es necesario hacer mas corrimientos de bits, simplemente puedes crear una función que cuente movimientos por medio de banderas.
0votos

Escrito por josejuan hace 6 años

simplemente puedes crear una función

Ya lo dudo, pero puedes postearla.
0votos

Escrito por Arturo hace 6 años

Por cierto, en vez de restar el número es más eficiente usar el corrimiento en sentido contrario :)
0votos

Escrito por josejuan hace 6 años

Va a ser que no, porque el desplazamiento de bits no acarrea el overflow. Pero puedes postear esa solución.
0votos

Escrito por Arturo hace 6 años

char white[7];

    if((rowDif==2))
    {
        if(((iniCol=='a')&&(white[0]==0))||((iniCol=='b')&&(white[1]==0))||((iniCol=='c')&&(white[2]==0))||((iniCol=='d')&&(white[3]==0))||((iniCol=='e')&&(white[4]==0))||((iniCol=='f')&&(white[5]==0))||((iniCol=='g')&&(white[6]==0))||((iniCol=='h')&&(white[7]==0)))
        {
            switch(iniCol)
            {
                case 'a':
                    white[0]=1;
                    break;
                    
                case 'b':
                    white[1]=1;
                    break;
                    
                case 'c':
                    white[2]=1;
                    break;
                    
                case 'd':
                    white[3]=1;
                    break;
                    
                case 'e':
                    white[4]=1;
                    break;
                    
                case 'f':
                    white[5]=1;
                    break;
                    
                case 'g':
                    white[6]=1;
                    break;
                    
                case 'h':
                    white[7]=1;
                    break;
                    
                default:
                    break;
            }
            return 1;
        }
        else{
            return 0;
        }
        }
    else{
        if(rowDif==1){
            switch(iniCol)
            {
                case 'a':
                    white[0]=1;
                    break;
                    
                case 'b':
                    white[1]=1;
                    break;
                    
                case 'c':
                    white[2]=1;
                    break;
                    
                case 'd':
                    white[3]=1;
                    break;
                    
                case 'e':
                    white[4]=1;
                    break;
                    
                case 'f':
                    white[5]=1;
                    break;
                    
                case 'g':
                    white[6]=1;
                    break;
                    
                case 'h':
                    white[7]=1;
                    break;
                    
                default:
                    break;
            }
            else {
return 0;
}
0votos

Escrito por josejuan hace 6 años

¡Pero pónla como OTRA solución, no en mi solución! XD XD XD

Y por cierto, no te haces ni idea de lo deficiente que es tu solución respecto de la mía. Aparte que lo que usas no es un bitboard... ¡¿pero no habías posteado tú el problema?!
0votos

Escrito por Arturo hace 6 años

Pero después de que se usa la regla de dos casillas por peón, tienes que prohibir otro movimiento de ese tipo. No es muy eficiente, lo sé, por que asignar valores al arreglo y comprobar cada vez pierdo mucho tiempo.¿Que solución le darias tu?
0votos

Escrito por josejuan hace 6 años

Cíñete a tu propio enunciado:

+ Bitboards
+ Olvidarse de validación de movimientos

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.