elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, YreX-DwX)
| | |-+  matriz de movimiento del caballo en c++
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: matriz de movimiento del caballo en c++  (Leído 2,379 veces)
Arielcv87

Desconectado Desconectado

Mensajes: 1


Ver Perfil
matriz de movimiento del caballo en c++
« en: 1 Marzo 2017, 22:20 »

hola a todos, soy nuevo en el foro y quisiera solicitarles su ayuda, estoy programando el codigo de un juego de ajedrez pero soy nuevo y me atore en la parte del movimiento del caballo ya que me comentan que lo haga por matrices una matriz de 8x8, para los movimientos que son:
 x,  y
 2,  1
 2, -1
-2,  1
-2, -1
 1,  2
 1, -2
-1,  2
-1, -2

como tal no se vaciar estas coordenadas en una matriz y no he encontrado mucha informacion al respecto, espero puedan ayudarme y se los agradeceria mucho.


En línea

quecomendoza

Desconectado Desconectado

Mensajes: 1


Ver Perfil WWW
Re: matriz de movimiento del caballo en c++
« Respuesta #1 en: 13 Diciembre 2017, 19:01 »

Me interesa también lo del movimiento del caballo. A ver si alguien nos ilumina...


En línea

CalgaryCorpus


Desconectado Desconectado

Mensajes: 319


Ver Perfil WWW
Re: matriz de movimiento del caballo en c++
« Respuesta #2 en: 13 Diciembre 2017, 23:37 »

Si las coordenadas actuales del caballo son x, y
las posibles casillas resultan de la suma de (x,y) con cada una de las opciones que presentas.

Tal vez te conviene tener una función esValida(a.b) que devuelve true si los valores de a y b son indices válidos.


Tienes que hacer un programa que juegue ajedrez?
Uno que valide solamente?
Uno que genere jugadas posibles?
Que llevas hecho?
En línea

MAFUS


Desconectado Desconectado

Mensajes: 1.472



Ver Perfil
Re: matriz de movimiento del caballo en c++
« Respuesta #3 en: 14 Diciembre 2017, 12:47 »

De las coordenadas que has dado las tienes que sumar a la posición actual del caballo y comprobar si hay algo allí o que exista esa casilla (que esté fuera del tablero).

En plan, como te han dicho, int esValida(int x, int y); y que regrese 0 si no puede saltar para allá y 1 si puede saltar.

Sea Cx la posición X del caballo y Cy la posición Y del caballo.
Llamas, por ejemplo, esValida(Cx-2, Cy+1) y si te devuelve 1 cambias la posición del caballo: Cx -= 2; Cy++;

Espero que te sirva, estoy desde el móvil y es complicado formatear el texto.
En línea

while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}
NEBIRE


Desconectado Desconectado

Mensajes: 2.229


Ver Perfil
Re: matriz de movimiento del caballo en c++
« Respuesta #4 en: 14 Diciembre 2017, 17:34 »

Yo veo más interesante que una función devuelve un valor indicando cuales de las 8 posibles movimientos del caballo son válidas.

Se pasa a la función las cordenadas del caballo y el estado del tablero.
Con estado del tablero, se indica que contiene uno de estos 3 tipos de valores (en cada casilla del array que lo mantiene):
---: =0; Casilla no ocupada.
---: >0; Casillas ocupadas por el contrincante (el valor define que figura es).
---: <0; Casillas ocupadas por tus propias figuras (el valor define que figura es).

Luego, como el caballo tiene 8 posibles movimientos, usaremos un byte como respuesta:
- Cada bit a 1 indica movimiento posible (casilla vacía o figura del enemigo que se puede comer).
- Cada bit a 0, movimiento no posible (esto es, fuera del tablero u ocupada por tus propias figuras)

Código:
// Esta funcion devuelve un byte indicando en cada bit si la casilla correspondiente a dicho bit puede o no saltar el caballo a ella.
// Si el movimiento es posible y la casilla está vacía u ocupada por el enemigo, se pone el bit correspondiente a 1.
byte = funcion PosicionesValidas(entero x, entero y, array tablero() )
    byte n
    
    ' bit 0 y 5 (porque ambos comparten el x-1)
    Si (x-1) >= 0) luego
        Si (y-2) >= 0) luego // bit 0            
            Si Tablero(x-1, y-2) >= 0 luego n = 1 //previamente valía 0.
        fin si
        Si (y+2) >=0) luego //bit 5
            Si Tablero(x-1, y+2) >= 0 luego n= (n or 32)
        Fin si
    Fin si

    ' bit 1 y 4 (porque ambos comparten el x+1)
    Si (x+1) >= 0) luego
        Si (y-2) >= 0) luego // bit 1            
            Si Tablero(x+1, y-2) >= 0 luego n=(n or 2)
        fin si
        Si (y+2) >=0) luego //bit 4
            Si Tablero(x+1, y+2) >= 0 luego n= (n or 16)
        Fin si
    Fin si
// -----------------------------
     ' bit 6 y 7 (porque ambos comparten el x-2)
    Si (x-2) >= 0) luego
        Si (y-1) >= 0) luego // bit 6            
            Si Tablero(x-2, y-1) >= 0 luego n=(n or 64)
        fin si
        Si (y+1) >=0) luego //bit 7
            Si Tablero(x-2, y+1) >= 0 luego n= (n or 128)
        Fin si
    Fin si

    ' bit 2 y 3 (porque ambos comparten el x+2)
    Si (x+2) >= 0) luego
        Si (y-1) >= 0) luego // bit 2            
            Si Tablero(x+2, y-1) >= 0 luego n= (n or 4)
        fin si
        Si (y+1) >=0) luego //bit 3
            Si Tablero(x+2, y+1) >= 0 luego n= (n or 8)
        Fin si
    Fin si

    devolver n
fin funcion

- Otra función debiera admitir a qué cordenadas refiere un bit 'n' del byte (que devuelve la función anterior) dada la posición actual del caballo.
- Se añade además  a la función otro parámetro; el array del tablero, y así la función retorna un byte, que es indicadtivo de si se mueve a dicha casilla y si además 'se come' una ficha del enemigo, ó si no es posible moverse a ella...  
Código:
// Una enumeración para la devolución de la función así resulta útil saber que pasó.
//  igualmente bastaría un sByte y acordar que este
enumeracion PosibilidadesDeMovimiento
     Movimiento_No_Mueve = -1 //No se puede mover a esa posición (están tus figuras o apunta fuera del tablero)
     Movimiento_Vacio = 0 //se posiciona en OTRA casilla vacía, no pasa nada más.
     // Al comer se podría prescindir de qué figura come (y en todos estos casos devolver simplemente 1) aunque resulta más interesante así...
     // Estos valores deberían coincidir con los valores asignados a las figuras (en otra enumeración, para el tablero)
     Movimiento_Come1 = 1  // come a un peón
     Movimiento_Come2 = 2  //come a una torre
     Movimiento_Come3 = 3  //come a un caballo
     Movimiento_Come4 = 4  //come a un alfil
     Movimiento_Come5 = 5  // Come a la reina.
     Movimiento_Come6 = 6  //  Mata al rey, fin de partida (el rey no tiene movimientos)
fin enumeracion

Y ahora que queda claramente definida lo que tiene que hace rla función su pseudocódigo resultante:
- Posibles es el byte que se devolvió en la función anterior, y bitposición la elección de movimiento del jugador.
- 'x' e 'y' son las cordenadas actuales y a la devolución contendrán las cordenadas de destino del caballo (solo si fue posible moverse).
Código:
PosibilidadesDeMovimiento = funcion PosicionarCaballoSobre(byte x, byte y, byte Posibles, byte BitPosicion, array sByte Tablero() )
    sbyte dx, dy
    PosibilidadesDeMovimiento n

    Si ((2^BitPosicion) and posibles) luego  // ¿realmente ese bit está a uno (casilla aceptable donde mover el caballo) ?
        Seleccionar BitPosicion
            caso 0
                dx = x-1
                dy = y-2          
            caso 1
                dx = x+1
                dy = y-2
            caso 2
                ...  // a rellenar por ti...
            caso 3
                ...
            caso 4
                ...
            caso 5
                ...
            caso 6
                ...
            caso 7
                ...
        Fin seleccionar
  
        // no hace falta comprobar dx y dy dentro del tablero, ya que eso se comprobó en la función anterior y se garantiza al inicio de esta función...
        n = Tablero(dx, dy)
        Si (n>0) luego
            x = dx
            y = dy
            devolver n
        Osi (n=0)
            devolver n
        fin si
    Fin si

    devolver -1
fin funcion


Luego el código de las llamadas sería algo como:
Código:
array sByte tablero(0 a 7, 0 a 7)  //el array del estado del tablero está definidio a nivel del módulo/clase

Funcion JugarCaballo(byte x, byte y)  //x, y son las cordenadas actuales del caballo.
    sByte n, p
    posibilidadesDeMovimiento j
    byte dx, dy

    n = PosicionesValidas(x, y, tablero() )
    Si (n> 0) luego //hay posiciones válidas para el caballo desde donde está actualmente
        dx= x
        dy = y
        Hacer
            mensajeAlJugador ""Elige una de los 8 posibles movimeintos del caballo (un valor en el rango: (0/7)" con imagen adjunta de las psoiciones que son 0-7)
            p = JugadorEligePosicion // para el caballo (en el rango 0-7
            j = PosicionarCaballoSobre(x, y, n, p, tablero() )
        Repetir mientras (j<0)

        Si (j>0)
            ComerFichaEnemiga(x, y, j) // allí se ve si la ficha comida es el rey en cuyo caso acaba la partida.
        Fin si
        MoverCaballoA(x, y)

        // Actualizar estado del tablero:
        tablero(dx, dy) = 0 // casilla libre, caballo retirado de ahí.
        tablero(x, y) = -3 // 'nuestro' caballo en dicha posición (hbiera o no una ficha del enemigo en ella).
    fin si
fin funcion
   

Los bits que definen la posición del movimiento serían así:
« Última modificación: 14 Diciembre 2017, 17:41 por NEBIRE » En línea

fefeelcrack

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Re: matriz de movimiento del caballo en c++
« Respuesta #5 en: 25 Abril 2020, 00:05 »

me puedes pasar el codigo completo
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines