Juego de ajedrez en Visual C++

Moviendo cada pieza de ajedrez

Ahora veremos en detalle como podemos controlar la movida de cada pieza de ajedrez.

Movida del peón

Es la movida que parece simple de implementar, pero presenta situaciones especiales.

1. Obtenemos la diferencia entre las coordenadas de origen y destino.
2. Si es una movida vertical
   • Si se ha movido un casillero
     • Si la dirección de la movida corresponde al turno, entonces es posible realizar la movida
   • Si se ha movido dos casilleros
     • Si la dirección de la movida corresponde al turno y la pieza del peon aun no se ha movido, entonces es posible realizar la movida
       • Si hay vía libre para realizar la movida, entonces es posible realizar la movida.
3. Si es un movimiento diagonal y si la orientación de la movida es correcta con el turno y si la celda de destino no esta vacía y si la celda de destino corresponde a una pieza del oponente.
   • Se puede realizar la movida.

Código fuente de la función MoverPeonHacia

bool CAjedrezView::MoverPeonHacia(int x, int y)
{
    int dify = y - m_celdaSel.y;
    int difx = x - m_celdaSel.x;
 
    bool bMovidaPosible = false;
 
    if(difx == 0) //Movida Vertical
    {        
        if(abs(dify) == 1)//Si mueve un casillero
        {
            if(dify == (EsPiezaBlanca(m_celdaSel.x ,m_celdaSel.y)?-1:1))
            {
                bMovidaPosible = true;
            }
        }
        else if(abs(dify) == 2) //Movida larga de peon
        {
            if(m_celdaSel.y == (EsPiezaBlanca(m_celdaSel.x ,m_celdaSel.y)?6:1))
            {
                if(EsViaLibre(x,y))
                    bMovidaPosible = true;
            }
        }
    }
    else if((abs(difx) == 1) // Si esta intentando comer
        && (dify == (EsPiezaBlanca(m_celdaSel.x ,m_celdaSel.y)?-1:1))
        && !EsCeldaNula(x,y)
        && (m_pCeldas[m_celdaSel.y ][m_celdaSel.x] != m_pCeldas[y][x]))
    {
        bMovidaPosible = true;
    }

    return bMovidaPosible;
}

Movida del alfil

El alfil es una pieza que se mueve diagonalmente, entonces basta con verificar si hay vía libre entre las posiciones.

1. Obtenemos la diferencia entre las coordenadas de origen y destino.
2. Si la diferencia de ambas coordenadas son iguales entonces es un movimiento diagonal.
   • Si hay vía libre y la celda de destino esta vacía o corresponde al enemigo
     • Devolver true, indicando que se puede realizar la movida.
3. Sino, devolver falso.

Código fuente de la función

bool CAjedrezView::MoverAlfilHacia(int x, int y)
{
    int dify = y - m_celdaSel.y;
    int difx = x - m_celdaSel.x;
 
    if(abs(difx) == abs(dify))
    {
        if(EsViaLibre(x,y) && m_pCeldas[m_celdaSel.y ][m_celdaSel.x] != m_pCeldas[y][x])
        {            
            return true;
        }
    }
    return false;
}

Movida de la torre

La movida de la torre es similar a la del alfil con la diferencia que una de las dos diferencias debe ser cero.

bool CAjedrezView::MoverTorreHacia(int x, int y)
{
    int dify = y - m_celdaSel.y;
    int difx = x - m_celdaSel.x;
 
    if((difx == 0) || (dify == 0) )
    {
        if(EsViaLibre(x,y) && m_pCeldas[m_celdaSel.y ][m_celdaSel.x] != m_pCeldas[y][x])
        {            
            return true;
        }
    }
    return false;
}

Movida de la reina

Es mas fácil de lo que parece:

bool CAjedrezView::MoverReinaHacia(int x, int y)
{
    return MoverAlfilHacia(x,y) || MoverTorreHacia(x,y);
}

Movida del rey

En esta movida solo hay que verificar que se haya movido un casillero y que la celda de destino sea la del oponente.

bool CAjedrezView::MoverReyHacia(int x, int y)
{
    int dify = y - m_celdaSel.y;
    int difx = x - m_celdaSel.x;
 
    if((abs(difx) == 1) && (abs(dify) == 1) )
    {        
        if(m_pCeldas[m_celdaSel.y ][m_celdaSel.x] != m_pCeldas[y][x])
        {
            return true;
        }
    }
    return false;
}

Movida del caballo

Esta movida no se parece a ninguna de las anteriores, es por eso que necesita explicación.

1. Obtenemos la diferencia entre las coordenadas de origen y destino.
2. Si la diferencia entre las coordenadas debe ser 2 y 1 para cada caso
   • Si la celda de destino es del oponente o esta en blanco
     • Devolver true indicando que se puede realizar la movida
3. Sino, retornar false.

bool CAjedrezView::MoverCaballoHacia(int x, int y)
{
    int dify = y - m_celdaSel.y;
    int difx = x - m_celdaSel.x;
 
    if(((abs(difx) == 2) && (abs(dify) == 1))||((abs(difx) == 1) && (abs(dify) == 2)))
    {
        if(m_pCeldas[m_celdaSel.y ][m_celdaSel.x] != m_pCeldas[y][x])
        {
            return true;
        }
    }
    return false;
}

Es todo!

Ya pueden compilar y ejecutar, sientanse libre de escribir sus comentarios, tampoco se olviden de votar por el articulo.