def convertir_Carta_A_Num(carta):
#Igual que antes generamos una estructura de ifs anidada donde
# primero ponemos el casos donde no podemos convertir directamente
# el string a int y luego mediante un else controlamos el resto de
# casos. Es importante en ese último caso que controla todos los
# casos en los que se puede hacer la conversión directamente, el crear
# una estructura try y except donde controlemos el proceso de conversión
# de string a int. Puesto que a ese caso llegará cualquier string
# que no sea AS, SOTA, CABALLO y REY, por lo que podría resultar
# que llegara cualquier string que no fuera convertible a int y
# eso tenemos que controlarlo mostrando la pantalla de error
if carta == "AS":
return 1
elif carta == "SOTA":
return 10
elif carta == "CABALLO":
return 11
elif carta == "REY":
return 12
else:
try:
num = int(carta)
return num
except Exception as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
pantallaError = PantallaError(r"Error {0} no es un valor válido de carta".format(carta))
pantallaError.mostrarPantallaError()
sys.exit()
def calcularResultado(self):
try:
#Recuperamos las cartas de la ronda
cartajugador = self.cartasjugador[0]
cartaordenador = self.cartasordenador[0]
#Recuperamos el valor los marcadores
j = self.marcador["jugador"]
o = self.marcador["ordenador"]
#Con el método convertir_Carta_A_Num convertirmos el
#atributo string numero de la clase Carta a valor
#numérico para así poder compararlo
numJugador = Utiles.convertir_Carta_A_Num(cartajugador.numero)
numOrdenador = Utiles.convertir_Carta_A_Num(cartaordenador.numero)
#Si la carta del jugador es más alta, ha ganado la ronda
if (numJugador > numOrdenador):
#Sumamos uno a su marcador
self.marcador = {"jugador": j + 1, "ordenador": o}
#Si la carta del jugador es más baja, ha ganado la ronda el ordenador
elif (numJugador < numOrdenador):
#Sumanos uno a su marcador
self.marcador = {"jugador": j, "ordenador": o + 1}
except Exception as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Atrapamos cualquier excepción posible y mostramos
#la pantalla de error
pantallaError = PantallaError("Error al actualizar marcadores")
pantallaError.mostrarPantallaError()
sys.exit()
def abrirFicheroEscritura(ruta=RUTA):
#Creamos una variable fichero
fichero = None
try:
#Si el fichero ya existe y el tamaño del fichero es mayor que
# un determinado valor de bytes
if os.path.isfile(ruta) and os.path.getsize(ruta) > 100000:
#Copiamos el fichero baraja.txt a una fichero der back-up
#que termina el la fecha actual hasta el milisegundo
copyfile(
ruta, ruta + "-" +
datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S-%f"))
#Borramos el contenido del fichero baraja.txt y
#lo abrimos para escritura mediante el modo w
fichero = open(ruta, "w", encoding="utf-8")
else:
#En caso contrario tenemos que seguir escribiendo
#en el fichero baraja.txt para lo que usamos el modo a
fichero = open(ruta, "a+", encoding="utf-8")
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Atrapamos al excepción que se producirá en el caso de
#no encontrar el archivo y mostramos la pantalla de error
pantallaError = PantallaError(r"Falta el fichero {0}".format(ruta))
pantallaError.mostrarPantallaError()
sys.exit()
#Devolvemos el fichero
return fichero
def __init__(self, numero, palo):
pygame.sprite.Sprite.__init__(self)
#Igualamos los parámetros de entrada a los parámetros palo y número
#propios de la clase
#Además los definimos como no accesibles fuera
#de la clase, en primer lugar como método didáctico
#y en otro porque no nos interesa que se pueda modificar
#el valor de una carta una vez creada
self.__palo = palo
self.__numero = numero
try:
#Aquí asignamos la imagen de la carta a cada carta
#Para ello, usamos el método load del módulo image de pygame
#al que hay que pasarle la ruta a la imagen
#En utiles hemos definido una función a la que si le damos
#el valor y el palo de la carta, nos devuelve la ruta
#en la que tal imagen debería encontrarse
self.image = pygame.image.load(
utiles.convertir_Carta_A_Ruta(self.palo,
self.numero)).convert_alpha()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos la excepción en caso de que el fichero no haya sido
#encontrado y devolvemos la pantalla de error
pantallaError = PantallaError(
r"Error al buscar las imágenes de las cartas")
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos cualquier otra excepción que pueda darse y devolvemos
#la pantalla de error
pantallaError = PantallaError(
r"Error al buscar las imágenes de las cartas")
pantallaError.mostrarPantallaError()
sys.exit()
#En caso de que no haya habido errores, procedemos a
#terminar con la definición de las cartas
else:
#Definimos el rectángulo en el cual se imprime la imagen
self.rect = self.image.get_rect()
self.rect.centery = 350
def procesarRespuestaMenu(i,screen = None):
#En este caso generamos una estructura de ifs aninados
# Solo hay tres valores posibles
# Caso el usuario elige el primer item, significa que el usuario
# quiere jugar una partida
if i == 0:
#Llamamos al método controladorPartida que gestiona todos
# los eventos necesario para generar esa partida
controladorPartida(screen)
elif i == 1:
Estadisticas.generarGraficoEstadisticas(Estadisticas.RUTA_FICHERO_CSV)
elif i == 2:
#En caso de seleccionar Salir, simplemente detenemos la ejecución
sys.exit()
else:
#Controlamos por si acaso el caso en que llegara un valor inválido
# y mostramos la pantalla de error
pantallaError = PantallaError(r"Error con los items del menú")
pantallaError.mostrarPantallaError()
sys.exit()
def convertir_Num_A_Carta(num):
#Para ello generamos una estructura de ifs anidados, especificando
# los casos en los que hay que cambiar el valor numérico por otro
# string distinto (1 por AS, 10 por SOTA..) y devolvemos directamente
# el string. También ponemos un elif que controle el caso en que los
# valores no sean correctos y lanzamos nuestra pantalla de error en ese
# caso. Finalmente solo quedan los casos en los que solo habrá que
# convertir el int de num a string y lo devolvemos también
if num == 1:
return "AS"
elif num == 10:
return "SOTA"
elif num == 11:
return "CABALLO"
elif num == 12:
return "REY"
elif num > 12 or num < 0:
pantallaError = PantallaError(r"Error {0} no es un valor válido de carta".format(num))
pantallaError.mostrarPantallaError()
sys.exit()
else:
return str(num)
def escribirFichero(ruta, *textos):
#Abrimos el fichero usando el método que habíamos desarrollado
#anteriormente
fichero = abrirFicheroEscritura(ruta)
try:
for texto in textos:
#Cogemos cada línea de la variable sobre la que iteramos
#Escribimos la línea en el fichero usando write
fichero.write(texto)
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Atrapamos la excepción de fichero no encontrado
#y mostramos la pantalla de error
pantallaError = PantallaError(r"Falta el fichero {0}".format(ruta))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Atrapamos cualquier otra posible excepción y mostramos
#la pantalla de error
pantallaError = PantallaError(
r"Error al escribir en el fichero {0}".format(ruta))
pantallaError.mostrarPantallaError()
sys.exit()
finally:
#Usamos finally aquí para asegurarnos de que el fichero
#será cerrado siempre. Ya que finally siempre es ejecutado
#antes de terminar la iteración sobre la estructura try y except
fichero.close()
def mensajeInicial(self):
#Gracias al decorador ya generemos la baraja nueva
#para la partida nueva
i = 0
#Generamos un bucle que mostrará durante 5 segundos el mensaje
#de bienvenida a la partida
while i < 5:
#Escuchamos los eventos eventos del teclado y ratón
for evento in pygame.event.get():
#Solo responderemos al cierre de la ventana
#terminando la ejecución
if evento.type == pygame.QUIT:
sys.exit()
#Definimos una variable background que contendrá la
#imagen que usaremos para el fondo
background = None
try:
#Cargamos la imagen del fondo usando el método
#load del módulo image
background = pygame.image.load(
Utiles.RUTA_FONDO_MESA_JUEGO).convert()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos la excepción que se generará en caso
# de no encontrar el fichero y mostraremos la
#pantalla de error
pantallaError = PantallaError(r"Falta el fichero {0}".format(
Utiles.RUTA_FONDO_MESA_JUEGO))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos cualquier excepción que se pueda
#generar y mostramos la pantalla de error
pantallaError = PantallaError(
r"Ocurrió un problema con la mesa de juego")
pantallaError.mostrarPantallaError()
sys.exit()
#Definimos el rectángulo donde imprimiremos la imagen
background_rect = background.get_rect()
#Imprimimos la imagen del fondo sobre la pantalla
#con screen.blit
self.screen.blit(background, background_rect)
#Iniciamos las fuentes de pygame
pygame.font.init()
#Definimos la fuente del mensaje
fuenteJugador = pygame.font.SysFont(self.TIPO_FUENTE_1, 50)
sizeTextoJugador = fuenteJugador.size("Tengo una baraja.")
#Generamos el texto del mensaje
textoJugador = fuenteJugador.render('Tengo una baraja.', False,
(0, 0, 0))
#Generamos el texto para el segundo mensaje
sizeTextoJugador2 = fuenteJugador.size("Vamos a jugar.")
textoJugador2 = fuenteJugador.render('Vamos a jugar.', False,
(0, 0, 0))
#Imprimimos ambos mensajes en la pantalla con screen.blit
self.screen.blit(
textoJugador,
(self.screen.get_width() / 2 - sizeTextoJugador[0] / 2,
self.screen.get_height() / 2 - sizeTextoJugador[1]))
self.screen.blit(
textoJugador2,
(self.screen.get_width() / 2 - sizeTextoJugador2[0] / 2,
self.screen.get_height() / 2 + sizeTextoJugador2[1]))
#Actualizamos la pantalla
pygame.display.flip()
#Esperamos 0.1 segs
time.sleep(0.1)
#Avanzamos el bucle
i += 1
def animacionPapete(self):
#Preparamos los sprites de las cartas y los recuperamos
self.sprite_jugador = self.prepararSpriteCarta()
self.cartasjugador = self.sprite_jugador.sprites()
self.sprite_ordenador = self.prepararSpriteCarta()
self.cartasordenador = self.sprite_ordenador.sprites()
#Como ya tenemos las cartas usamos este método para calcular
#el resultado de la ronda
self.calcularResultado()
background = None
try:
#Cargamos la imagen para el fondo del tapete
background = pygame.image.load(Utiles.RUTA_TAPETE).convert()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Capturamos la excepción que se generaría en caso
#de no encontrar el fichero y mostramos lap pantalla de error
pantallaError = PantallaError(r"El fichero {0} no existe".format(
Utiles.RUTA_TAPETE))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Capturamos cualquier excepción y mostramos la pantalla de error
pantallaError = PantallaError(
r"Ocurrió un error en la mesa de juego")
pantallaError.mostrarPantallaError()
sys.exit()
i = 0
#Hasta que las cartas no estén en el centro seguiremos
#usando un bucle que las anima
#Este parámetro boolean es el que cambiará a true cuando
#las cartas lleguen al centro y por tanto se acabe la ronda
finRonda = False
while not finRonda:
#Escuchamos los eventos del teclado y el ratón
for evento in pygame.event.get():
#Solo respondemos al cierre de la ventana terminado la ejecución
if evento.type == pygame.QUIT:
sys.exit()
#Recuperamos la carta del jugador
cartajugador = self.cartasjugador[0]
#Recuperamos la carta del ordenador
cartaordenador = self.cartasordenador[0]
#En cada iteración movemos la carta del jugador
#de izquierda a derecha hasta el centro
cartajugador.rect.left = i - (cartajugador.image.get_rect().width /
2)
cartajugador.rect.top = (self.screen.get_height() /
2) - cartajugador.image.get_rect().height
#En cada iteración movemos la carta del ordenador
#de derecha a izquierda hasta el centro
cartaordenador.rect.left = self.screen.get_width() - i - (
cartaordenador.image.get_rect().width / 2)
cartaordenador.rect.top = (self.screen.get_height() / 2) + 50
#Mostramos la imagen del fondo del tapete
background_rect = background.get_rect()
self.screen.blit(background, background_rect)
#Iniciamos las fuentes
pygame.font.init()
#Generamos un texto que dice Carta Jugador
fuenteCartas = pygame.font.SysFont(self.TIPO_FUENTE_1, 20)
sizeTextoJugador = fuenteCartas.size("Carta Jugador")
textoJugador = fuenteCartas.render('Carta Jugador', False,
(0, 0, 0))
#Lo vamos mostrando en cada iteración de manera que se mueva junto con su carta
self.screen.blit(textoJugador,
(i - (sizeTextoJugador[0] / 2), 170))
#Generamos un texto que dice Carta Ordenador
sizeTextoOrdenador = fuenteCartas.size("Carta Ordenador")
textoOrdenador = fuenteCartas.render('Carta Ordenador', False,
(0, 0, 0))
#Lo vamos mostrando en cada iteración de manera que sigue a la carta
self.screen.blit(
textoOrdenador,
(self.screen.get_width() - i -
(sizeTextoOrdenador[0] / 2), self.screen.get_height() - 140))
#Dibujamos la carta
self.sprite_jugador.draw(self.screen)
#Dibujamos la carta
self.sprite_ordenador.draw(self.screen)
#Mostramos los marcadores
self.rotuloMarcador()
#Si todavía no hemos llegado a la mitad avanzamos
if (i < (self.screen.get_width()) / 2):
i += 1
else:
#En caso de llegar a la mitad mostramos el resultado
#de la ronda usando actualizarConResultado
ganador = self.actualizarConResultado(cartajugador,
cartaordenador)
#Es el final de la ronda, esto romperá el bucle
finRonda = True
#Como ha terminado la ronda, introducimos en la lista
#de registros que recibirá el csv
datarow = {
"T": "R",
"G": ganador,
"CPJ": "{0}".format(cartajugador),
"CPO": "{0}".format(cartaordenador)
}
self.datacsv.append(datarow)
#Actualizamos la pantalla
pygame.display.flip()
#Devolvemos el marcador
return self.marcador
def popupCortarBaraja(self):
font = pygame.font.Font(None, 32)
clock = pygame.time.Clock()
#Cargamos la imagen para el fondo de la pantalla
background = None
try:
background = pygame.image.load(
Utiles.RUTA_FONDO_MESA_JUEGO).convert()
#Recogemos cualquier posible excepción y mostramos la pantalla de error
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
pantallaError = PantallaError(r"Falta el fichero {0}".format(
Utiles.RUTA_FONDO_MESA_JUEGO))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
pantallaError = PantallaError(
r"Ocurrió un error en la mesa de juego")
pantallaError.mostrarPantallaError()
sys.exit()
#Definimos el rectángulo donde imprimiremos la imagen del fondo
background_rect = background.get_rect()
#Definimos la caja para el input para el usuario
input_box = pygame.Rect(self.screen.get_width() / 2 - 17.5,
self.screen.get_height() / 2 + 15, 35, 32)
#Definimos los colores que tendrá, azul claro para cuando esté inactivo
#y azul más oscuro apra cuando esté inactivo
color_inactive = pygame.Color('lightskyblue3')
color_active = pygame.Color('dodgerblue2')
#Por defecto tal input estará activo
color = color_active
active = True
#Esta será la variable que contendrá y mostrará el texto
#que el usuario introducirá por defecto
text = ''
#Definimos esta variable que controla el bucle que usaremos
#para mostrar la pantalla, hasta que el usuario no realice
#la acción que cambiará esta variable booleana a True, no
#se terminará el bucle (not True = False)
done = False
while not done:
#Escuchamos todos los eventos del teclado y raton
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
# Si el usuario hace click en el input
if input_box.collidepoint(event.pos):
# El input cambiará a activo
active = not active
else:
#Si ha pulsado en otra parte, pasará a inactivo
active = False
# Esta sentencia coordina el color del input con su estado
color = color_active if active else color_inactive
#Escuchamos si el usuario pulsa una tecla
if event.type == pygame.KEYDOWN:
if active:
#Si el input está activo
#Si el usuario pulsa ENTER
if event.key == pygame.K_RETURN or event.key == pygame.K_KP_ENTER:
try:
if text == "":
#Si no introdujo texto, no hacemos nada. Además es una manera
#de exponer de manera didáctica qué hace la sentencia pass
pass
#Si el texto que ha introducido por el teclado corresponde
#a un número que es mayor que la longitud de la baraja
elif int(text) > len(self.baraja.cartas):
#Simplemente sustituimos la cadena por la longitud de la baraja
text = "{0}".format(len(
self.baraja.cartas))
elif int(text) == 0:
#Si el usuario introdujo 0, lo cambiamos por 1
text = "1"
else:
#En caso de que no haya que cambiar el input del usuario
#significa que validamos ese entero y terminamos
#la ejecución de este bucle, para eso cambiamos Done a True
#y ello provocará avanzar en el flujo
done = True
except ValueError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
print(
"Ha ocurrido la siguiente excepción: {0}".
format(e))
print(exc_type, fname, exc_tb.tb_lineno)
pantallaError = PantallaError(
r"Has introducido un valor inválido")
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
print(
"Ha ocurrido la siguiente excepción: {0}".
format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
pantallaError = PantallaError(
r"Ha ocurrido un error al procesar tu valor"
)
pantallaError.mostrarPantallaError()
sys.exit()
#Así borramos un caracter del input cuando el usario pulsa borrar
elif event.key == pygame.K_BACKSPACE:
text = text[:-1]
else:
#Cada vez que añada un dígito lo añadimos al texto que mostrar
#aunque ponemos dos dígitos como límite en el input
#no escucharemos si el usuario quiere meter un tercero
if (len(text) < 2):
newText = ''.join(i for i in event.unicode
if i.isdigit())
text += newText
#También escuchamos al cierre de la ventana
if event.type == pygame.QUIT:
sys.exit()
#Imprimimos en pantalla el fondo con screen.blit
self.screen.blit(background, background_rect)
#Generamos el texto del input
txt_surface = font.render(text, True, color)
rect = txt_surface.get_rect()
#Generamos la fuente que llevarán los textos del pop-up
fuenteTextoPopUp = pygame.font.SysFont(self.TIPO_FUENTE_1, 22)
#Definimos una superficie que será sobre la que
#imprimiremos el pop-up
popupSurf = pygame.Surface((400, 150))
#Le damos color y lo colocamos en su posición
popupSurf.fill(self.FONDO_POP_UP)
popupRect = popupSurf.get_rect()
popupRect.centerx = self.screen.get_width() / 2
popupRect.centery = self.screen.get_height() / 2
rect.bottom = popupRect.bottom
rect.left = self.screen.get_width() / 2 - rect.width / 2
#Imprimimos el texto del input del usuario en la superficie
popupSurf.blit(txt_surface, rect)
#Generamos los textos del mensaje para el usuario y los
# colocamos en la superficie y los mostramos
sizeTextoPopUp = fuenteTextoPopUp.size("Te toca cortar la baraja")
textSurf = fuenteTextoPopUp.render("Te toca cortar la baraja", 1,
(0, 0, 0))
textRect = textSurf.get_rect()
textRect.top = popupSurf.get_height() / 2 - sizeTextoPopUp[1] * 2
textRect.left = popupSurf.get_width() / 2 - sizeTextoPopUp[0] / 2
popupSurf.blit(textSurf, (textRect.left, textRect.top))
sizeTextoPopUp2 = fuenteTextoPopUp.size(
"ELije un número del 1 al {0} y pulsa Intro".format(
len(self.baraja.cartas)))
textSurf2 = fuenteTextoPopUp.render(
"Elije un número del 1 al {0} y pulsa Intro".format(
len(self.baraja.cartas)), 1, (0, 0, 0))
textRect2 = textSurf2.get_rect()
textRect2.top = popupSurf.get_height() / 2 - sizeTextoPopUp2[1]
textRect2.left = popupSurf.get_width() / 2 - sizeTextoPopUp2[0] / 2
popupSurf.blit(textSurf2, (textRect2.left, textRect2.top))
#Imprimimos la superficie que creamos para el pop-up
#en la pantalla
self.screen.blit(popupSurf, popupRect)
#Imprimimos el input de usuario en la pantalla
self.screen.blit(txt_surface, (input_box.x + 5, input_box.y + 5))
# Dibujamos el rectángulo del input
pygame.draw.rect(self.screen, color, input_box, 2)
#Actualizamos la pantalla
pygame.display.flip()
clock.tick(30)
#Ahora traducimos el valor introducido por el usuario a int
n = 0
try:
n = int(text)
except ValueError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Si no es un valor entero válido mostramos la pantalla de error
pantallaError = PantallaError(
"El valor introducido debe estar en el rango [0,{0}]".format(
len(self.baraja.cartas)))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Mostramos la pantalla de error para cualquier otra posible excepción
pantallaError = PantallaError(
"Ocurrió un error al cortar la baraja")
pantallaError.mostrarPantallaError()
sys.exit()
#Cortamos la baraja
self.baraja.cortarBaraja(n)
def animacionBarajar(self):
#Lo primero será barajar la baraja de verdad para dejarla
#en el estado tras barajar
self.baraja.barajar()
k = 0
#Generamos un bucle donde iremos de k = 0 a k =47
#donde k será el índice que la imagen que mostrar en
#cada iteración
while k < 48:
#Escuchamos a los eventos del teclado y ratón
for evento in pygame.event.get():
#Solo respondemos al cierre de la ventana,
#finalizando la ejecución
if evento.type == pygame.QUIT:
sys.exit()
#Como las imágenes se numeran como 01 a 09 y 10 a 47
#tenemos que preparar la variable que contendrá el índice
#para el nombre del fichero
r = ""
if (k < 10):
r = "0{0}".format(k)
else:
r = "{0}".format(k)
#Definimos las variables para el fondo y para la imagen
#de la animación que habrá que mostrar en esta iteración
barajarGIF = None
background = None
try:
#Cargamos la imagen de la animación a mostrar en esta iteración
barajarGIF = pygame.image.load(
Utiles.RUTA_IMAGENES_ANIMACION_BARAJAR.format(
r)).convert()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Como siempre capturamos el error de fichero no encontrado
#y mostramos la pantalla de error
pantallaError = PantallaError(
r"Falta el fichero " +
Utiles.RUTA_IMAGENES_ANIMACION_BARAJAR.format(r))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Como siempre capturamos cualquier excepción que se genere
#y mostramos la pantalla de error
pantallaError = PantallaError(
"Ocurrió un problema con la animación de barajar")
pantallaError.mostrarPantallaError()
sys.exit()
try:
#Ahora cargamos la imagen del fondo
background = pygame.image.load(
Utiles.RUTA_FONDO_MESA_JUEGO).convert()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Capturamos la excepción de fichero no encontrado
#y mostramos la pantalla de error
pantallaError = PantallaError(r"Falta el fichero {0}".format(
Utiles.RUTA_FONDO_MESA_JUEGO))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Capturamos cualquier otra excepción y mostramos
#la pantalla de error
pantallaError = PantallaError(
r"Ocurrió un error en la mesa de juego")
pantallaError.mostrarPantallaError()
sys.exit()
#Definimos el rectángulo en que impriremos la imagen del fondo
background_rect = background.get_rect()
#Mostramos la imagen del fondo en la pantalla usando screen.blit
self.screen.blit(background, background_rect)
#Usando screen.blit mostramos la imagen que mostrar en esta iteración
#de la animación de barajar
self.screen.blit(
barajarGIF,
(self.screen.get_width() / 2 - barajarGIF.get_rect()[2] / 2,
self.screen.get_height() / 2 - barajarGIF.get_rect()[3] / 2))
#Definimos la fuente que usaremos para imprimr un texto
fuenteTextoBarajando = pygame.font.SysFont(self.TIPO_FUENTE_1, 40)
sizeTextoBarajando = fuenteTextoBarajando.size("Barajando")
#Generamos el texto
textBarajando = fuenteTextoBarajando.render(
"Barajando", 1, (0, 0, 0))
textRectBarajando = textBarajando.get_rect()
textRectBarajando.top = self.screen.get_height(
) / 2 - barajarGIF.get_rect()[3] / 2 - 10 - sizeTextoBarajando[1]
textRectBarajando.left = self.screen.get_width(
) / 2 - sizeTextoBarajando[0] / 2
#Imprimimos el texto por pantalla
self.screen.blit(textBarajando,
(textRectBarajando.left, textRectBarajando.top))
#Actualizamos la pantalla
pygame.display.flip()
#Avanzamos el bucle
k += 1
#Esperamos un poco antes de avanzar
time.sleep(0.005)
def PantallaResultado(self,resultado):
#Definimos la variable background que representará el
#fondo de la pantalla
background = None
try:
#Dentro de este try, cargamos la imagen para el fondo
#de esta pantalla usando el método load del módulo image
background = pygame.image.load(Utiles.RUTA_FONDO_MESA_JUEGO).convert()
except FileNotFoundError as e:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos la posible excepcíón que generará el caso
#en que no podramos encontrar la imagen
#En tal caso mostramos la pantalla de error
pantallaError = PantallaError(r"Falta el fichero {0}".format(Utiles.RUTA_FONDO_MESA_JUEGO))
pantallaError.mostrarPantallaError()
sys.exit()
except Exception as e1:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e1))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos cualquier otra posible excepción
pantallaError = PantallaError(r"Ocurrió un error en la pantalla de resultado")
pantallaError.mostrarPantallaError()
sys.exit()
#Definimos el rectángulo donde impriremos la imagen
#del fondo
background_rect = background.get_rect()
#Mostramos el fondo por pantalla usando screen.bilt
self.screen.blit(background,background_rect)
i = 0
#Generamos otra estructura try and except para atrapar
#otros posible errores
try:
#Iniciamos las fuentes de pygame
pygame.font.init()
#Definimos la fuente del texto
fuenteMensaje = pygame.font.SysFont(self.FUENTE_TEXTO, self.TAMAÑO_TEXTO)
sizeTextoMensaje = fuenteMensaje.size("Jugador {0}:{1} Ordenador".format(resultado["jugador"],resultado["ordenador"]))
#Generamos el texto con la fuente
textoMensaje = fuenteMensaje.render("Jugador {0}:{1} Ordenador".format(resultado["jugador"],resultado["ordenador"]), False, self.COLOR_TEXTO)
mensaje = ""
ganador = ""
#En la variable mensaje incluiremos un mensaje un otro
#en función de quien haya ganado o si ha habido empate
if resultado["jugador"]>resultado["ordenador"]:
mensaje = "Has ganado la partida"
ganador = "J"
elif resultado["jugador"]<resultado["ordenador"]:
mensaje = "Has perdido la partida"
ganador="O"
else:
mensaje = "Habéis empatado"
ganador = "E"
sizeTextoMensaje2 = fuenteMensaje.size(mensaje)
#Generamos el texto del mensaje diciendo quien ha ganado
textoMensaje2 = fuenteMensaje.render(mensaje, False, self.COLOR_TEXTO)
#Imprimimos en pantalla los mensajes usando screen.blit
self.screen.blit(textoMensaje,(self.screen.get_width()/2-sizeTextoMensaje[0]/2,self.screen.get_height()/2-sizeTextoMensaje[1]))
self.screen.blit(textoMensaje2,(self.screen.get_width()/2-sizeTextoMensaje2[0]/2,self.screen.get_height()/2+sizeTextoMensaje2[1]))
#Actualizamos la pantalla
pygame.display.flip()
#Esperamos algo 5 segundos antes de terminar con esta pantalla
while i<500:
i+=1
#Escuchamos los eventos del teclado y el ratón
for evento in pygame.event.get ():
#Solo respondemos al cierre de la ventana terminado la ejecución
if evento.type == pygame.QUIT:
sys.exit()
#Paramos el hilo 0.01 segundos para que
#tras 500 iteraciones hayamos esperado aproximadamente
#5 segs
time.sleep(0.01)
#Actualizamos el fichero que controla el estado de la baraja para decir que se terminço la partida (y ya de paso añadimos quién ganó)
FicheroBaraja.escribirFichero(FicheroBaraja.RUTA,mensaje+"\r\n","Partida finalizada\r\n","--------------\r\n")
#Construimos el registro con la información del fin de esta ronda para que se pueda escribir en el fichero csv
datarow= {"T":"P","G":ganador,"CPJ":resultado["jugador"],"CPO":resultado["ordenador"]}
#Lo devolvemos para que así se pueda añadir al csv y así contribuir a las estadísticas
return datarow
except Exception:
#Ante cualquier excepción, primero imprimimos por
#consola un log del error
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("Ha ocurrido la siguiente excepción: {0}".format(e))
print(exc_type, fname, exc_tb.tb_lineno)
#Recogemos cualquier error y mostramos la pantalla de error
pantallaError = PantallaError(r"Error al buscar los resultados")
pantallaError.mostrarPantallaError()
sys.exit()