Proyecto Ajedrez I.0: Descripción de las reglas

Objetivo del Juego de Ajedrez

El objetivo del ajedrez es dar jaque mate al rey oponente, lo que significa que el rey está en una posición de ataque y no puede escapar.

El Tablero

    El tablero es una cuadrícula de 8x8, con 64 casillas alternadas en colores claros y oscuros.
    Las columnas se denominan de la 'a' a la 'h', y las filas del '1' al '8'.

Colocación de las Piezas

    Fila 1 (de las blancas) y Fila 8 (de las negras): Torre (T), Caballo (C), Alfil (A), Dama (Q), Rey (K), Alfil (A), Caballo (C), Torre (T).
    Filas 2 (blancas) y 7 (negras): Peones (P).
    Las piezas blancas empiezan en las filas 1 y 2, las negras en las filas 7 y 8.

     ┌─────────────────┐
    8┤ t c a q k a c t │
    7┤ p p p p p p p p │
    6┤ . . . . . . . . │
    5┤ . . . . . . . . │
    4┤ . . . . . . . . │
    3┤ . . . . . . . . │
    2┤ P P P P P P P P │
    1┤ T C A Q K A C T │
     └─┬─┬─┬─┬─┬─┬─┬─┬─┘
       A B C D E F G H


Movimientos de las Piezas

    Peón (P)
        Movimiento: Avanza una casilla hacia adelante. En su primer movimiento, puede avanzar dos casillas.
        Captura: Una casilla en diagonal hacia adelante.
        Captura al paso: Un peón que avanza dos casillas desde su posición inicial puede ser capturado "al paso" por un peón enemigo como si solo hubiera avanzado una casilla. Esto solo es posible inmediatamente después del movimiento del peón.

    Torre (T)
        Movimiento: Vertical y horizontalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Caballo (C)
        Movimiento: Forma de 'L' (dos casillas en una dirección y una en perpendicular). Puede saltar sobre otras piezas.
        Captura: Igual que el movimiento.

    Alfil (A)
        Movimiento: Diagonalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Dama (Q)
        Movimiento: Vertical, horizontal y diagonalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Rey (K)
        Movimiento: Una casilla en cualquier dirección.
        Captura: Igual que el movimiento.
        Enroque: Movimiento especial en colaboración con una torre (ver detalles abajo).

Movimientos Especiales

    Enroque:
        Condiciones:
            El rey y la torre implicada no deben haberse movido previamente.
            No debe haber piezas entre el rey y la torre.
            El rey no puede estar en jaque, pasar por casillas bajo ataque, ni terminar en jaque.
        Movimiento:
            Enroque corto: Rey mueve dos casillas hacia la torre del lado rey, y la torre se coloca a su lado.
            Enroque largo: Rey mueve dos casillas hacia la torre del lado dama, y la torre se coloca a su lado.

    Captura al paso: Un peón que avanza dos casillas desde su posición inicial puede ser capturado al paso por un peón enemigo en la columna adyacente que se encuentra en la quinta fila (blancas) o cuarta fila (negras).

    Promoción de Peón: Cuando un peón alcanza la octava fila, debe ser promovido a una dama, torre, alfil o caballo, a elección del jugador.

Reglas de Jaque y Jaque Mate

    Jaque: El rey está bajo ataque. El jugador debe mover el rey, capturar la pieza atacante o interponer otra pieza para bloquear el ataque.
    Jaque Mate: El rey está bajo ataque y no puede escapar. El juego termina y el jugador que dio el jaque mate gana.

Otras Reglas

    Tablas: El juego puede terminar en empate por varias razones, como repetición de jugadas, rey ahogado (rey no está en jaque pero no tiene movimientos legales), acuerdo mutuo, o si 50 movimientos han pasado sin captura ni movimiento de peón.

 

Gráfica de un mapa de calor a partir de una matriz.

Este programa crea una ventana que muestra un mapa de calor basado en los valores de la matriz proporcionada. Los valores más bajos se representan en negro y los valores más altos en blanco, con una escala de grises entre ellos.

Matriz de distancias:

    0  185  905  911  236  173  549   85  506  972  911  681
  185    0  421  824  270  350   79  275  666  831  259  251
  905  421    0  286  136  338  764  249  881  508  902  798
  911  824  286    0  924  282  815   40  242  571  448  886
  236  270  136  924    0   88  521  140  345  799  544  295
  173  350  338  282   88    0  584  254   61   76  931  870
  549   79  764  815  521  584    0  353  795  547  213  198
   85  275  249   40  140  254  353    0  181  682  427  539
  506  666  881  242  345   61  795  181    0  618  775  521
  972  831  508  571  799   76  547  682  618    0  734  462
  911  259  902  448  544  931  213  427  775  734    0  162
  681  251  798  886  295  870  198  539  521  462  162    0


Código Java (HeatMap.java):

import javax.swing.*;
import java.awt.*;

public class HeatMap extends JPanel {
    private final int[][] data;
    private final int maxValue;
    private final int minValue;

    public HeatMap(int[][] data) {
        this.data = data;
        this.maxValue = findMaxValue(data);
        this.minValue = findMinValue(data);
    }

    private int findMaxValue(int[][] data) {
        int max = Integer.MIN_VALUE;
        for (int[] row : data) {
            for (int value : row) {
                if (value > max) {
                    max = value;
                }
            }
        }
        return max;
    }

    private int findMinValue(int[][] data) {
        int min = Integer.MAX_VALUE;
        for (int[] row : data) {
            for (int value : row) {
                if (value < min) {
                    min = value;
                }
            }
        }
        return min;
    }

    private Color getColor(int value) {
        float normalizedValue = (float)(value - minValue) / (maxValue - minValue);
        int gray = (int)(normalizedValue * 255);
        return new Color(gray, gray, gray);
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        int cellWidth = getWidth() / data[0].length;
        int cellHeight = getHeight() / data.length;
        for (int row = 0; row < data.length; row++) {
            for (int col = 0; col < data[row].length; col++) {
                g.setColor(getColor(data[row][col]));
                g.fillRect(col * cellWidth, row * cellHeight, cellWidth, cellHeight);
            }
        }
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(600, 600);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Heat Map");
        int[][] data = {
            {0, 185, 905, 911, 236, 173, 549, 85, 506, 972, 911, 681},
            {185, 0, 421, 824, 270, 350, 79, 275, 666, 831, 259, 251},
            {905, 421, 0, 286, 136, 338, 764, 249, 881, 508, 902, 798},
            {911, 824, 286, 0, 924, 282, 815, 40, 242, 571, 448, 886},
            {236, 270, 136, 924, 0, 88, 521, 140, 345, 799, 544, 295},
            {173, 350, 338, 282, 88, 0, 584, 254, 61, 76, 931, 870},
            {549, 79, 764, 815, 521, 584, 0, 353, 795, 547, 213, 198},
            {85, 275, 249, 40, 140, 254, 353, 0, 181, 682, 427, 539},
            {506, 666, 881, 242, 345, 61, 795, 181, 0, 618, 775, 521},
            {972, 831, 508, 571, 799, 76, 547, 682, 618, 0, 734, 462},
            {911, 259, 902, 448, 544, 931, 213, 427, 775, 734, 0, 162},
            {681, 251, 798, 886, 295, 870, 198, 539, 521, 462, 162, 0}
        };

        HeatMap heatMap = new HeatMap(data);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(heatMap);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

Resultado:

Cálculo de la distancia entre dos puntos en un espacio de 6 dimensiones.

La distancia euclidiana es una medida de la longitud del segmento de línea recta que conecta dos puntos en un espacio n-dimensional.
En este caso, los dos puntos están representados por los vectores a1​ y b1​. Como es un espacio en 6D cada vector constará de 6 coordenadas cartesianas.

Código Java (CalculoDistanciaEuclideana.java):

package calculodistanciaeuclideana;

public class CalculoDistanciaEuclideana {

    public static void main(String[] args) {
        // Representación de dos puntos (a1, b1) en un espacio de 6 dimensiones (en coordenadas cartesianas)
        double[] a1 = {88, 74, 33, 29, 47, 58};
        double[] b1 = {29, 56, 13, 68, 11, 87};
        double distance = calculodistanciaeuclideana(a1, b1);
        System.out.println("La distancia entre a1 y b1 es: " + distance);
    }

    public static double calculodistanciaeuclideana(double[] a1, double[] b1) {        
        double sum = 0.0;
        for (int i = 0; i < a1.length; i++) {
            sum += Math.pow(b1[i] - a1[i], 2);
        }
        return Math.sqrt(sum);
    }
}

 

Resultado: 

run:
La distancia entre a1 y b1 es: 88.67355862939075
BUILD SUCCESSFUL (total time: 0 seconds)