Estoy buscando urgentemente un programa para un juego de ajedrez escrito en lenguaje C o C++. Si tienes alguno, envíalo a mi correo electrónico: na1234567899@163.com.

Estoy buscando urgentemente un programa para un juego de ajedrez escrito en lenguaje C o C++. Si tienes alguno, envíalo a mi correo electrónico: na1234567899@163.com Gracias Xiaofaneq Nivel 2

Obténgalo primero Comprenda la estructura de los datos:

Asegúrese de leer primero las cosas en MantisChessDef.h; de lo contrario, se confundirá.

También hay coordenadas del tablero:

El tamaño del tablero de ajedrez es 9x10 Para facilitar la programación, se estipula que cada lado del tablero tiene un límite de un elemento. .

El tamaño del tablero (incluidos los bordes) pasa a ser de 11x12. El eje x del tablero de ajedrez está hacia la derecha y el eje y está hacia abajo.

Las negras siempre están arriba En la apertura estándar, las coordenadas de la torre negra en la esquina superior izquierda son (1, 1).

La situación está representada por estas tres variables:

static POINT g_pointChessman[32]; //coordenadas de la pieza de ajedrez

static int g_iChessmanMap[11][12 ]; //Estado de la posición del ajedrez

static int g_iSide; //¿De qué lado le toca moverse?

Los primeros tres parámetros de varias funciones en la parte inteligente son solo esto, ¿No debería ser difícil de entender?

---------------------------------- ------------- ------------------------------------- -----------

Función de búsqueda:

En primer lugar, los amigos a menudo me preguntan cuáles son los principios, pero les revelo el código fuente para darles a todos una Referencia, no un tutorial, así que no quiero hablar de esas cosas teóricas.

El principio básico es la búsqueda alfa-beta, que se menciona en muchos libros de texto de inteligencia artificial. Si no lo has leído, busca uno y echa un vistazo.

Aunque estos; libros La mayor parte del texto es oscuro y difícil de entender, pero después de todo, se explica claramente.

Para los que no tienen un libro, por favor usen su iniciativa y búsquenlo, no me lo pidan, porque yo tampoco lo tengo.

Aquí solo analizaré la función de búsqueda:

Después de comprender la búsqueda α-β, echemos un vistazo a este árbol de juegos y veamos cómo programarlo.

En primer lugar, estipulemos que usamos un número entero para representar la calidad de la situación.

Cuanto mayor sea el número, más favorable será la situación para el "lado jugador". y 0 significa que ambos lados tienen la misma fuerza.

1a( 1) ┬ 2a(-1) ┬ 3a(-1)

│ └ 3b( 1)

└ 2b(-5) ┬ 3c( 2)

├ 3d(-4)

└ 3e( 5)

Analice este árbol, tiene las siguientes características: Valor del nodo principal = - MAX (valor del nodo hijo)

También sabemos que 1. Cada nodo corresponde a una situación. 2. Se "estima" el valor del nodo subyacente.

Entonces podemos escribir pseudocódigo:

Pseudocódigo: busca las ramas debajo de un nodo y obtiene el valor de este nodo.

Parámetros: situación, profundidad de búsqueda

Valor de retorno: valor de nodo

int search(situación, profundidad int)

{

if(profundidad!=0)//No es el nodo inferior

{

Enumerar todos los nodos secundarios (enumerar todos los movimientos

); int count=número de nodos secundarios;

int maxvalue= -∞;

for(int i=0;i

{

Calcular la situación de los nodos secundarios;

maxvalue=max(maxvalue, search(situación del nodo secundario, profundidad-1)); }

return -maxvalue;

}

else //Es el nodo subyacente

{

devolver el valor estimado;

}

}

Este es el marco del algoritmo de búsqueda, que utiliza recursividad.

Las funciones inteligentes de MantisChess están todas en MantisChessThink.cpp, donde buscar es buscar, que es similar a la búsqueda anterior. Lo copiaré y lo comentaré:

int Search(int tmap. [11][12],POINT tmanposition[32],int &tside,int man, POINT point,int upmax,int Depth)

{

// Los primeros tres Los parámetros son la situación.

//man y point son movimientos que se utilizan para calcular la situación de este nodo. Aquí, la situación de cálculo se coloca al comienzo de la función, que es diferente del pseudocódigo anterior.

//upmax: up - la capa anterior, max - el valor máximo Esto es lo que se usa para la poda α-β, que se discutirá más adelante.

//profundidad: profundidad de búsqueda

int ate,cur,maxvalue,curvalue,xs,ys;

int count;

//#####################Este párrafo es la situación de cálculo de este nodo################## ######################

ate=32;

//Mover la pieza de ajedrez:

xs=tmanposition[man].x;ys=tmanposition[man].y; //coordenadas originales

if (SideOfMan[tmap[point.x][point.y]]= = !tside) //Hay una pieza del oponente en el punto objetivo

{

ate=tmap[point.x][point.y] //Registra la pieza capturada

if(ate==0 || comió==16)

{

devuelve 9999;

}

tmanposition[ate].x=0; // Se captura la pieza de ajedrez en el punto objetivo

}

tmap[point.x][point.y]= man; //Estas dos líneas son:

tmap[xs][ys]=32; //Movimiento en el mapa

tmanposition[man]=point;

tside=!tside;

//################################ # ################################################

profundidad--;

if(profundidad>0) //No el nodo inferior

{

int chessman[125];

PUNTO targetpoint[125];

if(EnumList(tmap,tmanposition,tside,chessman,targetpoint,count)) //Enumerar todos los nodos secundarios (enumerar todos Cómo moverse)

{

//@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@

//Esto es poda (no poda α-β). El principio es utilizar una búsqueda menos profunda para obtener un valor con un error mayor antes de la búsqueda formal

// Luego ordene los nodos secundarios de acuerdo con estos valores. Sólo conserve los mejores nodos S_WIDTH para la búsqueda formal.

//Evidentemente esta poda tiene ciertos riesgos

if(profundidad>=2 && count>S_WIDTH+2)

{

int valor[125];

cur=0;

maxvalue=-10000;

while(cur< cuenta)

{

curvalue=Buscar(tmap,tmanposition,tside,chessman[cur],targetpoint[cur],-10000,profundidad-2);

valor[cur]= curvalue;

if(curvalue>maxvalue)maxvalue=curvalue;

cur ++;

}

::Mantis_QuickSort(valor, pieza de ajedrez ,targetpoint,0,count-1); //Ordenar

count=S_WIDTH;//Podar

}

//@@@ @@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@ @@@@@@@@@@@@@@@@

maxvalue=-10000;

cur=0;

mientras(cur< recuento)

{

curvalue=Buscar(tmap,tmanposition,tside,chessman[cur],targetpoint[cur ],maxvalue,profundidad);

if (curvalue>maxvalue)maxvalue=curvalue;

if(curvalue>=-upmax)goto _ENDSUB; //poda α-β, recorta aquellas que cumplan con las condiciones de poda. Aquí se utiliza la declaración goto, así que no sigas mi ejemplo.

cur ++;

}

}

else maxvalue=9800;

}

else //Es el nodo subyacente

{

maxvalue=Value(tmap,tmanposition,tside); //Valoración

}

_ENDSUB:

//Restaurar la situación del nodo padre antes de regresar

//############### ################################################ ## #################

tmanposition[man].x=xs //Estas dos líneas son:

tmanposition [man] ].y=ys; //Restaurar en la cara

tmap[xs][ys]=man; //Restaurar en el mapa

if(ate! =32)

{

tmanposition[ate]=punto;

tmap[point.x][point.y]=ate;

}

else tmap[point.x][point.y]=32;

tside=!tside;

//### ###### ########################################## ######## ######################

return -maxvalue;

}

Lo anterior El código utiliza poda α-β, que se puede entender dando un ejemplo:

Sigue siendo el mismo árbol de juego, atravesado de arriba a abajo.

1a( 1) ┳ 2a(-1) ┳ 3a(-1)

┃ ┗ 3b( 1)

┗ 2b(-5) ┯ 3c( 2)

├ 3d(-4)

└ 3e( 5)

Upmax=-1 después de atravesar 2a, continúa atravesando 3c Volver a 2b y encuentre que 3c=2>-upmax. En este momento, no hay necesidad de preocuparse por 3d y 3e, porque no importa cuáles sean sus valores, 2b=-max(3c,3d,3e)<2a debe. ser cierto,

Eso significa que 2b se puede cortar de forma segura. Esta es la poda alfa-beta.

Del código anterior, mi algoritmo MantisChess no es diferente de la búsqueda de poda estándar α-β, excepto que se agregan clasificación y poda.

Lo encontré en línea y acordé

0| Comentarios

2012-4-14 23:25 leexye Nivel 6

Este tipo Si solicitas directamente el código fuente, incluso si me lo das, probablemente no podrás leerlo ni aceptarlo.

0| Comentarios