INGENIERÍA EN SISTEMAS

COMPUTACIONALES

“AJEDREZ”
EN PHYTON
PROYECTO INTEGRADOR

❖ PRESENTA:
❖ MARTINEZ SEGURA JOSE
❖ DE LA CRUZ VILLA JOCELYN
❖ OSORNO HERNÁNDEZ FERNANDO ALEJANDRO
❖ VILLALÓN JAIMES BRYAN JOSUÉ
❖ HERNANDEZ CLETO ABIGAIL
❖ GONZALEZ CAMPUZANO EMMANUEL
 Índice
INTRODUCCIÓN ................................................................................................................................... 3
PLANTEAMIENTO ................................................................................................................................ 4
OBJETIVOS ........................................................................................................................................... 6
Objetivos Específicos: ...................................................................................................................... 6
ALCANCE.............................................................................................................................................. 7
Alcance de un Programa de Ajedrez en Python .............................................................................. 8
JUSTIFICACIÓN .................................................................................................................................... 9
Beneficios educativos ...................................................................................................................... 9
Beneficios técnicos .......................................................................................................................... 9
Marco Teórico ................................................................................................................................... 10
Marco Metodológico ......................................................................................................................... 11
Configuración PY ........................................................................................................................... 11
Canvas ........................................................................................................................................... 12
Denominación de piezas de ajedrez ............................................................................................. 13
Convención para nombrar ubicaciones en el tablero de ajedrez ................................................. 13
Definición de reglas para las piezas de ajedrez............................................................................. 23
Reglas para un caballo................................................................................................................... 27
La validación del movimiento de piezas de ajedrez ...................................................................... 33
CRONOGRAMA .................................................................................................................................. 33
REESULTADO ..................................................................................................................................... 35
CONCLUSIONES ................................................................................................................................. 38
ANEXOS…………………………………………………………………………………………………………..……………………………40

2
 INTRODUCCIÓN.

Ajedrez Virtual: Un Desafío Intelectual en la Era Digital

El ajedrez, juego milenario de estrategia y habilidad, fascina a jugadores de todas las

edades. Su complejidad y carácter tanto arte como ciencia lo convierten en un desafío único.
En la actualidad, con la tecnología en auge, surge la oportunidad de crear una experiencia
virtual. Este proyecto busca desarrollar un juego de ajedrez virtual que refleje la esencia del
tradicional, pero con innovaciones que enriquezcan la experiencia de juego y fomenten el
aprendizaje. Integrará un motor de juego eficiente y una interfaz interactiva para usuarios de
todas las edades y niveles. Además, ofrecerá elementos educativos y sociales, como tutoriales
y torneos en línea, promoviendo el ajedrez como herramienta para el desarrollo intelectual y
social en la era digital.

3
 PLANTEAMIENTO.

El ajedrez es un juego de mesa complejo que requiere una planificación estratégica y

un pensamiento crítico. La programación en Python ofrece una herramienta poderosa para
crear un proyecto integrador que simule el juego de ajedrez

El objetivo del programa es simular una partida de ajedrez completa entre dos jugadores. El
programa debe ser capaz de:

● Representar el tablero de ajedrez: El programa debe crear una estructura de datos

que represente el tablero de ajedrez, incluyendo la posición de las piezas y el turno
actual.
● Realizar movimientos: El programa debe permitir a los jugadores realizar
movimientos válidos de acuerdo a las reglas del ajedrez.
● Comprobar las reglas: El programa debe verificar que los movimientos realizados
sean válidos de acuerdo a las reglas del ajedrez.
● Gestionar la partida: El programa debe gestionar el turno de juego, la captura de
piezas y la promoción de peones.

Las principales características para poder realizar el ajedrez en Python es entender las
abreviaturas MVC.

MVC: Model, View, Controller es el patrón de diseño más utilizado. A los desarrolladores
les resulta fácil implementar este patrón de diseño.

MODEL: En nuestra arquitectura MVC es aquella que se encarga de trabajar con los datos;
por lo que normalmente dentro del modelo encontraremos la lógica de aplicación, que
interactúa con la base de datos. Incluye toda la información para representar los datos al
usuario final.

VIEW: La vista representa los archivos HTML, que interactúan con el usuario
final. Representa los datos del modelo para el usuario.

4
CONTROLLER: contiene el código fuente necesario para responder a las acciones que el
usuario solicita y servir como puente de interacción entre las vistas y el modelo de datos.

Funcionalidades del Programa:

Entrada:

• Posición Inicial de las Piezas: El software permitirá al usuario optar entre leer la
posición inicial de las piezas desde un archivo o ingresarla manualmente.
• Movimientos de los Jugadores: Los jugadores podrán introducir sus movimientos
haciendo clic en el tablero para desplazar las piezas según las reglas del juego.

Salida:

• Representación del Tablero: Después de cada movimiento, el programa mostrará

en pantalla el estado actualizado del tablero, reflejando los cambios realizados.
• Resultado de la Partida: Al concluir cada movimiento, el programa exhibirá las
piezas restantes en el tablero, brindando una visión clara del progreso de la
partida.

5
 OBJETIVOS.

Desarrollo de un Software en lenguaje Python para Simular un Juego Completo de

Ajedrez

Objetivos Específicos:

1. Implementación del Tablero:

• Crear una representación del tablero de ajedrez mediante una matriz de 8x8.
• Desarrollar las reglas de movimiento para cada pieza: peón, torre, alfil, caballo,
dama y rey.
• Facilitar la captura de piezas durante el juego.
• Visualizar el estado del tablero en la pantalla mediante una interfaz de usuario
intuitiva y amigable.

2. Lógica del Juego:

• Establecer un sistema de turnos entre dos jugadores (modo humano vs humano).

• Gestionar la entrada de movimientos por parte de los jugadores.
• Validar la legalidad de los movimientos de acuerdo con las reglas establecidas en
el ajedrez.
• Proporcionar una experiencia de jugabilidad uno a uno, asegurando la fluidez y la
precisión en cada movimiento.

6
 ALCANCE.

Alcance de un Programa de Ajedrez en Python.

El desarrollo de un programa de ajedrez en Python puede abarcar una amplia gama
de niveles, desde una aplicación básica para principiantes hasta un sofisticado motor capaz
de desafiar a jugadores expertos. A continuación, se presentan ejemplos de diferentes niveles
de alcance que pueden lograrse con dicho programa:

Nivel Principiante:

• Un programa que facilita partidas entre dos jugadores en un tablero de ajedrez

elemental.
• Una aplicación que brinda asistencia con las reglas del juego y sugiere
movimientos durante la partida.
• Una implementación que permite a los jugadores enfrentarse a un oponente
controlado por la computadora, adaptado para principiantes.

Nivel Intermedio:

• Un programa con una interfaz gráfica de usuario (GUI) que muestra de forma
visual el tablero y las piezas.
• Herramientas de análisis de jugadas y sugerencias de movimientos más
avanzadas para mejorar las habilidades de los jugadores.
• La posibilidad de desafiar a un oponente controlado por la computadora con
un nivel de habilidad intermedio.

Nivel Avanzado:

• Un motor de ajedrez completo que puede competir con jugadores

experimentados y ofrecer partidas desafiantes.
• Utilización de algoritmos de búsqueda avanzados para evaluar las posiciones
del tablero y tomar decisiones estratégicas.
• Un programa que incorpora capacidades de aprendizaje automático para
analizar errores previos y mejorar su rendimiento con el tiempo.

7
 JUSTIFICACIÓN.

El ajedrez es un juego milenario que despierta interés y pasión en personas de todas

las edades y culturas. Su complejidad estratégica y su capacidad para fomentar habilidades
cognitivas lo convierten en una herramienta educativa invaluable. La implementación de un
programa de ajedrez en Python ofrece numerosos beneficios, tanto educativos como
recreativos.

Beneficios educativos

Desarrollar un juego de ajedrez en Python ofrece una serie de beneficios educativos:

● Fomenta el pensamiento lógico y la capacidad de resolución de problemas. Los

jugadores deben analizar el tablero, evaluar diferentes opciones y tomar decisiones
estratégicas.
● Mejora la capacidad de concentración y la atención al detalle. Es fundamental
prestar atención a los movimientos del oponente y anticipar sus posibles jugadas.
● Desarrolla la paciencia y la disciplina. El ajedrez no es un juego de azar, sino que
requiere tiempo, esfuerzo y dedicación para mejorar.
● Promueve la deportividad y el respeto por el oponente. Es importante aprender a
ganar y perder con dignidad.

Beneficios técnicos

● Profundiza en la comprensión de la programación orientada a objetos. El ajedrez

es un problema complejo que se puede modelar de manera efectiva utilizando objetos
y clases.
● Desarrolla habilidades de diseño de interfaces de usuario. El juego debe ser
visualmente atractivo y fácil de usar.
● Permite la experimentación con diferentes algoritmos de búsqueda. Se pueden
implementar diferentes estrategias para que la jugabilidad sea usuario contra usuario.

8
 Marco Teórico.

El ajedrez es un juego de estrategia para dos jugadores que se disputa sobre un tablero
cuadriculado de 64 casillas (8x8). Cada jugador comienza con 16 piezas: un rey, una reina,
dos torres, dos caballos, dos alfiles y ocho peones. El objetivo del juego es dar jaque mate al
rey del oponente, lo que significa que el rey está bajo amenaza y no puede escapar.

1-Tablero de ajedrez

a) Representación del tablero: Puedes utilizar una matriz bidimensional para representar
el tablero, donde cada celda contiene información sobre la pieza que está en esa
posición (si hay alguna) o si está vacía.
b) Coordenadas: Puedes usar una notación de coordenadas algebraicas como "a1", "b2",
etc., o simplemente coordenadas numéricas (fila, columna).
c) Tamaño del tablero: El estándar es un tablero de 8x8, pero también puedes considerar
tableros de diferentes tamaños para variantes del juego.

2-Piezas:

● Cada pieza debe tener su propio comportamiento y reglas de movimiento.

● Puedes representar cada tipo de pieza (peón, torre, caballo, etc.) con una clase o
estructura de datos. Cada pieza debe tener información sobre su posición actual
en el tablero y posibles movimientos válidos.
● Considera cómo manejar el movimiento especial de algunas piezas como el
enroque, el peón al paso o la promoción del peón.

3-Reglas del Juego:

● Implementa las reglas del juego para determinar qué movimientos son legales en
una posición dada.
● Esto incluye reglas como el jaque, el jaque mate y el empate por ahogado.

4-Interfaz de Usuario:

● Puedes implementar una interfaz de línea de comandos (CLI) o una interfaz gráfica
de usuario (GUI) para que los jugadores interactúen con el juego.

9
 ● Para una interfaz gráfica, puedes usar bibliotecas como Tkinter, Pygame o Model,
View, Controller.

5-Lógica del Juego:

● La lógica del juego manejará la interacción entre el tablero, las piezas y las reglas
del juego.
● Debe ser capaz de validar movimientos, detectar jaque mate, mantener un registro
de movimientos y manejar el flujo del juego.
● Jugabilidad uno a uno

6-Pruebas y Depuración:

Asegúrate de probar exhaustivamente tu código para detectar y corregir errores.

Las pruebas unitarias y las pruebas de integración son útiles para garantizar el buen
funcionamiento del juego en diferentes situaciones.

Implementar el ajedrez en Python es una tarea desafiante pero gratificante que puede ayudarte
a desarrollar tus habilidades de programación y lógica. Las bibliotecas y herramientas
disponibles en Python facilitan el proceso, pero es importante comprender las reglas del juego
y los conceptos básicos de la programación para crear una implementación completa y
funcional.

10
 Marco Metodológico.

El ajedrez es un juego de estrategia complejo que ha fascinado a las mentes humanas

durante siglos. Implementar un programa de ajedrez en Python puede ser una tarea desafiante
pero gratificante, ya que implica aplicar conceptos de programación orientados a objetos,
algoritmos de búsqueda y técnicas de evaluación de posiciones.

Definición del Problema.

El objetivo de este proyecto es desarrollar un programa de ajedrez en Python que pueda:

● Representar el tablero de ajedrez y las piezas.

● Permitir al usuario jugar contra otro jugador humano.
● Implementar las reglas del ajedrez, incluyendo movimiento de piezas.
● Evaluar la posición actual del tablero y realizar jugadas estratégicas.
● Ofrecer una interfaz de usuario amigable para la interacción con el programa.

Configuración PY.
Se genero una carpeta para que los valores constantes que estén disponibles para todos
los archivos y también los importamos en las carpetas model.py, controller.py y view.py.
También se creó una carpeta llamada excepción para manejo de errores y excepciones.

Según los principios de la arquitectura MVC la clase view interactúa con la clase model y
controller y estás siempre permanecerán ligadas en consecuencia importamos el controlador
en la clase view y el model en la clase controller.

11
Canvas.
Es un área rectangular destinada a hacer dibujos u otros diseños complejos. Puedes
colocar gráficos, texto, widgets o marcos en un lienzo.

Para poder mostrar nuestro tablero en la pantalla utilizamos canvas que sirve para poder
mostrar una imagen en pantalla en el cual van declaradas el tamaño del tablero del numero
de columnas y filas.

12
Denominación de piezas de ajedrez.
Cada pieza de ajedrez está identificada por una sola letra (peón = p, caballo = n, alfil
= b, torre = r, reina = q y rey = k).
P=pawn.
N=knight.
B=bishop.
R =rook.
Q= Queen.
K=King.
Las piezas de ajedrez blancas están representadas por letras mayúsculas (P, N, B, R, Q, K),
y las piezas de ajedrez negras están representadas por letras minúsculas (p, n, b, r, q, k).

Convención para nombrar ubicaciones en el tablero de ajedrez

Para asignar identificadores únicos a cada casilla del tablero de ajedrez, usaremos marca los
cuadrados a lo largo del eje x usando las letras de la A a la H. Marcaremos la y eje utilizando
los números del 1 al 8 respectivamente.

En consecuencia, las casillas del tablero de ajedrez se identificarán de la siguiente manera

13
Por tanto, A1 denota la casilla situada más a la izquierda en la parte inferior del tablero de
ajedrez. Actualmente, está ocupada por una torre blanca. La posición C3 está actualmente
vacía, E8 tiene un rey negro, y A8 tiene una torre negra.

Agreguemos esto al archivo configuraciones.py.

Ahora, si quieres representar el tablero de ajedrez en cualquier momento, todo lo que

necesitas es un mapeo de la ubicación a la pieza de ajedrez en esa ubicación. Por lo tanto, la
posición inicial de todas las piezas de ajedrez en el tablero se puede representar enviado de
la siguiente manera:

14
Necesitamos estos datos para comenzar. Entonces, agreguemos esto como una constante a la
configurations.py.
Ahora, pasemos a codificar la clase Modelo para nuestro programa. Ya hemos decidido que
usaremos un diccionario Python para almacenar la posición de las piezas de ajedrez en el
tablero de ajedrez. Podemos seguir adelante y agregar un atributo de diccionario a la clase.
Hagamos de Model una clase secundaria de la clase de diccionario incorporada, de la
siguiente manera:

Por lo tanto, la variable self que hace referencia a la instancia del objeto de clase actual
también tendrá todas las propiedades y métodos que están disponibles para el diccionario.
todos los métodos que están disponibles para la clase de diccionario estándar ahora se pueden
llamar en el Modelo.
Ahora podemos definir un método que devuelva el nombre corto de la pieza de ajedrez en
esa posición cuando se le da una posición en el tablero de ajedrez, de la siguiente manera (en
model):

Si no hay ninguna pieza de ajedrez en la posición, esto atrapa en lugar de dar un KeyError
excepción.
A continuación, agreguemos algunos atributos más importantes a la clase Modelo, de la
siguiente manera: (ver model.py).

15
El reloj de medio movimiento mantiene un registro del número de turnos jugados desde el
último avance del peón o la última captura. Esto se utiliza para determinar si un empate puede
ser reclamado bajo la regla de los cincuenta movimientos.
El número de movimiento completo es un conteo que se incrementa en 1 después de cada
movimiento de una pieza negra. Esto se utiliza para realizar un seguimiento de la duración
total de un juego.
Finalmente agreguemos otro método que, dada la tupla fila-columna para un cuadrado,
cambia su posición alfanumérica (por ejemplo, una entrada de (1,2) devuelve B3):

A continuación, definamos un método auxiliar asociado para garantizar que solo procesemos
clics del mouse que ocurren en el widget Canvas y no en ningún otro lugar de la raíz ventana,
de la siguiente manera:

No hay mucho que se pueda agregar a la clase Modelo por ahora hasta que establezcamos
la lógica del código para manejar las piezas de ajedrez.
Podemos definir las reglas para todas las piezas de ajedrez dentro de la clase Modelo, pero
eso haría que la clase Model fuera demasiado voluminosa. Por lo tanto, definamos la pieza
de ajedrez.
La lógica relacionada en un nuevo archivo llamado piece.py. Dado que esto es
inherentemente una parte de la Clase de model, pero está definida en un archivo nuevo,
agreguemos una referencia a la clase de modelo dentro de este archivo. (ver pieza.py)
Creando una clase de pieza

16
Necesitamos definir reglas para todas las diferentes piezas de ajedrez. Algunos métodos
como el color serán comunes a todas las piezas de ajedrez, mientras que otros
atributos/métodos, como las reglas de movimiento, variarán para cada ajedrez.

Primero, definiremos una nueva clase Piece. Esta clase tendrá los atributos y métodos, que
son comunes a todas las piezas de ajedrez. Luego, definiremos clases para cada individuo.
La pieza individual como una subclase de esta clase pieza principal. Luego podemos anular
todos los atributos y métodos en estas clases individuales.

El código se verá así (piece.py):

La clase Piece necesita el color como argumento para la creación de objetos. Nosotros
creamos dos atributos llamados self.name y self. Color en la clase.
La definición del método keep_reference (self, model). Desde la clase Piece no es más que
una extensión de la clase Modelo, necesitamos obtener una referencia a la Clase modelo en
este método para comunicarse con él.
De manera similar, la clase Modelo necesita una referencia a la nueva clase Pieza. En
consecuencia, agregue esto como una importación a la clase Modelo, de la siguiente manera
(consulte el código model.py):

17
Finalmente, necesitamos un método que tome una cadena perteneciente al nombre de un
determinado objeto pieza y crea un nuevo objeto pieza. Por ejemplo, necesitamos un método
que,
dados los argumentos (Peón, negro) o simplemente ("p"), crea dinámicamente un nuevo Peón
objeto con el atributo de color definido como negro.

En consecuencia, definamos un método auxiliar en el archivo piece.py pero fuera de Piece.

clase, de la siguiente manera (ver piece.py):

Para admitir el método anterior, agregue la siguiente constante a la configuración:

configurations.py

El código anterior simplemente toma un solo carácter como entrada. Luego obtiene completo
el nombre para la clase de pieza correspondiente (por ejemplo, si se da una p, obtiene el valor
completo nombre, que es Peón).

18
Luego verifica el caso del personaje y define la variable de color como blanco si el carácter
de entrada está en mayúsculas. De lo contrario, el color es establecido en negro. Luego crea
dinámicamente un objeto pieza correspondiente.
Esto concluye la iteración. Hemos creado la clase Piece y todas sus subcategorías. Tenemos
la capacidad de crear objetos, pieza dinámicamente a partir de un determinado carácter de
entrada. Esta clase es simplemente una extensión de la clase Modelo, y cada una de las dos
clases pueden acceder a los métodos de cada una manteniendo una referencia a cada uno.

La siguiente es una descripción del código anterior:

•Las imágenes de las piezas de ajedrez se almacenan en una carpeta llamada piezas imagen
y se nombran en el nombre de la pieza de ajedrez en formato minúscula + _ + color.png.
Entonces, por ejemplo, la reina negra se guarda con el nombre queen_black.png.
•Las imágenes se agregan al tablero de ajedrez usando canvas.create_image() método, que
toma las coordenadas (x , y) un objeto PhotoImage() que se basa en la ubicación del archivo
de imagen como argumento.
•Utilizamos la clase PhotoImage de Tkinter para hacer referencia a los archivos .png.
•Además de crear y exhibir una pieza de ajedrez en el tablero, también los etiqueta con una
etiqueta personalizada llamada ocupado. El etiquetado es importante característica del widget
Canvas, que nos permite identificar de forma única los elementos colocados en el widget de
lienzo.
También utilizamos los siguientes dos métodos auxiliares en el código anterior: (ver view.py)

19
Ahora es el momento de simplemente llamar al método draw_single_piece anterior para
todos los
piezas de ajedrez: (view.py)

Un aspecto clave que debe tener en cuenta aquí es que cuando necesitábamos algunos datos
del Clase modelo, digamos, un diccionario que contiene todas las piezas de ajedrez en el
tablero, no llamó directamente a la clase Modelo para los datos. En lugar de ello, solicitamos
la controller para conseguirnos los datos del modelo. El método
get_all_pieces_on_chess_board()
El método del controlador es simplemente un contenedor alrededor del método real de la
clase Modelo. (ver controller.py):

20
Ahora tenemos los métodos necesarios para dibujar todas las piezas de ajedrez en el tablero
de ajedrez. Pero la mera definición no ayuda. Estos métodos deben llamarse desde algún
lugar. Por lo tanto, definamos un nuevo método llamado start_new_game() y llámelo desde
el método __init__ de la clase View, de la siguiente manera.

Además de llamar al método draw_all Pieces(), este método también restablece el Modele
mediante llamadas a dos métodos de controlador contenedor (ver – controller.py):

Los métodos reales se definen en la clase Modelo de la siguiente manera:

El método reset_game_data() es simple. Simplemente restablece todos los atributos del Clase
modelo a sus estados iniciales.

El método reset_to_initial_locations() inicializa todas las ubicaciones de las piezas de ajedrez

para reflejar la posición inicial del juego. Esto también debería explicarse por sí solo si son
conscientes de la estructura de datos que discutimos anteriormente.

21
Ahora, cuando continúas y ejecutas el código (ver – view.py), el ajedrez-
El tablero debe mostrar todas las piezas de ajedrez en la posición inicial del juego, como
se muestra en la siguiente captura de pantalla:

22
Definición de reglas para las piezas de ajedrez.
Diferentes piezas de ajedrez tienen diferentes reglas de movimiento. Intentemos
tabular la
normas:

Como se desprende de la tabla, las reglas para todas las piezas de ajedrez, excepto el caballo
y los peones son bastante sencillos.

El movimiento del caballo es diferente a los demás. Deben mover dos casillas en una
dirección, y luego un movimiento más en un ángulo de 90 grados, siguiendo la forma de L.
Los caballos son también las únicas piezas de ajedrez que pueden saltar sobre otras piezas de
ajedrez.

Reglas para el rey, la reina, la torre y el alfil.

Necesitamos de alguna manera resolver la forma de cambiar la posición mediante el
uso de un método matemático.

23
El siguiente diagrama muestra lo que se necesita para mover una pieza de ajedrez desde su
posición (digamos x, y) tanto ortogonal como diagonalmente:

Si observa el diagrama anterior, x representa el número de columna, y representa el número

de filas. Está claro que podemos representar los movimientos ortogonales, agregando a la
posición actual los elementos de las tuplas (-1,0) (0,1) (1,0) (0,-1).

De manera similar, los movimientos diagonales se pueden representar sumando a las tuplas
(-1,1) (1,1) (1,-1) (-1,-1).
Las tuplas en Python o tuples son muy similares a las listas, pero con dos diferencias.
Son inmutables, lo que significa que no pueden ser modificadas una vez declaradas, y en
vez de inicializarse con corchetes se hace con ().
Dependiendo de lo que queramos hacer, las tuplas pueden ser más rápidas.
Agreguemos estas dos tuplas a configurations.py, de la siguiente manera:

24
Si una pieza de ajedrez puede moverse tanto ortogonal como diagonalmente, como la Reina,
La tupla representativa es simplemente una suma de las dos tuplas anteriores.

Si una pieza de ajedrez se puede mover más de una casilla, es simplemente una cuestión de
multiplicar la tupla representativa por un número entero para obtener todas las demás
posiciones permitidas.
Con esta información en mente, codifiquemos un método de moves_avaibles que, dada la
posición actual de la pieza de ajedrez, la tupla de direcciones relevantes para la pieza de
ajedrez
y la distancia máxima que puede moverse la pieza de ajedrez, devuelve una lista de todas las
tulpas.
Allow_moves, de la siguiente manera (ver – piece.py):

La siguiente es una descripción del código anterior:

•Dependiendo de los argumentos, el método recopila todos los movimientos permitidos para
una pieza de ajedrez dada en una lista llamada moves_avaibles.
•El código registra en iteración todas las ubicaciones para detectar una posible colisión. Si se
detecta una colisión, se sale del bucle. De lo contrario, añade la coordenada a la lista de
moves_avaibles.
•La penúltima línea filtra los movimientos que quedan fuera del tablero de ajedrez, y la última
línea devuelve la posición equivalente en notaciones alfanuméricas para todos los
movimientos permitidos.

25
También podemos definir algunos métodos auxiliares para respaldar el método anterior,
como se muestra a continuación:

A continuación, modifiquemos las clases secundarias de piezas de Rey, Reina, Torre y Alfil
de la siguiente manera: (ver– piece.py):

26
Reglas para un caballo.
El Caballo es una bestia diferente porque no se mueve ni ortogonal ni diagonalmente.
También puede saltar sobre piezas de ajedrez.
Como las reglas que seguimos antes para llegar a ORTHOGONAL_POSITIONS y
DIAGONAL_POSITIONS, podemos llegar de manera similar a las reglas que se requieren
para determine la tupla KNIGHT_POSITIONS. Esto se define en configuraciones.py, de la
siguiente manera:

A continuación, anulemos el método Moves_availables de la clase Knight (ver– piece.py):

Lo siguiente es una descripción del código anterior:

•El método es bastante similar al método de la superclase anterior. Sin embargo, a diferencia
del método de superclase, los cambios se representan para capturar movimientos usando la
tupla KNIGHT_POSITIONS.
•A diferencia de la súper clase, no necesitamos rastrear las colisiones, porque los Caballeros
Puede saltar sobre otras piezas de ajedrez.

27
Reglas para un peón.
Un peón también tiene un movimiento único porque avanza. De manera similar,
anulemos la clase moves_avaibles desde dentro de la clase Peón, de la siguiente manera (ver
– piece.py):

Descripción del código anterior:

•Primero asignamos las variables de initial_position, dirección y enemigo, independiente de
si el peón es blanco o negro.
•Similar a los métodos Moves_allowed anteriores, este método recopila todos los
movimientos permitidos en una lista en blanco llamada moves_avaibles.
• Luego, recopilamos una lista de todos los movimientos prohibidos concatenando dos listas
de casillas ocupadas por todas las piezas de ajedrez blancas y negras.
•Definimos una variable llamada forward que mantiene la posición del cuadrado,
inmediatamente delante de la posición actual del Peón.
•Un peón no puede avanzar si hay una pieza de ajedrez delante de él.
•Un Peón puede avanzar dos lugares desde su posición inicial. Verificamos si la posición
actual es la posición inicial y si es la posición inicial posición, agregamos el doble
movimiento a la lista de moves_avaibles.

28
•Un peón puede capturar sólo las piezas de ajedrez diagonalmente adyacentes que tiene
delante.
Por lo tanto, asignamos un ataque variable para rastrear la posición diagonalmente adyacente.
Si el cuadrado diagonalmente adyacente está ocupado por un enemigo, esa posición califica
para ser agregada a la lista de moves_avaibles.
•Luego, filtramos la lista para eliminar todas las posiciones que pueden quedar fuera del
tablero de ajedrez. La última línea devuelve todos los movimientos permitidos como una lista
de notaciones alfanuméricas correspondientes, como hicimos en todas las definiciones
anteriores.

La validación del movimiento de piezas de ajedrez.

Antes de permitir que las piezas de ajedrez se muevan, debemos tener un registro de
todas las posibles opciones de movimiento en el tablero de ajedrez. En cada movimiento,
también debemos comprobar si es un turno legítimo para un jugador determinado y si el
movimiento propuesto no debe provocar un jaque al rey del jugador actual.
Ahora bien, puede ocurrir un jaque al Rey no sólo por una pieza de ajedrez que fue movida,
pero de cualquier otra pieza de ajedrez en el tablero como consecuencia de dicho movimiento.
Por lo tanto, después de cada movimiento, necesitamos calcular los movimientos posibles
para todas las piezas de ajedrez del oponente.
En consecuencia, necesitaremos dos métodos para hacer lo siguiente:
• Mantener un registro de todos los movimientos disponibles para un jugador
•Comprobar si hay jaque al Rey.

Agreguemos dos nuevos métodos en la clase Modelo (ver – model.py).

Seguimiento de todos los movimientos disponibles

El código necesario para realizar un seguimiento de todos los movimientos disponibles para
un jugador es el siguiente:

29
La descripción del código se enumera a continuación:
•Ya hemos codificado el método move_available en la iteración anterior.
•El método anterior simplemente recorre en iteración cada elemento del diccionario y agrega
el resultado de move_available para cada pieza de ajedrez de un color determinado en una
lista llamada resultado.

Descubrir la posición actual del Rey.

Antes de codificar el método que comprueba si un rey está en jaque, primero debemos
conocer la posición exacta del Rey. Definamos un método para descubrir la posición del Rey,
de la siguiente manera (ver código – model.py):

El código anterior simplemente recorre en iteración todos los elementos del diccionario. Si
un dado position es una instancia de la clase King, simplemente devuelve su posición.

Comprobando si el Rey está en jaque.

Definamos un método para comprobar si el Rey está en jaque por parte del oponente:

30
Descripción del código anterior:
•Primero, obtuvimos la posición actual del Rey y el color del oponente.
•Luego descubrimos todos los movimientos posibles para todas las piezas de ajedrez del
oponente. Si la posición del Rey coincide con cualquier posición de todas las posiciones,
posibles movimientos, el Rey está en jaque y devolvemos Verdadero. De lo contrario,
volvemos FALSO.
Hacer que el juego sea funcional

Ahora que tenemos todas las piezas de ajedrez y las reglas de validación relacionadas con el
tablero, demos, ahora vida a nuestro programa de ajedrez. En esta iteración, haremos nuestro
Juego de ajedrez totalmente funcional.
El objetivo de esta iteración es mover las piezas de ajedrez con un clic de la izquierda. Botón
del ratón. Cuando un jugador hace clic en una pieza de ajedrez, el código primero debe
verificar si es un turno legítimo para esa pieza de ajedrez.
Con el primer clic, se selecciona la pieza de ajedrez que se debe mover y se muestran todas
las demás.
Los movimientos indicados para esa pieza de ajedrez se resaltan en el tablero. El segundo el
clic debe realizarse en el cuadrado de destino. Si el segundo clic se realiza en una casilla de
destino válida, la pieza de ajedrez debe moverse desde la casilla de origen hasta la plaza de
destino.
También necesitamos codificar los eventos de capturar piezas de ajedrez y que el Rey esté
en jaque. Los otros atributos que deben ser rastreados incluyen una lista de las piezas
capturadas del ajedrez, el conteo del reloj de medio movimiento, el conteo de números del
movimiento completo y el historial.
Anteriormente creamos un método ficticio que está vinculado al clic izquierdo evento. El
método por ahora simplemente imprime el valor de la fila y la columna en la consola.
Modifiquemos este método de la siguiente manera (ver código – view.py):

31
Descripción del código:
•La primera parte del código calcula las coordenadas de la pieza de ajedrez en el que hiciste
clic. En base a las coordenadas calculadas, almacena las coordenadas notación de la letra
correspondiente en una variable denominada position_of_click.
•Luego intenta asignar la variable pieza a la instancia de pieza correspondiente. Si no hay
ninguna pieza en el cuadrado en el que se hizo clic, simplemente ignora el clic.
•La segunda parte del método comprueba si este es el segundo clic que estaba destinado a
mover una pieza de ajedrez a una casilla de destino. Si esta es la segunda. Con un segundo
clic, llama al método de desplazamiento, pasando las coordenadas de origen y destino.
•Si el cambio tiene éxito, establece todos los atributos establecidos previamente en su estado
vacío original y llama a los métodos draw_board y draw_pieces para volver a dibujar el
tablero de ajedrez y piezas de ajedrez.
Mientras codificamos la funcionalidad deseada para el método on_square_clicked, llamamos
varios métodos nuevos desde su interior. Necesitamos definir estos nuevos métodos.
Éste es el método central en torno al cual se basan todos los demás. Los métodos
evolucionarán a lo largo de nuestros intentos de hacer que el juego de ajedrez funcione.

32
 CRONOGRAMA.

29 de febrero de 2024 - 10 de marzo de 2024: Fase de Planificación y Diseño.

• Investigación inicial sobre el desarrollo de programas de ajedrez en Python.

• Definición de los requisitos y funcionalidades del programa.
• Diseño de la arquitectura del software y la representación del tablero.

11 de marzo de 2024 - 12 de marzo de 2024: Desarrollo de la Lógica del Juego.

• Implementación del tablero de ajedrez utilizando una matriz de 8x8.

• Desarrollo de las reglas de movimiento para cada pieza: peón, torre, alfil,
caballo, dama y rey.
• Programación de la lógica para permitir la captura de piezas.

13 de marzo de 2024 - 14 de marzo de 2024: Creación de la Interfaz de Usuario

UI).

• Integración de una interfaz gráfica de usuario (GUI) para mostrar el tablero y

las piezas de forma visualmente atractiva.
• Implementación de herramientas de interacción para que los jugadores puedan
mover las piezas mediante clics en el tablero.

15 de marzo de 2024 - 1 de abril de 2024: Implementación de la Lógica de Juego

Avanzada.

• Desarrollo de un sistema de turnos entre dos jugadores (humano vs humano).

• Programación para gestionar la entrada de movimientos por parte de los
jugadores.
• Validación de la legalidad de los movimientos según las reglas del ajedrez.

16 de abril de 2023 - de mayo de 2023: Pruebas y Depuración.

• Realización de pruebas exhaustivas para identificar y corregir posibles

errores y fallos en el programa.
• Optimización del rendimiento y la eficiencia del código.

33
 • Ajustes finales en la jugabilidad y la interfaz de usuario según la
retroalimentación obtenida durante las pruebas.

11 de mayo de 2023 - 25 de mayo de 2023: Lanzamiento y Publicación.

• Preparación del programa para su lanzamiento oficial al público.

• Creación de la documentación y los manuales de usuario necesarios.
• Publicación del programa de ajedrez en Python en plataformas relevantes,
como repositorios de código abierto o tiendas de aplicaciones.

26 de mayo de 2023 - 3 de abril de 2024: Mantenimiento y Actualizaciones

• Recepción de comentarios de los usuarios y corrección de errores reportados.

• Implementación de nuevas funcionalidades y mejoras basadas en la
retroalimentación de los usuarios y las tendencias del mercado.
• Actualizaciones periódicas del programa para garantizar su compatibilidad
con nuevas versiones de Python y otros sistemas operativos.

34
 RESULTADO.
En el mundo digital del ajedrez, cada partida es un emocionante enfrentamiento entre
estrategia y habilidad. Al ejecutar este programa creado en Python, se despliega un tablero
virtual que se convierte en el campo de batalla donde los jugadores compiten por la
supremacía. Veamos cómo podría desarrollarse el resultado de una partida:

La pantalla se ilumina con la representación visual del tablero, cada casilla esperando ser
ocupada por las piezas. Los jugadores, con concentración palpable, hacen clic para mover
sus piezas con destreza y cautela. El flujo del juego avanza con movimientos precisos y
calculados, mientras el programa registra cada acción con precisión milimétrica.

Durante la partida, la tensión crece a medida que los jugadores despliegan sus estrategias.
Los peones avanzan audazmente, las torres dominan las columnas, los caballos saltan en
movimientos impredecibles, y la dama y el rey defienden su territorio con valentía. La
pantalla se llena de acción mientras las piezas rivalizan por el control del tablero.

35
El programa, dotado de inteligencia artificial, evalúa cada jugada y ofrece sugerencias
tácticas para mejorar el juego de los participantes. Las herramientas de análisis proporcionan
a los jugadores una visión más profunda de la posición y las posibles estrategias a seguir.
A medida que la partida se acerca a su clímax, la emoción se intensifica. Cada movimiento
se vuelve crucial, y los jugadores deben tomar decisiones cuidadosas para evitar los embates
del oponente y buscar oportunidades para alcanzar la victoria.
Finalmente, después de una intensa batalla mental, un jugador logra asegurar la victoria,
capturando el rey del oponente y proclamando su triunfo. El tablero se congela en la posición
final, mostrando el resultado de la partida mientras los jugadores reflexionan sobre su
desempeño y planean su próxima estrategia para el siguiente enfrentamiento.
Así concluye una emocionante partida de ajedrez en el mundo virtual, donde la estrategia, la
habilidad y la emoción se combinan para ofrecer una experiencia única y cautivadora para
los amantes del juego milenario.

36
 CONCLUSIONES.
Luego de completar el desarrollo del programa de ajedrez en Python, se pueden
extraer varias conclusiones importantes:

1. Viabilidad Tecnológica:

La creación de un programa de ajedrez en Python ha demostrado ser factible y viable desde

el punto de vista tecnológico. Python ofrece una amplia gama de herramientas y bibliotecas
que facilitan el desarrollo de aplicaciones de este tipo.

2. Desafíos Técnicos:

El proceso de desarrollo del programa presentó diversos desafíos técnicos, especialmente en

áreas como la representación del tablero, la implementación de las reglas del juego y la
creación de una interfaz de usuario intuitiva.

3. Importancia de la Planificación:

La fase inicial de planificación y diseño resultó fundamental para el éxito del proyecto.
Definir claramente los requisitos, establecer objetivos y diseñar una arquitectura sólida
contribuyó significativamente a la eficiencia y efectividad del desarrollo.

4. Pruebas Rigurosas:

Las pruebas exhaustivas desempeñaron un papel crucial en la identificación y corrección de

errores. La realización de pruebas continuas permitió garantizar la calidad y la estabilidad
del programa antes de su lanzamiento.

5. Feedback de los Usuarios:

La retroalimentación de los usuarios durante la fase de pruebas y después del lanzamiento

fue invaluable para mejorar el programa. Escuchar las opiniones y sugerencias de los usuarios
ayudó a identificar áreas de mejora y a implementar nuevas funcionalidades.

37
6. Continuidad del Mantenimiento:

El desarrollo de software es un proceso continuo. Mantener el programa actualizado, corregir

errores y agregar nuevas características es esencial para garantizar su relevancia y utilidad a
lo largo del tiempo.

En resumen, el proceso de desarrollo del programa de ajedrez en Python destacó la

importancia de una planificación cuidadosa, pruebas rigurosas y la colaboración con los
usuarios para crear una aplicación exitosa y satisfactoria.

38
 Anexos
- Ajedrez de Torneo. (s.f.). Historia del ajedrez.
- Efdeportes. (s.f.). Ajedrez en la escuela.
- Tecnologia+Informatica. (s.f.). El ajedrez y su historia.
- Krerivas. (s.f.). Historia del ajedrez.
- Russ, H. (2017). *Bobby Fischer Teaches Chess*. Bantam.
- Silman, J. (1999). *The Amateur's Mind: Turning Chess Misconceptions into Chess Mastery*. Siles
Press.
- Dvoretsky, M. (2014). *Dvoretsky's Endgame Manual*. Russell Enterprises.
- Chernev, I. (2018). *Logical Chess: Move By Move: Every Move Explained New Algebraic Edition*.
Batsford.
- Kasparov, G. (2010). *Garry Kasparov on My Great Predecessors, Part 1*. Everyman Chess.
- Pandolfini, B. (2003). *Pandolfini's Ultimate Guide to Chess*. Fireside.
- Schiller, E. (2003). *Learn to Play Chess Like a Boss: Make Pawns of Your Opponents with Tips and
Tricks from a Grandmaster of the Game*. Adams Media.
- Watson, J. (2016). *A Strategic Chess Opening Repertoire for White*. Mongoose Press.
- Soltis, A. (2003). *Pawn Structure Chess*. Batsford.
- Kasparov, G. (2007). *How Life Imitates Chess: Making the Right Moves, from the Board to the
Boardroom*. Bloomsbury Publishing.
- Fine, R. (2015). *Basic Chess Endings*. Ishi Press.

39