def __init__(self, x, y, imagen, callback, activarImagenHover=True):
pygame.sprite.Sprite.__init__(self)
self.activarImagenHover = activarImagenHover
# Asignamos la acción a realizar al hacer click
self.callback = callback
# Cargamos las imágenes
self.imagenNormal = pygame.image.load(
xdg_data_path(imagen + ".png")).convert_alpha()
if self.activarImagenHover:
self.imagenHover = pygame.image.load(
xdg_data_path(imagen + "_sobre.png")).convert_alpha()
#self.imagenActive = pygame.image.load(xdg_data_path(imagen + "_pulsada.png")).convert_alpha()
# Definimos el rectángulo de acción
self.rect = self.imagenNormal.get_rect()
self.rect.x = x
self.rect.y = y
# El estado por defecto es el normal
self.estado = "normal"
def run(team_a, team_b, fast=False, dont_log=False, hidden=False,
number_turns=100,
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/main-layout.xml'),
get_stats=False, cant_draw=False):
"""
Runs a game using the system expert teams given. It calls to libguadalete,
generating the game and parsing the file.
"""
lib = libguadalete.LibGuadalete(team_a[0], team_b[0], number_turns)
try:
out_file, winner = lib.run_game()
except LibFileError as exc:
raise GuadaFileError(exc.msg)
if not fast:
name_team_a = filenames.extract_name_expert_system(team_a[0])
name_team_b = filenames.extract_name_expert_system(team_b[0])
_load_game_from_file(out_file, (name_team_a, team_a[1]),
(name_team_b, team_b[1]), path_piece_def,
xml_file, hidden, cant_draw=cant_draw)
if cant_draw:
winner = _handle_draw(out_file)
res = winner
if get_stats:
res = (winner, stats.get_game_file_stats(out_file))
if dont_log or get_stats:
os.remove(out_file)
return res
def run(team_a,
team_b,
fast=False,
dont_log=False,
hidden=False,
number_turns=100,
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/main-layout.xml'),
get_stats=False,
cant_draw=False,
logNameReference=None):
"""
Runs a game using the system expert teams given. It calls to libguadalete,
generating the game and parsing the file.
"""
# Preparamos el motor con los equipos y el número de turnos
lib = libguadalete.LibGuadalete(team_a[0], team_b[0], number_turns)
try:
# Procesamos el juego, obteniendo el fichero de log y el ganador
out_file, winner = lib.run_game()
except LibFileError as exc:
logging.error("ERROR: %s", exc.msg)
raise GuadaFileError(exc.msg)
# fast indica si queremos ver solo el resultado (fast = True) o la partida
# completa
if not fast:
# Aquí es donde se llama a la función que gestiona el dibujado del juego
_load_game_from_file(out_file,
team_a,
team_b,
path_piece_def,
xml_file,
hidden,
cant_draw=cant_draw)
reason = "normal"
# Si no puede haber empate
if cant_draw:
# Solucionar el empate
entire_game, winner = file_parser.parse_file(out_file)
winner, reason = _handle_draw(entire_game, winner)
# Preparamos la variable de retorno
res = (winner, reason)
if get_stats:
res = (winner, stats.get_game_file_stats(out_file))
if logNameReference != None:
logNameReference[0] = out_file
if dont_log:
os.remove(out_file)
return res
def __init__(self, x, y, imagen, callback):
self.callback = callback
# Cargamos las imágenes
self.imagenNormal = pygame.image.load(xdg_data_path(imagen + ".png")).convert_alpha()
self.imagenToggled = pygame.image.load(xdg_data_path(imagen + "_toggled.png")).convert_alpha()
self.rect = self.imagenNormal.get_rect()
self.rect.x = x
self.rect.y = y
self.estado = "normal"
def run(team_a, team_b, fast=False, dont_log=False, hidden=False,
number_turns=100,
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/main-layout.xml'),
get_stats=False, cant_draw=False, logNameReference = None):
"""
Runs a game using the system expert teams given. It calls to libguadalete,
generating the game and parsing the file.
"""
# Preparamos el motor con los equipos y el número de turnos
lib = libguadalete.LibGuadalete(team_a[0], team_b[0], number_turns)
try:
# Procesamos el juego, obteniendo el fichero de log y el ganador
out_file, winner = lib.run_game()
except LibFileError as exc:
logging.error("ERROR: %s", exc.msg)
raise GuadaFileError(exc.msg)
# fast indica si queremos ver solo el resultado (fast = True) o la partida
# completa
if not fast:
# Aquí es donde se llama a la función que gestiona el dibujado del juego
_load_game_from_file(out_file,
team_a, team_b,
path_piece_def,
xml_file, hidden, cant_draw=cant_draw)
reason = "normal"
# Si no puede haber empate
if cant_draw:
# Solucionar el empate
entire_game, winner = file_parser.parse_file(out_file)
winner,reason = _handle_draw(entire_game, winner)
# Preparamos la variable de retorno
res = (winner, reason)
if get_stats:
res = (winner, stats.get_game_file_stats(out_file))
if logNameReference != None:
logNameReference[0] = out_file
if dont_log:
os.remove(out_file)
return res
def __init__(self, x, y, imagen, callback):
self.callback = callback
# Cargamos las imágenes
self.imagenNormal = pygame.image.load(
xdg_data_path(imagen + ".png")).convert_alpha()
self.imagenToggled = pygame.image.load(
xdg_data_path(imagen + "_toggled.png")).convert_alpha()
self.rect = self.imagenNormal.get_rect()
self.rect.x = x
self.rect.y = y
self.estado = "normal"
def run_from_file(src_file,
team_a=('equipoA', xdg_data_path('images/piece-orange.png')),
team_b=('equipoB',
xdg_data_path('images/piece-violete.png')),
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/alternative-layout.xml')):
"""
Muestra un juego en pantalla directamente desde un fichero de un juego
previamente simulado
"""
name_a, name_b = filenames.extract_names_from_file(src_file)
team_a = (name_a, team_a[1])
team_b = (name_b, team_b[1])
_load_game_from_file(src_file, team_a, team_b, path_piece_def, xml_file)
def dividir_ruta(rutaReglas, usandoFormacion=False):
defPathRules = xdg_data_path('teams/rules/')
if usandoFormacion:
defPathRules = xdg_data_path('teams/formations/')
# Le quitamos a la ruta del fichero de reglas la parte común
rutaReglas = rutaReglas[len(defPathRules):]
# Leemos el subdirectorio (si hay alguno)
subdirectorio, fichero = path.split(rutaReglas)
# Despejamos el nombre, quitando la extensión y el prefijo "reglas"
nombreDespejado = quitar_prefijo(path.splitext(fichero)[0])
return (subdirectorio, nombreDespejado)
def dividir_ruta(rutaReglas, usandoFormacion = False):
defPathRules = xdg_data_path('teams/rules/')
if usandoFormacion:
defPathRules = xdg_data_path('teams/formations/')
# Le quitamos a la ruta del fichero de reglas la parte común
rutaReglas = rutaReglas[len(defPathRules):]
# Leemos el subdirectorio (si hay alguno)
subdirectorio, fichero = path.split(rutaReglas)
# Despejamos el nombre, quitando la extensión y el prefijo "reglas"
nombreDespejado = quitar_prefijo(path.splitext(fichero)[0])
return (subdirectorio, nombreDespejado)
def run_from_file(src_file,
team_a=('equipoA',
xdg_data_path('images/piece-orange.png')),
team_b=('equipoB',
xdg_data_path('images/piece-violete.png')),
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/alternative-layout.xml')):
"""
Run a game directly from a file, not simulating a game.
"""
name_a, name_b = filenames.extract_names_from_file(src_file)
team_a = (name_a, team_a[1])
team_b = (name_b, team_b[1])
winner = _load_game_from_file(src_file, team_a, team_b,
path_piece_def, xml_file)
return winner
def run_from_file(src_file,
team_a=('equipoA', xdg_data_path('images/piece-orange.png')),
team_b=('equipoB', xdg_data_path('images/piece-violete.png')),
path_piece_def=xdg_data_path('images/piece-default.png'),
xml_file=xdg_data_path('layouts/alternative-layout.xml')):
"""
Muestra un juego en pantalla directamente desde un fichero de un juego
previamente simulado
"""
name_a, name_b = filenames.extract_names_from_file(src_file)
team_a = (name_a, team_a[1])
team_b = (name_b, team_b[1])
_load_game_from_file(src_file,
team_a, team_b,
path_piece_def, xml_file)
def parsear_obstaculos():
obstaculos = []
try:
fichero = open(xdg_data_path("obstaculos"))
for linea in fichero:
m = re.search(r"\(([1-8]),([1-8])\)", linea)
if m:
obstaculos.append((int(m.group(1)), int(m.group(2))))
except:
pass
return obstaculos
def __init__(self, x, y, imagen, callback, activarImagenHover = True):
pygame.sprite.Sprite.__init__(self)
self.activarImagenHover = activarImagenHover
# Asignamos la acción a realizar al hacer click
self.callback = callback
# Cargamos las imágenes
self.imagenNormal = pygame.image.load(xdg_data_path(imagen + ".png")).convert_alpha()
if self.activarImagenHover:
self.imagenHover = pygame.image.load(xdg_data_path(imagen + "_sobre.png")).convert_alpha()
#self.imagenActive = pygame.image.load(xdg_data_path(imagen + "_pulsada.png")).convert_alpha()
# Definimos el rectángulo de acción
self.rect = self.imagenNormal.get_rect()
self.rect.x = x
self.rect.y = y
# El estado por defecto es el normal
self.estado = "normal"
def actualizarSuperficie(self, modificarCoordenadas = True):
# Dependiendo del equipo elegiremos la pieza de un color u otro
if self.equipo == 'A':
imagenFicha = pygame.image.load(xdg_data_path("images/piece-orange.png"))
else:
imagenFicha = pygame.image.load(xdg_data_path("images/piece-violete.png"))
# Cargamos la fuente para el rótulo con el valor de la ficha
fuente = pygame.font.Font(xdg_data_path("fonts/LiberationMono-Bold.ttf"), 32)
# Pintamos el rótulo en una superficie nueva
if self.descubierta:
imagenTexto = fuente.render("%d" % self.valor, 1, (255, 255, 255))
else:
imagenTexto = fuente.render("[%d]" % self.valor, 1, (255, 255, 255))
# Bliteamos la superficie del texto en la superficie de la ficha original
if self.descubierta:
imagenFicha.blit(imagenTexto, (19,11))
elif not self.ocultarInicialmente:
imagenFicha.blit(imagenTexto, (0,11))
# Asignamos a la imagen de la ficha la superficie compuesta convertida
self.image = imagenFicha.convert()
if modificarCoordenadas:
# El rectángulo inicialmente será el de la imagen...
self.rect = self.image.get_rect()
# ... pero con las coordenadas acordes a la posición de la ficha en el tablero
self.posicionDestino = self.toGlobal()
self.posicionActual = self.posicionDestino
self.rect.x, self.rect.y = self.posicionActual
self.opacidad = 255
def devolverFormacionAsociada(rutaReglas, noPrefijo = False):
# Quitamos lo de 'file://' del principio
if "file://" in rutaReglas:
rutaReglas = rutaReglas[7:]
subdirectorio, nombreDespejado = dividir_ruta(rutaReglas)
# Formamos el nuevo nombre
nombreFormacion = "equipo" + nombreDespejado + ".form"
# Formamos la ruta completa
rutaFormacion = path.join(xdg_data_path('teams/formations/'), subdirectorio, nombreFormacion)
if not path.isfile(rutaFormacion):
return ""
prefijo = "file://"
if noPrefijo:
prefijo = ""
return prefijo + rutaFormacion
def devolverFormacionAsociada(rutaReglas, noPrefijo=False):
# Quitamos lo de 'file://' del principio
if "file://" in rutaReglas:
rutaReglas = rutaReglas[7:]
subdirectorio, nombreDespejado = dividir_ruta(rutaReglas)
# Formamos el nuevo nombre
nombreFormacion = "equipo" + nombreDespejado + ".form"
# Formamos la ruta completa
rutaFormacion = path.join(xdg_data_path('teams/formations/'),
subdirectorio, nombreFormacion)
if not path.isfile(rutaFormacion):
return ""
prefijo = "file://"
if noPrefijo:
prefijo = ""
return prefijo + rutaFormacion
def run(self):
logging.info("## INICIANDO Pintado de partida")
# Inicializando pygame..."
pygame.init()
if self.musica:
_music_path = xdg_data_path('music/walking_on_old_stones.ogg')
pygame.mixer.music.load(_music_path)
pygame.mixer.music.play()
tamanoVentana = (760,560)
# Estableciendo el modo de pantalla..."
self.pantalla = pygame.display.set_mode(tamanoVentana)
# Estableciendo el título de la ventana..."
pygame.display.set_caption("Reproduciendo partida")
# Cargando imagen de fondo..."
self.imagenFondoTemp = pygame.image.load(xdg_data_path("images/fondo.png"))
# Convirtiendo la imagen de fondo al formato adecuado..."
self.imagenFondo = self.imagenFondoTemp.convert()
# Parseando el estado inicial..."
organizacionInicial = self.parseador.esteTurno()
# Cargamos la imagen de los marcos con los nombres..."
imagenMarco = pygame.image.load(xdg_data_path("images/marco.png"))
imagenMarco = imagenMarco.convert()
# Posición inicial de los marcos con los nombres de los equipos
self.posMarcoSuperior = 10
self.posMarcoInferior = 190
# Bliteamos el marco en el fondo
self.imagenFondo.blit(imagenMarco, (510, self.posMarcoSuperior))
self.imagenFondo.blit(imagenMarco, (510, self.posMarcoInferior))
self.obstaculos = parsear_obstaculos()
self.imagenObstaculo = pygame.image.load(xdg_data_path("images/stone.png"))
self.imagenObstaculo = self.imagenObstaculo.convert()
# Cargamos la fuente para el rótulo con el valor de la ficha
fuenteEquipos = pygame.font.Font(xdg_data_path("fonts/zektonbi.ttf"), 18)
# Renderizamos los textos en superficies
textoEquipoA = fuenteEquipos.render(self.name_team_a[:16], 1, (255,255,255))
sombraTextoEquipoA = fuenteEquipos.render(self.name_team_a[:16], 1, (0,0,0))
self.imagenEquipoA = pygame.transform.scale(pygame.image.load(self.team_a[1]), (30,30))
textoEquipoB = fuenteEquipos.render(self.name_team_b[:16], 1, (255,255,255))
sombraTextoEquipoB = fuenteEquipos.render(self.name_team_b[:16], 1, (0,0,0))
self.imagenEquipoB = pygame.transform.scale(pygame.image.load(self.team_b[1]), (30,30))
# Bliteamos las superficies de los marcadores
self.imagenFondo.blit(self.imagenEquipoA, (515, self.posMarcoSuperior + 9))
self.imagenFondo.blit(sombraTextoEquipoA, (552, self.posMarcoSuperior + 11))
self.imagenFondo.blit(textoEquipoA, (550, self.posMarcoSuperior + 9))
self.imagenFondo.blit(self.imagenEquipoB, (515, self.posMarcoInferior + 9))
self.imagenFondo.blit(sombraTextoEquipoB, (552, self.posMarcoInferior + 11))
self.imagenFondo.blit(textoEquipoB, (550, self.posMarcoInferior + 9))
posBloqueTurnoActual = 367
self.imagenFondo.blit(imagenMarco, (510, posBloqueTurnoActual))
posBloqueTurnosRestantes = 420
self.imagenFondo.blit(imagenMarco, (510, posBloqueTurnosRestantes))
# Cargamos la fuente para el texto de las fichas muertas
self.fuenteFichasMuertas = pygame.font.Font(xdg_data_path("fonts/LiberationMono-Bold.ttf"), 19)
# Pintamos las fichas blancas del fondo
fichaBlanca = pygame.image.load(xdg_data_path("images/piece-default.png"))
fichaBlanca = fichaBlanca.convert()
for i in range(8):
for j in range (8):
self.imagenFondo.blit(fichaBlanca, (10 + 60 * i, 10 + 60 * j))
# Cargando las fichas iniciales..."
for keyFicha in organizacionInicial.keys():
ficha = organizacionInicial[keyFicha];
self.fichas[keyFicha] = Ficha(ficha[0], ficha[1], ficha[2],
ficha[3], ficha[4], ficha[5], self.hidden)
# Pintamos los botones
botonesInterfaz = []
botonesInterfaz.append(Boton(700, 500, "images/salir", self.callSalir))
botonesInterfaz.append(Boton(120, 500, "images/flecha_izquierda2", self.callRetrocederInicio))
botonesInterfaz.append(Boton(190, 500, "images/flecha_izquierda1", self.callRetrocederTurno))
botonesInterfaz.append(Boton(260, 500, "images/flecha_derecha1", self.callAvanzarTurno))
botonesInterfaz.append(Boton(330, 500, "images/flecha_derecha2", self.callAvanzarFinal))
botonesInterfaz.append(Boton(630, 500, "images/btnAbortar", self.callAbortar, False))
botonesInterfaz.append(Interruptor(560, 500, "images/btnAvanceAutomatico", self.callToggleAvanceAutomatico))
self.salir = False
self.avanceAutomatico = False
# Leemos del fichero de configuración la velocidad del avance automático
config_vars = configure.load_configuration()
self.intervaloAvanceAutomatico = config_vars['auto_interval_time']
# Comienza el game loop
while not self.salir and not controlPartida.flagCancelarCampeonato:
# Comprobación del avance automático
if self.avanceAutomatico:
# Si el tiempo que ha pasado desde el último avance supera el intervalo
if pygame.time.get_ticks() - self.ultimoAvance > self.intervaloAvanceAutomatico:
# Avanzamos el turno
self.callAvanzarTurno()
# Actualizamos la variable con el tiempo del último avance
self.ultimoAvance = pygame.time.get_ticks()
# Gestión de eventos
for eventos in pygame.event.get():
# Si se ha pulsado ALT+F4 o el botón de cerrar ventana
if eventos.type == QUIT:
# Activamos el flag de salir
self.salir = True
# Cuando se pulsa el botón el ratón
elif eventos.type == MOUSEBUTTONDOWN:
# Informamos a cada botón de la interfaz
for btn in botonesInterfaz:
btn.informarClick(eventos.pos)
# Cuando se mueve el ratón
elif eventos.type == MOUSEMOTION:
# Informamos a cada botón de la interfaz
for btn in botonesInterfaz:
btn.informarHover(eventos.pos)
# Podemos avanzar turno con la flecha derecha del teclado
elif eventos.type == KEYDOWN and eventos.key == 275:
self.callAvanzarTurno()
# También podemos retroceder turno con las flechas del teclado
elif eventos.type == KEYDOWN and eventos.key == 276:
self.callRetrocederTurno()
# Pintamos el fondo
self.pantalla.blit(self.imagenFondo, (0, 0))
# Pintamos las fichas
for keyFicha in self.fichas:
self.fichas[keyFicha].pintar(self.pantalla)
for obs in self.obstaculos:
self.pantalla.blit(self.imagenObstaculo, (float(10 + (obs[0] - 1) * 60),
float(10 + (obs[1] - 1) * 60)))
# Pintamos los botones
for btn in botonesInterfaz:
btn.pintar(self.pantalla)
# Pintamos las fichas muertas
self.pintarFichasMuertas()
self.pantalla.blit(fuenteEquipos.render("Turno actual: %d" % self.parseador.getNumTurnoActual(), 1, (0,0,0)), (517, posBloqueTurnoActual + 11))
self.pantalla.blit(fuenteEquipos.render("Turno actual: %d" % self.parseador.getNumTurnoActual(), 1, (255,255,255)), (515, posBloqueTurnoActual + 9))
self.pantalla.blit(fuenteEquipos.render("Turnos restantes: %d" % (self.parseador.getNumTurnoMax() - self.parseador.getNumTurnoActual()), 1, (0,0,0)), (517, posBloqueTurnosRestantes + 11))
self.pantalla.blit(fuenteEquipos.render("Turnos restantes: %d" % (self.parseador.getNumTurnoMax() - self.parseador.getNumTurnoActual()), 1, (255,255,255)), (515, posBloqueTurnosRestantes + 9))
# Volcamos la pantalla a la gráfica
pygame.display.flip()
##############################
# GESTIÓN DE LOS FPS
# Cogemos los ticks actuales
ticksActual = pygame.time.get_ticks()
espera = self.intervalo - (ticksActual - self.ticksAnterior)
if espera > 0:
# Esperamos el tiempo necesario para mantener los FPS
pygame.time.delay(int(espera))
# Actualizamos los ticks anteriores
self.ticksAnterior = ticksActual
# Fin del game loop"
# Cortamos la música
pygame.mixer.music.stop()
# Cerramos el subsistema gráfica (no es necesario)
pygame.display.quit()
logging.info("## FINALIZADO Pintado de partida")
return 0
def probar_equipo(equipo):
eqBase = (os.path.join(xdg_data_path('teams/rules'), "reglasA.clp"),
os.path.join(xdg_data_path('teams/formations'), "equipoA.form"))
motor = libguadalete.LibGuadalete(equipo, eqBase, 50)
motor.run_game()
def probar_equipo(equipo):
eqBase = (os.path.join(xdg_data_path('teams/rules'), "reglasA.clp"),
os.path.join(xdg_data_path('teams/formations'), "equipoA.form"))
motor = libguadalete.LibGuadalete(equipo, eqBase, 50)
motor.run_game()
def _load_game_from_file(src_file, team_a, team_b, path_piece_def, xml_file,
hidden=False, cant_draw=False):
entire_game, winner = file_parser.parse_file(src_file)
if cant_draw:
winner = _handle_draw(src_file)
if winner == 0:
print u'Empate'
elif winner == 1:
print u'Ganó %s' % team_a[0]
else:
print u'Ganó %s' % team_b[0]
music = False
if configure.load_configuration()['music_active'] == '1':
music = True
pygame.init()
xml_layout = layout.Layout(xml_file)
screen = pygame.display.set_mode(xml_layout.get_window_size())
pygame.display.set_caption(xml_layout.get_window_title())
if music:
_music_path = xdg_data_path('music/walking_on_old_stones.ogg')
mixer.music.load(_music_path)
mixer.music.play()
res_game = game.Game(entire_game, team_a[1],
team_b[1], path_piece_def, hidden=hidden)
img_board = res_game.draw_board().convert()
xml_layout.init((team_a[1], team_a[0]), (team_b[1], team_b[0]), img_board)
rects = xml_layout.get_buttons_rects()
pygame.display.set_icon(xml_layout.get_favicon())
screen.blit(xml_layout.get_surface(), (0, 0))
pygame.display.flip()
band_pos = False
clock = pygame.time.Clock()
while True:
clock.tick(50)
for event in pygame.event.get():
if event.type == pygame.QUIT:
if music:
mixer.music.stop()
pygame.display.quit()
show_dialog_result((team_a[0], team_b[0]), winner)
return winner
elif event.type == pygame.KEYDOWN:
if event.key == 275:
surface = next_turn(res_game, xml_layout)
screen.blit(surface, (0, 0))
pygame.display.flip()
if event.key == 276:
surface = previous_turn(res_game, xml_layout)
screen.blit(surface, (0, 0))
pygame.display.flip()
elif event.type == pygame.MOUSEMOTION:
res = get_collision(event.pos, rects)
if res != '':
if band_pos == False:
surface = xml_layout.get_surface((res, 2))
screen.blit(surface, (0, 0))
pygame.display.flip()
band_pos = True
else:
if band_pos == True:
surface = xml_layout.get_surface()
screen.blit(surface, (0, 0))
pygame.display.flip()
band_pos = False
elif event.type == pygame.MOUSEBUTTONUP:
res = get_collision(event.pos, rects)
if event.button == 1 and res != '':
if res == 'button_exit':
if music:
mixer.music.stop()
pygame.display.quit()
show_dialog_result((team_a[0], team_b[0]), winner)
return winner
else:
if res == 'button_left_2':
surface = first_turn(
res_game, xml_layout, (res, 1))
screen.blit(surface, (0, 0))
pygame.display.flip()
elif res == 'button_left_1':
surface = previous_turn(
res_game, xml_layout, (res, 1))
screen.blit(surface, (0, 0))
pygame.display.flip()
elif res == 'button_right_1':
surface = next_turn(
res_game, xml_layout, (res, 1))
screen.blit(surface, (0, 0))
pygame.display.flip()
elif res == 'button_right_2':
surface = last_turn(
res_game, xml_layout, (res, 1))
screen.blit(surface, (0, 0))
pygame.display.flip()
def run(self):
logging.info("## INICIANDO Pintado de partida")
# Inicializando pygame..."
pygame.init()
if self.musica:
_music_path = xdg_data_path("music/walking_on_old_stones.ogg")
pygame.mixer.music.load(_music_path)
pygame.mixer.music.play()
tamanoVentana = (760, 560)
# Estableciendo el modo de pantalla..."
self.pantalla = pygame.display.set_mode(tamanoVentana)
# Estableciendo el título de la ventana..."
pygame.display.set_caption("Reproduciendo partida")
# Cargando imagen de fondo..."
self.imagenFondoTemp = pygame.image.load(xdg_data_path("images/fondo.png"))
# Convirtiendo la imagen de fondo al formato adecuado..."
self.imagenFondo = self.imagenFondoTemp.convert()
# Parseando el estado inicial..."
organizacionInicial = self.parseador.esteTurno()
# Cargamos la imagen de los marcos con los nombres..."
imagenMarco = pygame.image.load(xdg_data_path("images/marco.png"))
imagenMarco = imagenMarco.convert()
# Posición inicial de los marcos con los nombres de los equipos
self.posMarcoSuperior = 10
self.posMarcoInferior = 190
# Bliteamos el marco en el fondo
self.imagenFondo.blit(imagenMarco, (510, self.posMarcoSuperior))
self.imagenFondo.blit(imagenMarco, (510, self.posMarcoInferior))
self.obstaculos = parsear_obstaculos()
self.imagenObstaculo = pygame.image.load(xdg_data_path("images/stone.png"))
self.imagenObstaculo = self.imagenObstaculo.convert()
# Cargamos la fuente para el rótulo con el valor de la ficha
fuenteEquipos = pygame.font.Font(xdg_data_path("fonts/zektonbi.ttf"), 18)
# Renderizamos los textos en superficies
textoEquipoA = fuenteEquipos.render(self.name_team_a[:16], 1, (255, 255, 255))
sombraTextoEquipoA = fuenteEquipos.render(self.name_team_a[:16], 1, (0, 0, 0))
self.imagenEquipoA = pygame.transform.scale(pygame.image.load(self.team_a[1]), (30, 30))
textoEquipoB = fuenteEquipos.render(self.name_team_b[:16], 1, (255, 255, 255))
sombraTextoEquipoB = fuenteEquipos.render(self.name_team_b[:16], 1, (0, 0, 0))
self.imagenEquipoB = pygame.transform.scale(pygame.image.load(self.team_b[1]), (30, 30))
# Bliteamos las superficies de los marcadores
self.imagenFondo.blit(self.imagenEquipoA, (515, self.posMarcoSuperior + 9))
self.imagenFondo.blit(sombraTextoEquipoA, (552, self.posMarcoSuperior + 11))
self.imagenFondo.blit(textoEquipoA, (550, self.posMarcoSuperior + 9))
self.imagenFondo.blit(self.imagenEquipoB, (515, self.posMarcoInferior + 9))
self.imagenFondo.blit(sombraTextoEquipoB, (552, self.posMarcoInferior + 11))
self.imagenFondo.blit(textoEquipoB, (550, self.posMarcoInferior + 9))
posBloqueTurnoActual = 367
self.imagenFondo.blit(imagenMarco, (510, posBloqueTurnoActual))
posBloqueTurnosRestantes = 420
self.imagenFondo.blit(imagenMarco, (510, posBloqueTurnosRestantes))
# Cargamos la fuente para el texto de las fichas muertas
self.fuenteFichasMuertas = pygame.font.Font(xdg_data_path("fonts/LiberationMono-Bold.ttf"), 19)
# Pintamos las fichas blancas del fondo
fichaBlanca = pygame.image.load(xdg_data_path("images/piece-default.png"))
fichaBlanca = fichaBlanca.convert()
for i in range(8):
for j in range(8):
self.imagenFondo.blit(fichaBlanca, (10 + 60 * i, 10 + 60 * j))
# Cargando las fichas iniciales..."
for keyFicha in organizacionInicial.keys():
ficha = organizacionInicial[keyFicha]
self.fichas[keyFicha] = Ficha(ficha[0], ficha[1], ficha[2], ficha[3], ficha[4], ficha[5], self.hidden)
# Pintamos los botones
botonesInterfaz = []
botonesInterfaz.append(Boton(700, 500, "images/salir", self.callSalir))
botonesInterfaz.append(Boton(120, 500, "images/flecha_izquierda2", self.callRetrocederInicio))
botonesInterfaz.append(Boton(190, 500, "images/flecha_izquierda1", self.callRetrocederTurno))
botonesInterfaz.append(Boton(260, 500, "images/flecha_derecha1", self.callAvanzarTurno))
botonesInterfaz.append(Boton(330, 500, "images/flecha_derecha2", self.callAvanzarFinal))
botonesInterfaz.append(Boton(630, 500, "images/btnAbortar", self.callAbortar, False))
botonesInterfaz.append(Interruptor(560, 500, "images/btnAvanceAutomatico", self.callToggleAvanceAutomatico))
self.salir = False
self.avanceAutomatico = False
# Leemos del fichero de configuración la velocidad del avance automático
config_vars = configure.load_configuration()
self.intervaloAvanceAutomatico = config_vars["auto_interval_time"]
# Comienza el game loop
while not self.salir and not controlPartida.flagCancelarCampeonato:
# Comprobación del avance automático
if self.avanceAutomatico:
# Si el tiempo que ha pasado desde el último avance supera el intervalo
if pygame.time.get_ticks() - self.ultimoAvance > self.intervaloAvanceAutomatico:
# Avanzamos el turno
self.callAvanzarTurno()
# Actualizamos la variable con el tiempo del último avance
self.ultimoAvance = pygame.time.get_ticks()
# Gestión de eventos
for eventos in pygame.event.get():
# Si se ha pulsado ALT+F4 o el botón de cerrar ventana
if eventos.type == QUIT:
# Activamos el flag de salir
self.salir = True
# Cuando se pulsa el botón el ratón
elif eventos.type == MOUSEBUTTONDOWN:
# Informamos a cada botón de la interfaz
for btn in botonesInterfaz:
btn.informarClick(eventos.pos)
# Cuando se mueve el ratón
elif eventos.type == MOUSEMOTION:
# Informamos a cada botón de la interfaz
for btn in botonesInterfaz:
btn.informarHover(eventos.pos)
# Podemos avanzar turno con la flecha derecha del teclado
elif eventos.type == KEYDOWN and eventos.key == 275:
self.callAvanzarTurno()
# También podemos retroceder turno con las flechas del teclado
elif eventos.type == KEYDOWN and eventos.key == 276:
self.callRetrocederTurno()
# Pintamos el fondo
self.pantalla.blit(self.imagenFondo, (0, 0))
# Pintamos las fichas
for keyFicha in self.fichas:
self.fichas[keyFicha].pintar(self.pantalla)
for obs in self.obstaculos:
self.pantalla.blit(self.imagenObstaculo, (float(10 + (obs[0] - 1) * 60), float(10 + (obs[1] - 1) * 60)))
# Pintamos los botones
for btn in botonesInterfaz:
btn.pintar(self.pantalla)
# Pintamos las fichas muertas
self.pintarFichasMuertas()
self.pantalla.blit(
fuenteEquipos.render("Turno actual: %d" % self.parseador.getNumTurnoActual(), 1, (0, 0, 0)),
(517, posBloqueTurnoActual + 11),
)
self.pantalla.blit(
fuenteEquipos.render("Turno actual: %d" % self.parseador.getNumTurnoActual(), 1, (255, 255, 255)),
(515, posBloqueTurnoActual + 9),
)
self.pantalla.blit(
fuenteEquipos.render(
"Turnos restantes: %d" % (self.parseador.getNumTurnoMax() - self.parseador.getNumTurnoActual()),
1,
(0, 0, 0),
),
(517, posBloqueTurnosRestantes + 11),
)
self.pantalla.blit(
fuenteEquipos.render(
"Turnos restantes: %d" % (self.parseador.getNumTurnoMax() - self.parseador.getNumTurnoActual()),
1,
(255, 255, 255),
),
(515, posBloqueTurnosRestantes + 9),
)
# Volcamos la pantalla a la gráfica
pygame.display.flip()
##############################
# GESTIÓN DE LOS FPS
# Cogemos los ticks actuales
ticksActual = pygame.time.get_ticks()
espera = self.intervalo - (ticksActual - self.ticksAnterior)
if espera > 0:
# Esperamos el tiempo necesario para mantener los FPS
pygame.time.delay(int(espera))
# Actualizamos los ticks anteriores
self.ticksAnterior = ticksActual
# Fin del game loop"
# Cortamos la música
pygame.mixer.music.stop()
# Cerramos el subsistema gráfica (no es necesario)
pygame.display.quit()
logging.info("## FINALIZADO Pintado de partida")
return 0