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()