En esta entrega del tutorial voy a utilizar la baraja española, y en la siguiente la baraja vasca; ambas con 40 cartas, en lugar de las 52 que tiene la baraja francesa o de póker.
En la primera versión del juego se podrá jugar con estas tres barajas.
Parto del script obtenido en la primera entrega del tutorial, del que elimino la funcionalidad de 'drag and drop', aunque nos quedamos con la forma de implementarla para aplicarla posteriormente, y en el que como primer paso: creo la clase para el mazo de cartas ('Mazo'), cargo en una lista todas las imágenes correspondientes a las cartas de la baraja española, también cargo y dibujo la propia imagen del mazo con las cartas a descubrir (el reverso de las mismas), y creo ciertas listas, grupos y variables que iré explicando a medida que vaya incorporando funcionalidades:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# TUTORIAL: KLONDIKE(II).
#
# Microsoft Windows (1990).
#
# Pygame es una colección de módulos Python diseñados para crear videojuegos.
#
# Autor: Mikel García Larragan.
# https://mikelgarcialarragan.blogspot.com/
import pygame
import os
class Mazo(pygame.sprite.Sprite):
# El mazo de cartas estará definido por la clase Mazo.
def __init__(self, x, y):
super().__init__()
self.x, self.y = x, y
self.mazo = []
for palo in range(1, 5):
for carta in range(1, 11):
self.mazo.append('E_' + str(carta) + '_' + str(palo) + '.png')
self.image = pygame.image.load('reverso.png').convert_alpha()
self.rect = self.image.get_rect(center=(self.x, self.y))
class Palo(pygame.sprite.Sprite):
# Los palos de las cartas del mazo estará definidos por la clase Palo.
def __init__(self, palo, x, y):
super().__init__()
self.palo = palo + 1
self.x, self.y = x, y
self.image = pygame.image.load('E_' + str(self.palo) + '.png').convert_alpha()
self.rect = self.image.get_rect(center=(self.x, self.y))
class Carta(pygame.sprite.Sprite):
# Las cartas estarán definidas por la clase Carta.
def __init__(self, mazo, num_carta):
super().__init__()
self.mazo = mazo
self.num_carta = num_carta
self.image = pygame.image.load(self.mazo.mazo[self.num_carta]).convert_alpha()
def mover(self, x, y, descubierta):
# Método que permite mover las cartas.
self.x, self.y = x, y
self.rect = self.image.get_rect(center=(self.x, self.y))
def klondike():
while True:
# inicializar módulos internos de pygame.
pygame.init()
# Obtener las dimensiones de la pantalla.
informacion_pantalla = pygame.display.Info()
# Establecer tamaño de la ventana.
ancho_pantalla = informacion_pantalla.current_w - int(informacion_pantalla.current_w * 0.5)
alto_pantalla = informacion_pantalla.current_h - int(informacion_pantalla.current_h * 0.45)
# crear una superficie de visualización: la ventana, y centrarla.
os.environ['SDL_VIDEO_CENTERED']='1'
ventana = pygame.display.set_mode((ancho_pantalla,alto_pantalla))
# Título de la ventana.
pygame.display.set_caption('Klondike')
# Icono de la ventana.
# Cargar la imagen del icono.
icono = pygame.image.load('klondike.ico')
# Establecer el icono de la ventana en tiempo de ejecución.
pygame.display.set_icon(icono)
# Cargar la imagen del fondo del juego.
fondo_juego = pygame.image.load('fondo_juego.png')
# Cambiar el formato de píxel del fondo del juego para crear una copia que se dibujará más rápidamente
# en la pantalla.
fondo_juego = fondo_juego.convert()
# Cargar archivos de fuentes y sonidos.
sonido_click = pygame.mixer.Sound('click.wav')
# Crear canal para sonidos.
canal1 = pygame.mixer.Channel(0)
# Dibujar el mazo de cartas e incluirlo en un grupo individual.
grupo_mazo = pygame.sprite.GroupSingle()
mazo = Mazo(ancho_pantalla - 845, alto_pantalla - 494)
grupo_mazo.add(mazo)
# Dibujar los sitios de las pilas de los mazos e incluirlos en un grupo.
grupo_palos = pygame.sprite.Group()
x, y = ancho_pantalla - 485, alto_pantalla - 494
for num_palo in range(4):
palo = Palo(num_palo, x, y)
grupo_palos.add(palo)
x += 120
# Variable booleana que indica si se ha hecho click sobre el mazo.
mazo_clickado = False
# Lista y grupo para las cartas que se van descubriendo del mazo.
lista_cartas_descubiertas = []
grupo_cartas_descubiertas = pygame.sprite.Group()
# Variables que indican la siguiente carta del mazo a descubrir y si éste está vacio, respectivamente.
carta_a_descubrir, mazo_vacio = 28, False
# Parámetros de la baraja a utilizar:
num_cartas = 40
cartas_a_descubrir = num_cartas - 28
# Última carta descubierta del mazo.
ultima_carta_descubierta = None
# Variable booleana que indica si se está arrastrando una o más cartas.
arrastrando_cartas = False
# Reloj para ejecutar el juego.
reloj = pygame.time.Clock()
# El juego se ejecutará a 60 frames por segundo.
fps = 60
# Bucle juego.
while True:
# Ejecutar el siguiente frame.
reloj.tick(fps)
# Escuchar cada uno de eventos de la lista de eventos de Pygame.
for evento in pygame.event.get():
# Finalizar el juego cuando se produzca el evento de terminación del programa (cierre de la ventana).
if evento.type == pygame.QUIT:
pygame.quit()
return
# Comprobar si se ha realizado click del botón izquierdo del ratón.
elif evento.type == pygame.MOUSEBUTTONDOWN:
if evento.button == 1:
# Obtener posición del puntero del ratón.
posicion_raton = pygame.mouse.get_pos()
# Comprobar si se ha soltado (liberado) el botón izquierdo del ratón.
elif evento.type == pygame.MOUSEBUTTONUP:
if evento.button == 1:
arrastrando_cartas = False
# Seguimiento del movimiento del ratón.
elif evento.type == pygame.MOUSEMOTION:
if arrastrando_cartas:
posicion_raton_x, posicion_raton_y = evento.pos
# Actualiza sprites.
grupo_mazo.update()
grupo_palos.update()
grupo_cartas_descubiertas.update()
# Copiar la imagen de fondo de la ventana en el canvas que la mostrará.
ventana.blit(fondo_juego, (0, 0))
# dibujar sprites.
grupo_mazo.draw(ventana)
grupo_palos.draw(ventana)
grupo_cartas_descubiertas.draw(ventana)
# Mostrar la ventana dibujada (cambiar buffers, buffer pantalla a disponible para dibujar y viceversa).
pygame.display.flip()
if __name__ == '__main__':
klondike()
Tras la ejecución de este script obtenemos lo siguiente:
Ahora, implemento las funcionalidades objeto de esta segunda entrega del tutorial. Basicamente, se trata de:
- Barajar las cartas del mazo.
- Descubrir las cartas del mazo.
1.- Barajar las cartas del mazo:
Para ello, basta con utilizar el método .shuflle() del módulo random de la librería estándar de python, que 'mezcla' o cambia aleatoriamente el orden de los elementos de una lista (para ser rigurosos hay que decir que los cambia de forma pseudoaleatoria). En nuestro caso, los elementos de la lista serán las cartas del mazo.
Importo el método .shuflle() del módulo random, creo un nuevo método .barajar() en la clase 'Mazo' y realizo la llamada a este método después de instanciar el objeto 'Mazo':
from random import shuffle
...
def barajar(self):
# Método que permite barajar el mazo de cartas.
shuffle(self.mazo)...
# Barajar el mazo.
mazo.barajar()
print('*** Mazo barajado:('+str(len(mazo.mazo))+'):', mazo.mazo)
print('------------------------------------------------------')Después de ejecutar el script, el resultado de las sentencias print es el siguiente:
*** Mazo barajado:(40): ['E_6_2.png', 'E_4_3.png', 'E_1_1.png', 'E_6_3.png', 'E_8_4.png', 'E_8_1.png', 'E_10_4.png', 'E_7_3.png', 'E_7_2.png', 'E_8_2.png', 'E_3_2.png', 'E_2_1.png', 'E_9_2.png', 'E_4_2.png', 'E_1_3.png', 'E_7_4.png', 'E_10_3.png', 'E_2_4.png', 'E_3_4.png', 'E_7_1.png', 'E_2_3.png', 'E_1_4.png', 'E_9_1.png', 'E_5_3.png', 'E_10_2.png', 'E_5_4.png', 'E_9_3.png', 'E_9_4.png', 'E_2_2.png', 'E_3_3.png', 'E_5_2.png', 'E_1_2.png', 'E_8_3.png', 'E_6_1.png', 'E_6_4.png', 'E_10_1.png', 'E_4_1.png', 'E_4_4.png', 'E_3_1.png', 'E_5_1.png']
------------------------------------------------------
Tal y como se observa, los elementos de la lista (las cartas del mazo) se han 'mezclado'. En cada carta o elemento de la lista:
- E: indica baraja española.
- Primer número: indica el valor de la carta (desde el 1, el As, hasta el 13, el Rey).
- Segundo número: indica el palo de la carta (1: Oros; 2: Copas; 3: Espadas y 4: Bastos).
Es decir, tras haberse barajado, el mazo ha quedado: 6 de copas, 4 de espadas, As de oros ..., cinco de oros.
2.- Descubrir la cartas del mazo:
Se trata de, tras hacerse clic sobre el mazo con el botón izquierdo del ratón, ir descubriendo las cartas de éste, de tres en tres.
Para ello, en primer lugar y de forma análoga que lo descrito en la primera entrega de este tutorial, utilizo el evento MOUSEBUTTONDOWN del ratón para saber si se ha hecho clic sobre el mazo con el botón izquierdo. Incorporo esto en la escucha de los eventos:
for evento in pygame.event.get():
# Finalizar el juego cuando se produzca el evento de terminación del programa (cierre de la ventana).
if evento.type == pygame.QUIT:
pygame.quit()
return
# Comprobar si se ha realizado click del botón izquierdo del ratón.
elif evento.type == pygame.MOUSEBUTTONDOWN:
if evento.button == 1:
# Obtener posición del puntero del ratón.
posicion_raton = pygame.mouse.get_pos()
# Comprobar si se ha realizado click del botón izquierdo del ratón sobre el
# mazo de cartas.
if mazo.rect.collidepoint(posicion_raton):
canal1.play(sonido_click)
mazo_clickado = TrueEs decir, si se pulsa el botón izquierdo obtengo la posición del ratón, mediante el método .mouse.get_pos(), y, después, compruebo si ese clic se realiza sobre el mazo, utilizando el método .collidepoint(), que devuelve verdadero si el punto indicado está dentro del rectángulo, es decir, en nuestro caso si el puntero del ratón se encuentra dentro del mazo en el momento de hacerse clic con el botón izquierdo.
Posteriormente, incorporo dos nuevos métodos, .vaciar() y .reiniciar(), en nuestra clase 'Mazo', para que se muestren las imágenes del sitio del mazo vacío y del mazo con todas las cartas boca abajo, respectivamente:
def vaciar(self):
# Método que muestra la imagen del sitio del mazo vacío de cartas.
self.image = pygame.image.load('sitio_mazo.png').convert_alpha()
def reiniciar(self):
# Método que muestra la imagen del sitio del mazo con las cartas a descubrir.
self.image = pygame.image.load('reverso.png').convert_alpha()Y un nuevo método, .descubrir(), en nuestra clase 'Carta', para ir mostrando las cartas que se van descubriendo:
def descubrir(self, orden):
# Método que permite ir descubriendo las cartas del mazo.
self.orden = orden
if self.orden == 0:
self.rect = self.image.get_rect(center=(self.mazo.x + 100, self.mazo.y))
elif self.orden == 1:
self.rect = self.image.get_rect(center=(self.mazo.x + 120, self.mazo.y))
elif self.orden == 2:
self.rect = self.image.get_rect(center=(self.mazo.x + 140, self.mazo.y))Y, finalmente, incluyo la lógica correspondiente a realizar clic sobre el mazo, que consiste en recorrer las cartas del mazo, a partir, de la número 28 ( con las del 0 al 27 se formarán las columnas) e ir descubriéndolas de tres en tres, y, cuando se finalice, volver a comenzar:
if mazo_clickado:
if mazo_vacio:
lista_cartas_descubiertas = []
grupo_cartas_descubiertas.empty()
ultima_carta_descubierta = None
mazo.reiniciar()
mazo_vacio = False
else:
for orden_carta in range(3):
carta = Carta(mazo, carta_a_descubrir)
carta.descubrir(orden_carta)
lista_cartas_descubiertas.append((carta, mazo.mazo[carta_a_descubrir]))
grupo_cartas_descubiertas.add(carta)
if len(lista_cartas_descubiertas) == cartas_a_descubrir:
mazo.vaciar()
mazo_vacio = True
carta_a_descubrir = 28
break
else:
carta_a_descubrir += 1
mazo_clickado = FalsePoniendo junto todo lo hecho hasta este momento obtenemos:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# TUTORIAL: KLONDIKE(II).
#
# Microsoft Windows (1990).
#
# Pygame es una colección de módulos Python diseñados para crear videojuegos.
#
# Autor: Mikel García Larragan.
# https://mikelgarcialarragan.blogspot.com/
import pygame
import os
from random import shuffle
class Mazo(pygame.sprite.Sprite):
# El mazo de cartas estará definido por la clase Mazo.
def __init__(self, x, y):
super().__init__()
self.x, self.y = x, y
self.mazo = []
for palo in range(1, 5):
for carta in range(1, 11):
self.mazo.append('E_' + str(carta) + '_' + str(palo) + '.png')
self.image = pygame.image.load('reverso.png').convert_alpha()
self.rect = self.image.get_rect(center=(self.x, self.y))
def barajar(self):
# Método que permite barajar el mazo de cartas.
shuffle(self.mazo)
def vaciar(self):
# Método que muestra la imagen del sitio del mazo vacío de cartas.
self.image = pygame.image.load('sitio_mazo.png').convert_alpha()
def reiniciar(self):
# Método que muestra la imagen del sitio del mazo con las cartas a descubrir.
self.image = pygame.image.load('reverso.png').convert_alpha()
class Palo(pygame.sprite.Sprite):
# Los palos de las cartas del mazo estará definidos por la clase Palo.
def __init__(self, palo, x, y):
super().__init__()
self.palo = palo + 1
self.x, self.y = x, y
self.image = pygame.image.load('E_' + str(self.palo) + '.png').convert_alpha()
self.rect = self.image.get_rect(center=(self.x, self.y))
class Carta(pygame.sprite.Sprite):
# Las cartas estarán definidas por la clase Carta.
def __init__(self, mazo, num_carta):
super().__init__()
self.mazo = mazo
self.num_carta = num_carta
self.image = pygame.image.load(self.mazo.mazo[self.num_carta]).convert_alpha()
def mover(self, x, y, descubierta):
# Método que permite mover las cartas.
self.x, self.y = x, y
self.rect = self.image.get_rect(center=(self.x, self.y))
def descubrir(self, orden):
# Método que permite ir descubriendo las cartas del mazo.
self.orden = orden
if self.orden == 0:
self.rect = self.image.get_rect(center=(self.mazo.x + 100, self.mazo.y))
elif self.orden == 1:
self.rect = self.image.get_rect(center=(self.mazo.x + 120, self.mazo.y))
elif self.orden == 2:
self.rect = self.image.get_rect(center=(self.mazo.x + 140, self.mazo.y))
def klondike():
while True:
# inicializar módulos internos de pygame.
pygame.init()
# Obtener las dimensiones de la pantalla.
informacion_pantalla = pygame.display.Info()
# Establecer tamaño de la ventana.
ancho_pantalla = informacion_pantalla.current_w - int(informacion_pantalla.current_w * 0.5)
alto_pantalla = informacion_pantalla.current_h - int(informacion_pantalla.current_h * 0.45)
# crear una superficie de visualización: la ventana, y centrarla.
os.environ['SDL_VIDEO_CENTERED']='1'
ventana = pygame.display.set_mode((ancho_pantalla,alto_pantalla))
# Título de la ventana.
pygame.display.set_caption('Klondike')
# Icono de la ventana.
# Cargar la imagen del icono.
icono = pygame.image.load('klondike.ico')
# Establecer el icono de la ventana en tiempo de ejecución.
pygame.display.set_icon(icono)
# Cargar la imagen del fondo del juego.
fondo_juego = pygame.image.load('fondo_juego.png')
# Cambiar el formato de píxel del fondo del juego para crear una copia que se dibujará más rápidamente
# en la pantalla.
fondo_juego = fondo_juego.convert()
# Cargar archivos de fuentes y sonidos.
sonido_click = pygame.mixer.Sound('click.wav')
# Crear canal para sonidos.
canal1 = pygame.mixer.Channel(0)
# Dibujar el mazo de cartas e incluirlo en un grupo individual.
grupo_mazo = pygame.sprite.GroupSingle()
mazo = Mazo(ancho_pantalla - 845, alto_pantalla - 494)
grupo_mazo.add(mazo)
# Dibujar los sitios de las pilas de los palos e incluirlos en un grupo.
grupo_palos = pygame.sprite.Group()
x, y = ancho_pantalla - 485, alto_pantalla - 494
for num_palo in range(4):
palo = Palo(num_palo, x, y)
grupo_palos.add(palo)
x += 120
# Barajar el mazo.
mazo.barajar()
print('*** Mazo barajado:('+str(len(mazo.mazo))+'):', mazo.mazo)
print('------------------------------------------------------')
# Variable booleana que indica si se ha hecho click sobre el mazo.
mazo_clickado = False
# Lista y grupo para las cartas que se van descubriendo del mazo.
lista_cartas_descubiertas = []
grupo_cartas_descubiertas = pygame.sprite.Group()
# Variables que indican la siguiente carta del mazo a descubrir y si éste está vacio, respectivamente.
carta_a_descubrir, mazo_vacio = 28, False
# Parámetros de la baraja a utilizar:
num_cartas = 40
cartas_a_descubrir = num_cartas - 28
# Última carta descubierta del mazo.
ultima_carta_descubierta = None
# Variable booleana que indica si se está arrastrando una o más cartas.
arrastrando_cartas = False
# Reloj para ejecutar el juego.
reloj = pygame.time.Clock()
# El juego se ejecutará a 60 frames por segundo.
fps = 60
# Bucle juego.
while True:
# Ejecutar el siguiente frame.
reloj.tick(fps)
# Escuchar cada uno de eventos de la lista de eventos de Pygame.
for evento in pygame.event.get():
# Finalizar el juego cuando se produzca el evento de terminación del programa (cierre de la ventana).
if evento.type == pygame.QUIT:
pygame.quit()
return
# Comprobar si se ha realizado click del botón izquierdo del ratón.
elif evento.type == pygame.MOUSEBUTTONDOWN:
if evento.button == 1:
# Obtener posición del puntero del ratón.
posicion_raton = pygame.mouse.get_pos()
# Comprobar si se ha realizado click del botón izquierdo del ratón sobre el
# mazo de cartas.
if mazo.rect.collidepoint(posicion_raton):
canal1.play(sonido_click)
mazo_clickado = True
# Comprobar si se ha soltado (liberado) el botón izquierdo del ratón.
elif evento.type == pygame.MOUSEBUTTONUP:
if evento.button == 1:
arrastrando_cartas = False
# Seguimiento del movimiento del ratón.
elif evento.type == pygame.MOUSEMOTION:
if arrastrando_cartas:
posicion_raton_x, posicion_raton_y = evento.pos
if mazo_clickado:
if mazo_vacio:
lista_cartas_descubiertas = []
grupo_cartas_descubiertas.empty()
ultima_carta_descubierta = None
mazo.reiniciar()
mazo_vacio = False
else:
for orden_carta in range(3):
carta = Carta(mazo, carta_a_descubrir)
carta.descubrir(orden_carta)
lista_cartas_descubiertas.append((carta, mazo.mazo[carta_a_descubrir]))
grupo_cartas_descubiertas.add(carta)
if len(lista_cartas_descubiertas) == cartas_a_descubrir:
mazo.vaciar()
mazo_vacio = True
carta_a_descubrir = 28
break
else:
carta_a_descubrir += 1
mazo_clickado = False
# Actualiza sprites.
grupo_mazo.update()
grupo_palos.update()
grupo_cartas_descubiertas.update()
# Copiar la imagen de fondo de la ventana en el canvas que la mostrará.
ventana.blit(fondo_juego, (0, 0))
# dibujar sprites.
grupo_mazo.draw(ventana)
grupo_palos.draw(ventana)
grupo_cartas_descubiertas.draw(ventana)
# Mostrar la ventana dibujada (cambiar buffers, buffer pantalla a disponible para dibujar y viceversa).
pygame.display.flip()
if __name__ == '__main__':
klondike()Si lo ejecutamos:
Y hasta aquí esta segunda entrega del tutorial sobre el solitario Klondike. En posteriores entradas abordaré aspectos tales como: distribuir las primeras 28 cartas del mazo en las siete columnas, apilar las cartas en la pila del palo que les correponde, arrastrar cartas del mazo a las columnas y soltarlas...
Quizás también te interese:
Comentarios
Publicar un comentario