コード例 #1
0
    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"
コード例 #2
0
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
コード例 #3
0
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
コード例 #4
0
    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"
コード例 #5
0
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
コード例 #6
0
    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"
コード例 #7
0
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)
コード例 #8
0
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)
コード例 #9
0
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)
コード例 #10
0
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
コード例 #11
0
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)
コード例 #12
0
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
コード例 #13
0
    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"
コード例 #14
0
    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
コード例 #15
0
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
コード例 #16
0
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
コード例 #17
0
    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
コード例 #18
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()             
コード例 #19
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()
コード例 #20
0
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()
コード例 #21
0
    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