def __init__(self, game, game_control, path_xml):
     '''
     @brief Constructor
     
     @param game referencia a Game
     @param game_control referencia al GameControl que pertenece
     @param path_xml Archivo xml con la configuración
     '''
     basicmenu.BasicMenu.__init__(self, game)
     
     self.game_control = game_control
     
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     #Parseamos la configuración basica
     self.parser_basic_info(parse)
     
     screen = pygame.display.get_surface()
     #Obtenemos la superficie transparente que será el fondo del menú
     self.layer = pygame.Surface((screen.get_width(), screen.get_height()))
     self.layer.set_alpha(125)
     
     #Obtenemos el centro de la pantalla
     center_screen = (screen.get_width() / 2, screen.get_height() / 2)
     
     #Asigamos la posición de dibujado de la pantalla que será el centro
     self.rect_background = self.background.get_rect()
     self.rect_background.centerx = center_screen[0]
     self.rect_background.centery = center_screen[1]
Exemple #2
0
    def __init__(self, game, game_control, path_xml):
        '''
        @brief Constructor
        
        @param game referencia a Game
        @param game_control referencia al GameControl que pertenece
        @param path_xml Archivo xml con la configuración
        '''
        basicmenu.BasicMenu.__init__(self, game)

        self.game_control = game_control

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Parseamos la configuración basica
        self.parser_basic_info(parse)

        screen = pygame.display.get_surface()
        #Obtenemos la superficie transparente que será el fondo del menú
        self.layer = pygame.Surface((screen.get_width(), screen.get_height()))
        self.layer.set_alpha(125)

        #Obtenemos el centro de la pantalla
        center_screen = (screen.get_width() / 2, screen.get_height() / 2)

        #Asigamos la posición de dibujado de la pantalla que será el centro
        self.rect_background = self.background.get_rect()
        self.rect_background.centerx = center_screen[0]
        self.rect_background.centery = center_screen[1]
Exemple #3
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = None
     
     ######PRUEBA MODULO PLAYER CAR##########
     
     self.car = playercar.PlayerCar("juego", 'coche_prueba.xml', 400, 300, 180)
Exemple #4
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     os.environ["SDL_VIDEO_CENTERED"] = "1"
     
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
         
     pygame.mouse.set_visible(False)
     pygame.display.set_icon(self.icon)
     
     self.clock = pygame.time.Clock()
     self.font = resource.get_font('cheesebu', 30)
     keyboard.update()
     
     ######PRUEBA MODULO GAME CONTROL##########
     self.__actual_state = gamecontrol.GameControl(self, 'circuits/circuit1-beach.tmx')
Exemple #5
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = None
     
     self.button = button.Button("menu/mainoption1.xml", "Prueba", 400, 300, 'cheesebu', True)
     self.button2 = button.Button("menu/mainoption2.xml", "Prueba2lslsls", 400, 365, 'cheesebu', False)
     self.button3 = button.Button("menu/mainoption1.xml", "Prueba3", 400, 405, 'cheesebu', True)
Exemple #6
0
    def __init__(self, game_control, xml_path, x, y):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param xml_path Ruta del archibo xml con la configuración
        @param x posición en el eje x
        @param y posición en el eje y
        '''
        gameobject.GameObject.__init__(self, game_control)

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_path))
        self.parser_basic_info(parser)
        
        #Establecemos posiciones
        self.x = x
        self.y = y
        self.rect.x = x
        self.rect.y = y
        
        #Creamos el sistema de particulas, para cuando colisionemos con la caja
        self.particles = particle.SystemParticle(self.game_control, 
                                                self.rect.centerx, 
                                                self.rect.centery, 
                                                ['particle'], 25, 1, 5, 
                                                100, 0.5)

        #Establecemos las funciones a tratar según el estado
        self.states = {gameobject.NORMAL: self.__normal_state,
                    gameobject.EXPLOSION: self.__explosion_state
                    }
                    
        self.update_image()
Exemple #7
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = None
     
     ###########PRUEBA DE CIRCUIT###########
     
     self.circuit = circuit.Circuit(None, 'mapa1.tmx')
Exemple #8
0
    def __init__(self, father, xml_path):

        basicmenu.BasicMenu.__init__(self, father)

        parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
        self.parser_basic_info(parse)

        self.player_name = None
        self.player_image = None
        self.player_position = None
        self.final_message1 = None
        self.final_message2 = None
        self.font2 = resource.get_font('cheesebu', 45)
        self.box = resource.get_image('championship_box')
        self.final_text = self.font2.render('Campeonato completado', True,
                                            (0, 0, 0))
        self.messages1 = {
            1: "Muy bien hecho,",
            2: "Segundo puesto,",
            3: "Tercer puesto,",
            4: "Cuarto puesto"
        }
        self.messages2 = {
            1: u"eres el Campeón",
            2: u"no está nada mal",
            3: u"puedes hacerlo mejor",
            4: u"debes mejorar mucho"
        }
Exemple #9
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__exit = False
     self.__actual_state = None
     
     ## A partir de aqui las variables no pertenecen a la clase game
     ## Si no para realizar las pruebas necesarias de la clase animation
     
     self.granny = resource.get_sprite('granny')
     self.walk = animation.Animation("0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30", 1)
     self.jump = animation.Animation("49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64", 1)
     self.attack =  animation.Animation("64,65,67,68,69,70,71,72,73,74,75,76,77,78,79,80", 1)
     self.actual_animation = self.walk
Exemple #10
0
    def __init__(self, game_control, xml_path, x, y):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param xml_path Ruta del archibo xml con la configuración
        @param x posición en el eje x
        @param y posición en el eje y
        '''
        gameobject.GameObject.__init__(self, game_control)

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_path))
        self.parser_basic_info(parser)

        #Establecemos posiciones
        self.x = x
        self.y = y
        self.rect.x = x
        self.rect.y = y

        #Creamos el sistema de particulas, para cuando colisionemos con la caja
        self.particles = particle.SystemParticle(self.game_control,
                                                 self.rect.centerx,
                                                 self.rect.centery,
                                                 ['particle'], 25, 1, 5, 100,
                                                 0.5)

        #Establecemos las funciones a tratar según el estado
        self.states = {
            gameobject.NORMAL: self.__normal_state,
            gameobject.EXPLOSION: self.__explosion_state
        }

        self.update_image()
Exemple #11
0
 def __init__(self, game_control, xml_file, x, y, angle = 0):
     '''
     Obtiene como parametro la referencia a GameControl al que pertenece
     el objeto.
     Define las principales variables.
     '''
     gameobject.GameObject.__init__(self, game_control)
     self.max_speed = None
     self.actual_speed = 0
     self.min_speed = None
     #self.__angle_rotation = None
     self.actual_angle = 0
     self.rotation_angle = None
     self.aceleration = None
     self.desaceleration = None
     self.break_force = None
     
     parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
     self.parser_car_info(parser)
     self.parser_basic_info(parser)
     
     self.x = x
     self.y = y
     
     if angle == 0:
         self.dx = 0
         self.dy = 0
     else:
         self.actual_angle = angle
         self.dx = cos(angle) * self.actual_speed
         self.dy = sin(angle) * self.actual_speed
         
     self.update_position()
     self.update_image()
Exemple #12
0
    def __init__(self, game, path_xml):
        """
        @brief Constructor
        
        @param game Referencia a game
        @param path_xml Ruta del archivo xml con las características del menú
        """
        basicmenu.BasicMenu.__init__(self, game)

        # Cambiamos el titulo de la ventana
        pygame.display.set_caption("Zycars: Menú Principal")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        # Le pasamos el archivo parseado a BasicMenu para que obtenga los elementos básicos
        self.parser_basic_info(parse)

        self.tiny_font = resource.get_font("cheesebu", 18)

        self.developer = self.font.render("Desarrollador", True, (0, 0, 0))
        self.developer_name = self.font.render(u"José J. Marente Florín", True, (189, 9, 38))
        self.developer_email = self.tiny_font.render(u"*****@*****.**", True, (189, 9, 38))
        self.developer_web = self.tiny_font.render(u"http://code.google.com/p/zycars/", True, (189, 9, 38))
        self.artist = self.font.render(u"Diseñador gráfico", True, (0, 0, 0))
        self.artist_name = self.font.render(u"David Nieto Rojas", True, (189, 9, 38))
        self.artist_email = self.tiny_font.render("*****@*****.**", True, (189, 9, 38))
        self.artist_web = self.tiny_font.render(u"http://www.deividart.com", True, (189, 9, 38))
        self.music = self.font.render(u"Música", True, (0, 0, 0))
        self.music_name1 = self.font.render(u"Bob Wizman", True, (189, 9, 38))
        self.music_name2 = self.font.render(u"Pirato Ketchup", True, (189, 9, 38))
        self.music_name3 = self.font.render(u"Los Cadaver", True, (189, 9, 38))
        self.music_name4 = self.font.render(u"The Wavers", True, (189, 9, 38))
        self.music_name5 = self.font.render(u"Zamalska", True, (189, 9, 38))
        self.music_web = self.tiny_font.render(u"http://www.jamendo.com", True, (189, 9, 38))
Exemple #13
0
def __initialize_module():
    '''
	Función privada del módulo.
	Es la encargada de parsear un fichero xml que contendrá todos los recursos necesarios 
	en el sistema.
	'''
    parser = xml.dom.minidom.parse(data.get_path_xml('resources.xml'))
    
    for element in parser.getElementsByTagName("image"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        alpha = bool(element.getAttribute("alpha"))
        __images_info[code] = (name, alpha)
    
    for element in parser.getElementsByTagName("sprite"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        rows = int(element.getAttribute("rows"))
        columns = int(element.getAttribute("columns"))
        alpha = bool(element.getAttribute("alpha"))
        __sprites_info[code] = (name, rows, columns, alpha)
    
    for element in parser.getElementsByTagName("sound"):
        code = element.getAttribute("code")
        name = element.getAttribute("name") 
        __sounds_info[code] = name 
    
    for element in parser.getElementsByTagName("font"):
        code = element.getAttribute("code")
        name = element.getAttribute("name") 
        __fonts_info[code] = name 
Exemple #14
0
    def __init__(self, game_control, owner, path_xml, x, y, angle):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param owner GameObject que lanza el item.
        @param path_xml Archivo xml con las características del item
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del item
        '''
        Item.__init__(self, game_control, owner, path_xml, x, y, angle)
        
        self.type = MISSILE
        
        parser = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        root = parser.firstChild
        
        #Inicializamos atributos
        self.aceleration = float(root.getAttribute('aceleration'))
        self.max_speed = float(root.getAttribute('max_speed'))
        self.particle_code = root.getAttribute('particle_code')
        
        #Funciones para cada estado
        self.states = {
            NORMAL: self.__normal_state, 
            RUN: self.__run_state, 
            EXPLOSION: self.__explosion_state, 
            ERASE: self.__erase_state, 
            }
        
        #Creamos el sistema de particulas, para cuando colisionemos con la caja
        self.particles = None
        self.actual_speed = 0.1
Exemple #15
0
 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.mouse.set_visible(False)
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = mainmenu.MainMenu(self, 'menu/mainmenu.xml')  
Exemple #16
0
 def __init__(self, xml_path, actual_value, max_value, x, y):
     
     parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
     
     bar = parse.getElementsByTagName('bar')
     
     image_code = str(bar[0].getAttribute('image_code'))
     self.bar_image = resource.get_image(image_code)
     self.bar_rect = self.bar_image.get_rect()
     self.bar_rect.x = x
     self.bar_rect.y = y
     
     controler = parse.getElementsByTagName('controler')
     
     image_code = str(controler[0].getAttribute('image_code'))
     self.controler_image = resource.get_image(image_code)
     self.controler_rect = self.controler_image.get_rect()
     self.controler_rect.centerx = self.bar_rect.centerx
     self.controler_rect.centery = self.bar_rect.centery
     
     font = parse.getElementsByTagName('font')
     
     font_code = str(font[0].getAttribute('font_code'))
     self.font = resource.get_font(font_code, 30)
     r = int(font[0].getAttribute('r'))
     g = int(font[0].getAttribute('g'))
     b = int(font[0].getAttribute('b'))
     self.color_font = (r,b,g)
     
     self.max_value = max_value
     self.actual_value = actual_value
     self.update_controler()
     self.still_pressed = False
Exemple #17
0
 def __init__(self, game, xml_file):
     
     state.State.__init__(self, game)
     
     parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
     
     self.speed = int(parser.firstChild.getAttribute('speed'))
     self.actual_alpha = 0
     
     self.surface = pygame.Surface((pygame.display.get_surface().get_width(), pygame.display.get_surface().get_height()))
     
     for element in parser.getElementsByTagName('image'):
         
         image_code = str(element.getAttribute('imagecode'))
         x = int(element.getAttribute('x'))
         y = int(element.getAttribute('y'))
         
         image = resource.get_image(image_code)
         
         self.surface.blit(image, (x,y))
         
     self.surface.set_alpha(self.actual_alpha)
     
     self.to_opaque = True
     self.quit = False
Exemple #18
0
 def __init__(self, game, path_xml):
     basicmenu.BasicMenu.__init__(self, game)
     
     pygame.display.set_caption("Zycars: Menú Principal")
     
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     self.parser_basic_info(parse)
Exemple #19
0
    def __init__(self, game, path_xml):
        '''
        @brief Constructor de CharacterMenu
        
        @param game referencia a game
        @param path_xml ruta del archivo xml con los distintos elementos
        '''
        basicmenu.BasicMenu.__init__(self, game)

        #Cambiamos el título de la pantalla
        pygame.display.set_caption("Zycars: Selección de personaje")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Parseamos la informacion básica de los menus
        self.parser_basic_info(parse)

        #Inicializamos car_features para representar las caracteristicas de los personajes
        self.car_features = CarFeatures(500, 350, 'cheesebu',
                                        'slider_controler')

        #Obtenemos el fragmento de los personajes
        characters_parse = parse.getElementsByTagName('characters')[0]
        #Inicializmaos el grupo de opciones
        self.group_option = GroupOption(
            self, characters_parse,
            characters_parse.getAttribute('normal_image'),
            characters_parse.getAttribute('selected_image'), 150, 110, 90)

        self.cars = {}
        first = True

        #Obtenemos las distintas caracterísitcas del personaje
        for element in parse.getElementsByTagName('character'):

            character_name = element.getAttribute('name')
            image_car_code = element.getAttribute('image_car')
            path_xml = element.getAttribute('path_xml')
            rotation = float(element.getAttribute('rotation'))
            aceleration = float(element.getAttribute('aceleration'))
            speed = float(element.getAttribute('speed'))

            self.cars[character_name] = {}
            self.cars[character_name]['image_car'] = resource.get_image(
                image_car_code)
            self.cars[character_name]['name_character'] = resource.get_font(
                'cheesebu', 40).render(character_name, True, (255, 255, 255))
            self.cars[character_name]['path_xml'] = path_xml
            self.cars[character_name]['speed'] = speed
            self.cars[character_name]['aceleration'] = aceleration
            self.cars[character_name]['rotation'] = rotation

            if first:
                self.car_features.update_values(speed, aceleration, rotation)
                first = False

        self.new_pressed = True
Exemple #20
0
    def __init__(self, x, y, path_xml):
        '''
        @brief Constructor
        
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param path_xml Ruta del archivo xml con los tiempos de cada circuito
        '''
        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
        
        #Mapa que contendrá los tiempos de cada circuito
        self.circuits = {}
        
        #Fuente para los textos
        self.font = resource.get_font('cheesebu', 30)
        
        #Superfice con el texto de Mejor Carrera y posición
        self.best_text = self.font.render('Mejor Carrera', True, 
                                        (194, 26, 26))
        self.best_text_position = (x, y)
        
        #Superficie con el texto de Vuelta Rapida y donde se almacenará la posición
        self.fasttest_text = self.font.render(u'Vuelta Rápida', True, 
                                            (194, 26, 26))
        self.fasttest_text_position = None
        
        #Superficie que contendrá los tiempos de los circuitos
        self.best_race = None        
        self.fasttest_lap = None
        
        #Posiciones de cada uno de los tiempos
        self.best_race_position = None
        self.fasttest_lap_position = None

        #Recorremos los circuitos y obtener los tiempos de estos
        for circuit in parse.getElementsByTagName('circuit'):
            
            #Nombre del circuito para añadir al mapa
            name = circuit.getAttribute('name')
            self.circuits[name] = {}
            self.circuits[name]['fasttestlap'] = None
            self.circuits[name]['bestrace'] = None
            
            #Obtenemos el tiempo de la mejor carrera
            bestrace = circuit.getElementsByTagName('bestrace')[0]
            minutes = bestrace.getAttribute('minutes')
            seconds = bestrace.getAttribute('seconds')
            hseconds = bestrace.getAttribute('hseconds')
            self.circuits[name]['bestrace'] = (minutes, seconds, hseconds)
            
            #Obtenemos el tiempo de la mejor vuelta
            fasttestlap = circuit.getElementsByTagName('fasttestlap')[0]
            minutes = fasttestlap.getAttribute('minutes')
            seconds = fasttestlap.getAttribute('seconds')
            hseconds = fasttestlap.getAttribute('hseconds')
            self.circuits[name]['fasttestlap'] = (minutes, seconds, hseconds)
Exemple #21
0
    def __init__(self, xml_path):
        parser = xml.dom.minidom.parse(data.get_path_xml("cursor.xml"))

        root = parser.firstChild
        self.normal_image = resource.get_image(root.getAttribute("normal_image"))
        self.over_image = resource.get_image(root.getAttribute("over_image"))
        self.actual_image = self.normal_image

        self.x = self.y = 0
        self.update()
Exemple #22
0
    def __init__(self, player, path_xml, is_ia=False):
        '''
        @brief Constructor.
        
        @param player Referencia al jugador.
        @param path_xml Ruta del archivo xml
        '''
        self.player = player
        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Obtenemos la imagen de fondo
        image = parse.getElementsByTagName('image')[0]
        image_code = image.getAttribute('image_code')
        self.image = resource.get_image(image_code)

        #Controla los misiles restantes
        self.missile = 0

        #Fuente para mostrar los misiles restantes
        self.font = resource.get_font('cheesebu', 40)

        #Posicion de la imagen de fondo
        self.centerx = int(image.getAttribute('centerx'))
        self.centery = int(image.getAttribute('centery'))
        self.position_image = self.image.get_rect()
        self.position_image.centerx = self.centerx
        self.position_image.centery = self.centery

        #Mapa para los items
        self.items = {}
        self.is_ia = is_ia

        #Recorremos cada uno de los items
        for element in parse.getElementsByTagName('item'):
            code = element.getAttribute('code')

            self.items[code] = {}
            self.items[code]['image'] = None
            self.items[code]['xml'] = None

            #Nos quedamos con su imagen de muestra
            image_code = element.getAttribute('image_code')
            self.items[code]['image'] = resource.get_image(image_code)

            #Y con su archivo xml de configuración
            path_xml = element.getAttribute('path_xml')
            self.items[code]['xml'] = path_xml

        if self.is_ia and 'turbo' in self.items.keys():
            del self.items['turbo']

        #En un principio no tenemos ningun item
        self.actual_item = None

        self.temp_angle = None
Exemple #23
0
 def __init__(self, player, path_xml, is_ia = False):
     '''
     @brief Constructor.
     
     @param player Referencia al jugador.
     @param path_xml Ruta del archivo xml
     '''
     self.player = player
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     #Obtenemos la imagen de fondo
     image = parse.getElementsByTagName('image')[0]
     image_code = image.getAttribute('image_code')
     self.image = resource.get_image(image_code)
     
     #Controla los misiles restantes
     self.missile = 0
     
     #Fuente para mostrar los misiles restantes
     self.font = resource.get_font('cheesebu', 40)
     
     #Posicion de la imagen de fondo
     self.centerx = int(image.getAttribute('centerx'))
     self.centery = int(image.getAttribute('centery'))
     self.position_image = self.image.get_rect()
     self.position_image.centerx = self.centerx
     self.position_image.centery = self.centery
             
     #Mapa para los items
     self.items = {}
     self.is_ia = is_ia
     
     #Recorremos cada uno de los items
     for element in parse.getElementsByTagName('item'):
         code = element.getAttribute('code')
         
         self.items[code] = {}
         self.items[code]['image'] = None
         self.items[code]['xml'] = None
         
         #Nos quedamos con su imagen de muestra
         image_code = element.getAttribute('image_code')
         self.items[code]['image'] = resource.get_image(image_code)
         
         #Y con su archivo xml de configuración
         path_xml = element.getAttribute('path_xml')
         self.items[code]['xml'] = path_xml
     
     if self.is_ia and 'turbo' in self.items.keys():
         del self.items['turbo']
     
     #En un principio no tenemos ningun item
     self.actual_item = None
     
     self.temp_angle = None
Exemple #24
0
    def __init__(self, game_control, xml_file, x, y, angle=0):
        '''
        @brief Constructor.
        
        @param game_control Referencia a Gamecontrol
        @param xml_file Archivo xml con la configuración del objeto
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del objeto, por defecto será 0.
        '''
        gameobject.GameObject.__init__(self, game_control)

        self.break_force = None
        self.avatar = None
        self.racer_image = None
        self.name_character = ""

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
        self.parser_car_info(parser)
        self.parser_basic_info(parser)

        #Definimos la posición del objeto
        self.x = self.old_x = x
        self.y = self.old_y = y

        self.start = None
        self.turbo_state = None
        self.turbo_sound = resource.get_sound('turbo')
        self.turbo_sound.set_volume(config.Config().get_sound_volume())

        self.old_max_speed = self.max_speed

        self.front_line = gameobject.Line(1, 1, 1, 1)
        self.back_line = gameobject.Line(1, 1, 1, 1)

        #Si el angulo es 0, no hacemos nada
        if angle == 0:
            self.dx = 0
            self.dy = 0
        #Si es 0 actualizamos el angulo del coche
        else:
            self.actual_angle = angle
            self.dx = math.cos(angle) * self.actual_speed
            self.dy = math.sin(angle) * self.actual_speed

        #Actualizamos la posicion del coche según su angulo
        self.update_position()
        #Actualizamos la rotación de la imagen del coche
        self.update_image()
Exemple #25
0
    def __init__(self, game_control, xml_file, x, y, angle = 0):
        '''
        @brief Constructor.
        
        @param game_control Referencia a Gamecontrol
        @param xml_file Archivo xml con la configuración del objeto
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del objeto, por defecto será 0.
        '''
        gameobject.GameObject.__init__(self, game_control)
        
        self.break_force = None
        self.avatar = None
        self.racer_image = None
        self.name_character = ""

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
        self.parser_car_info(parser)
        self.parser_basic_info(parser)
        
        #Definimos la posición del objeto
        self.x = self.old_x = x
        self.y = self.old_y = y
        
        self.start = None
        self.turbo_state = None
        self.turbo_sound = resource.get_sound('turbo')
        self.turbo_sound.set_volume(config.Config().get_sound_volume())
        
        self.old_max_speed = self.max_speed

        self.front_line = gameobject.Line(1, 1, 1, 1)
        self.back_line = gameobject.Line(1, 1, 1, 1)
        
        #Si el angulo es 0, no hacemos nada
        if angle == 0:
            self.dx = 0
            self.dy = 0
        #Si es 0 actualizamos el angulo del coche
        else:
            self.actual_angle = angle
            self.dx = math.cos(angle) * self.actual_speed
            self.dy = math.sin(angle) * self.actual_speed
        
        #Actualizamos la posicion del coche según su angulo
        self.update_position()
        #Actualizamos la rotación de la imagen del coche
        self.update_image()
 def __init__(self, player, path_xml):
     '''
     @brief Constructor.
     
     @param player Referencia al jugador.
     @param path_xml Ruta del archivo xml donde se encuentra toda las características
     '''
     self.player = player
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     #Obtenemos la imagen de fondo
     image = parse.getElementsByTagName('image')[0]
     image_code = image.getAttribute('image_code')
     self.image = resource.get_image(image_code)
     
     #Posicion de la imagen de fondo
     x = int(image.getAttribute('x'))
     y = int(image.getAttribute('y'))
     self.position_image = (x, y)
     
     #Posición para los items
     items = parse.getElementsByTagName('items')[0]
     x = int(items.getAttribute('x'))
     y = int(items.getAttribute('y'))
     self.item_position = (self.position_image[0] + x, self.position_image[1] + y)
     
     #Mapa para los items
     self.items = {}
     
     #Recorremos cada uno de los items
     for element in parse.getElementsByTagName('item'):
         code = element.getAttribute('code')
         
         self.items[code] = {}
         self.items[code]['image'] = None
         self.items[code]['xml'] = None
         
         #Nos quedamos con su imagen de muestra
         image_code = element.getAttribute('image_code')
         self.items[code]['image'] = resource.get_image(image_code)
         
         #Y con su archivo xml de configuración
         path_xml = element.getAttribute('path_xml')
         self.items[code]['xml'] = path_xml
     
     #En un principio no tenemos ningun item
     self.actual_item = None
     
     self.temp_angle = None
 def __init__(self, game, path_xml):
     basicmenu.BasicMenu.__init__(self, None)
     
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     self.parser_basic_info(parse)
     
     self.layer = pygame.Surface((pygame.display.get_surface().get_width(), pygame.display.get_surface().get_height()))
     self.layer.set_alpha(125)
     
     center_screen = (pygame.display.get_surface().get_width() / 2, pygame.display.get_surface().get_height() / 2)
     
     self.rect_background = self.background.get_rect()
     self.rect_background.centerx = center_screen[0]
     self.rect_background.centery = center_screen[1]
Exemple #28
0
 def __init__(self, xml_path, actual_value, max_value, x, y, option = ''):
     '''
     @brief Constructor.
     
     @param xml_path Ruta del archivo xml.
     @param actual_value Valor actual que tendrá 
     @param max_value Valor máximo que puede alcanzar
     @param x Posición en el eje x
     @param y Posición en el eje y
     '''
     parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
     
     bar = parse.getElementsByTagName('bar')
     
     #Obtenemos la imagen que representará la barra
     image_code = str(bar[0].getAttribute('image_code'))
     self.bar_image = resource.get_image(image_code)
     
     #Indicamos su posicion
     self.bar_rect = self.bar_image.get_rect()
     self.bar_rect.x = x
     self.bar_rect.y = y
     
     #Obtenemos la imagen que representará al controlador
     controler = parse.getElementsByTagName('controler')
     image_code = str(controler[0].getAttribute('image_code'))
     self.controler_image = resource.get_image(image_code)
     
     #Indicamos su posición inicial
     self.controler_rect = self.controler_image.get_rect()
     self.controler_rect.centerx = self.bar_rect.centerx
     self.controler_rect.centery = self.bar_rect.centery
     
     #Cargamos la fuente con la que se representará el valor
     font = parse.getElementsByTagName('font')
     font_code = str(font[0].getAttribute('font_code'))
     self.font = resource.get_font(font_code, 30)
     r = int(font[0].getAttribute('r'))
     g = int(font[0].getAttribute('g'))
     b = int(font[0].getAttribute('b'))
     self.color_font = (r, b, g)
     
     self.max_value = max_value
     self.min_value = 0
     self.actual_value = actual_value
     self.update_controler()
     self.still_pressed = self.new_pressed = False
     self.option = option
Exemple #29
0
    def __init__(self, game, path_xml):
        """
        @brief Constructor
        
        @param game Referencia a game
        @param path_xml Ruta del archivo xml con las características del menú
        """
        basicmenu.BasicMenu.__init__(self, game)

        # Cambiamos el titulo de la ventana
        pygame.display.set_caption("Zycars: Menú Principal")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        # Le pasamos el archivo parseado a BasicMenu para que obtenga los
        # elementos básicos
        self.parser_basic_info(parse)
Exemple #30
0
    def __init__(self, game_control, path_xml, position_x, position_y):
        '''
        @brief Consturctor
        
        @param game_control Referencia a GameControl
        @param path_xml Xml con la animacion
        @param x Posicion en el eje x
        @param y Posicion en el eje y
        '''
        gameobject.GameObject.__init__(self, game_control)

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        self.parser_basic_info(parse)

        self.rect.x = position_x
        self.rect.y = position_y
Exemple #31
0
    def __init__(self, game, path_xml):
        '''
        @brief Constructor
        
        @param game Referencia a game
        @param path_xml Ruta del archivo xml con las características del menú
        '''
        basicmenu.BasicMenu.__init__(self, game)

        #Cambiamos el titulo de la ventana
        pygame.display.set_caption("Zycars: Menú Principal")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Le pasamos el archivo parseado a BasicMenu para que obtenga los
        #elementos básicos
        self.parser_basic_info(parse)
    def __init__(self, game, path_xml):
        basicmenu.BasicMenu.__init__(self, game)
        
        pygame.display.set_caption("Zycars: Opciones")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
        
        self.parser_basic_info(parse)
        
        self.text_layers = {}
        self.elements_layers = {}
        self.actual_layer = None
        
        for element in parse.getElementsByTagName('layer'):
            
            name_layer = str(element.getAttribute('name'))
            self.text_layers[name_layer] = []
            self.elements_layers[name_layer] = []
            
            font_code = str(element.getAttribute('font_code'))
            size = int(element.getAttribute('size'))
            
            font_temp = resource.get_font(font_code, size)
            
            for text in element.getElementsByTagName('text'):
                
                value = text.getAttribute('value')
                posx = int(text.getAttribute('x'))
                posy = int(text.getAttribute('y'))
                text_render = font_temp.render(value, True, (0,0,0))
                text_render_rect = text_render.get_rect()
                text_render_rect.x = posx
                text_render_rect.y = posy
                
                self.text_layers[name_layer].append((text_render, text_render_rect))
            
            for slider_option in element.getElementsByTagName('slider'):
                xml_path = str(slider_option.getAttribute('xml_file'))
                x = int(slider_option.getAttribute('x'))
                y = int(slider_option.getAttribute('y'))
                new_slider = slider.Slider(xml_path, 50, 100, x, y)
                self.elements_layers[name_layer].append(new_slider)
                
        self.actual_layer = "Sonido"
Exemple #33
0
    def __init__(self, game, path_xml):
        '''
        @brief Constructor
        
        @param game Referencia a game
        @param path_xml Ruta del archivo xml con las características del menú
        '''
        basicmenu.BasicMenu.__init__(self, game)

        #Cambiamos el titulo de la ventana
        pygame.display.set_caption("Zycars: Menú Principal")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Le pasamos el archivo parseado a BasicMenu para que obtenga los elementos básicos
        self.parser_basic_info(parse)

        self.tiny_font = resource.get_font('cheesebu', 18)

        self.developer = self.font.render('Desarrollador', True, (0, 0, 0))
        self.developer_name = self.font.render(u'José J. Marente Florín', True,
                                               (189, 9, 38))
        self.developer_email = self.tiny_font.render(
            u'*****@*****.**', True, (189, 9, 38))
        self.developer_web = self.tiny_font.render(
            u'http://code.google.com/p/zycars/', True, (189, 9, 38))
        self.artist = self.font.render(u'Diseñador gráfico', True, (0, 0, 0))
        self.artist_name = self.font.render(u'David Nieto Rojas', True,
                                            (189, 9, 38))
        self.artist_email = self.tiny_font.render('*****@*****.**', True,
                                                  (189, 9, 38))
        self.artist_web = self.tiny_font.render(u'http://www.deividart.com',
                                                True, (189, 9, 38))
        self.music = self.font.render(u'Música', True, (0, 0, 0))
        self.music_name1 = self.font.render(u'Bob Wizman', True, (189, 9, 38))
        self.music_name2 = self.font.render(u'Pirato Ketchup', True,
                                            (189, 9, 38))
        self.music_name3 = self.font.render(u'Los Cadaver', True, (189, 9, 38))
        self.music_name4 = self.font.render(u'The Wavers', True, (189, 9, 38))
        self.music_name5 = self.font.render(u'Zamalska', True, (189, 9, 38))
        self.music_web = self.tiny_font.render(u'http://www.jamendo.com', True,
                                               (189, 9, 38))
Exemple #34
0
    def __init__(self):
        '''
        #brief Constructor. Carga e inicializa la configuración principal y las variables principales de la clase
        '''
        os.environ["SDL_VIDEO_CENTERED"] = "1"

        #Cargamos el archivo de configuración
        parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
        
        #Obtenemos las dimensiones de la pantalla
        for element in parser.getElementsByTagName('screen'):
            self.__screen_width = int(element.getAttribute('width'))
            self.__screen_height = int(element.getAttribute('height'))
            self.caption = element.getAttribute('caption')
        
        #Obtenemos los fps
        for element in parser.getElementsByTagName('fps'):
            self.fps = int(element.getAttribute('value'))
        
        #Inicializamos Pygame
        pygame.init()
        
        #Obtenemos la ventana de juego
        self.screen = None
        self.set_screen()
        
        #Obtenemos el icono
        for element in parser.getElementsByTagName('icon'):
            icon_code = str(element.getAttribute('code'))
            self.icon = resource.get_image(icon_code)
        
        #Deshabilitamos el cursor
        pygame.mouse.set_visible(False)
        pygame.display.set_icon(self.icon)
        
        #Creamos el reloj
        self.clock = pygame.time.Clock()
        self.font = resource.get_font('cheesebu', 30)
        
        
        #Estado actual del juego
        self.__actual_state = intro.Intro(self, 'intro.xml')  
 def __init__(self, father, xml_path):
     '''
     @brief Constructor.
     
     @param father Modo de juego al que pertenece
     @param xml_path Ruta del archivo xml con la configuración básica
     '''
     basicmenu.BasicMenu.__init__(self, father)
     
     parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
     self.parser_basic_info(parse)
     
     self.classification_bar = resource.get_image('classification_bar')
     self.classification_winner = resource.get_image('classification_winner')
     self.classification_player = resource.get_image('classification_player')
     
     self.big_font = resource.get_font('cheesebu', 40)
     self.tiny_font = resource.get_font('cheesebu', 20)
     
     self.players_position = None
Exemple #36
0
    def get_times(self, circuit_name):
        '''
        @brief obtiene los tiempos de un circuito determinado
        
        @param circuit_name Nombre del circuito que debemos obtener los tiempos
        '''
        parse = xml.dom.minidom.parse(data.get_path_xml('times.xml'))

        for time in parse.getElementsByTagName('circuit'):
            print time.getAttribute('name')
            if time.getAttribute('name') == circuit_name:
                best_race = time.getElementsByTagName('bestrace')[0]
                self.best_total_time = (int(best_race.getAttribute('minutes')),
                                        int(best_race.getAttribute('seconds')),
                                        int(best_race.getAttribute('hseconds')))
                fastest_lap = time.getElementsByTagName('fasttestlap')[0]
                self.best_lap = (int(fastest_lap.getAttribute('minutes')),
                                int(fastest_lap.getAttribute('seconds')),
                                int(fastest_lap.getAttribute('hseconds')))  
                break
Exemple #37
0
    def __init__(self):
        '''
        #brief Constructor. Carga e inicializa la configuración principal y las variables principales de la clase
        '''
        os.environ["SDL_VIDEO_CENTERED"] = "1"

        #Cargamos el archivo de configuración
        parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))

        #Obtenemos las dimensiones de la pantalla
        for element in parser.getElementsByTagName('screen'):
            self.__screen_width = int(element.getAttribute('width'))
            self.__screen_height = int(element.getAttribute('height'))
            self.caption = element.getAttribute('caption')

        #Obtenemos los fps
        for element in parser.getElementsByTagName('fps'):
            self.fps = int(element.getAttribute('value'))

        #Inicializamos Pygame
        pygame.init()

        #Obtenemos la ventana de juego
        self.screen = None
        self.set_screen()

        #Obtenemos el icono
        for element in parser.getElementsByTagName('icon'):
            icon_code = str(element.getAttribute('code'))
            self.icon = resource.get_image(icon_code)

        #Deshabilitamos el cursor
        pygame.mouse.set_visible(False)
        pygame.display.set_icon(self.icon)

        #Creamos el reloj
        self.clock = pygame.time.Clock()
        self.font = resource.get_font('cheesebu', 30)

        #Estado actual del juego
        self.__actual_state = intro.Intro(self, 'intro.xml')
Exemple #38
0
    def __init__(self, game, xml_file):
        '''
        @brief Constructor 
        
        @param game Referencia a game
        @param xml_file ruta del archivo xml con la configuración deseada
        '''
        state.State.__init__(self, game)
        
        pygame.display.set_caption("Zycars")

        #Parseamos el fichero xml
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
        
        #Obtenemos la velocidad con la que avanzará la introducción
        self.speed = int(parser.firstChild.getAttribute('speed'))
        self.actual_alpha = 0
        
        #Obtenemos una superficie negra del mismo tamaño que la pantalla
        self.surface = pygame.Surface((pygame.display.get_surface().get_width(),
                                    pygame.display.get_surface().get_height()))
        
        #Obtenemos la imagen del logo
        for element in parser.getElementsByTagName('image'):
            
            image_code = str(element.getAttribute('imagecode'))
            x = int(element.getAttribute('x'))
            y = int(element.getAttribute('y'))
            
            image = resource.get_image(image_code)
            
            #La dibujamos sobre la superficie antes mencionada
            self.surface.blit(image, (x, y))
        
        #Indicamos el alfa de la superficie, en un principio será 0, es decir
        #Negra completamente
        self.surface.set_alpha(self.actual_alpha)
        
        #Definimos los estados en los que se encuentra la intro
        self.to_opaque = True
        self.quit = False
Exemple #39
0
    def get_times(self, circuit_name):
        '''
        @brief obtiene los tiempos de un circuito determinado
        
        @param circuit_name Nombre del circuito que debemos obtener los tiempos
        '''
        parse = xml.dom.minidom.parse(data.get_path_xml('times.xml'))

        for time in parse.getElementsByTagName('circuit'):
            print time.getAttribute('name')
            if time.getAttribute('name') == circuit_name:
                best_race = time.getElementsByTagName('bestrace')[0]
                self.best_total_time = (
                    int(best_race.getAttribute('minutes')),
                    int(best_race.getAttribute('seconds')),
                    int(best_race.getAttribute('hseconds')))
                fastest_lap = time.getElementsByTagName('fasttestlap')[0]
                self.best_lap = (int(fastest_lap.getAttribute('minutes')),
                                 int(fastest_lap.getAttribute('seconds')),
                                 int(fastest_lap.getAttribute('hseconds')))
                break
Exemple #40
0
    def __init__(self, game_control, xml_file, x, y, angle = 0):
        '''
        @brief Constructor.
        
        @param game_control Referencia a Gamecontrol
        @param xml_file Archivo xml con la configuración del objeto
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del objeto, por defecto será 0.
        '''
        gameobject.GameObject.__init__(self, game_control)
        
        self.break_force = None
        self.avatar = None

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
        self.parser_car_info(parser)
        self.parser_basic_info(parser)
        
        #Definimos la posición del objeto
        self.x = self.old_x = x
        self.y = self.old_y = y
        
        self.start = None
        
        #Si el angulo es 0, no hacemos nada
        if angle == 0:
            self.dx = 0
            self.dy = 0
        #Si es 0 actualizamos el angulo del coche
        else:
            self.actual_angle = angle
            self.dx = cos(angle) * self.actual_speed
            self.dy = sin(angle) * self.actual_speed
        
        #Actualizamos la posicion del coche según su angulo
        self.update_position()
        #Actualizamos la rotación de la imagen del coche
        self.update_image()
Exemple #41
0
    def __init__(self, game_control, owner, path_xml, x, y, angle):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param owner GameObject que lanza el item.
        @param path_xml Archivo xml con las características del item
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del item
        '''
        Item.__init__(self, game_control, owner, path_xml, x, y, angle)

        self.type = MISSILE

        parser = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        root = parser.firstChild

        #Inicializamos atributos
        self.aceleration = float(root.getAttribute('aceleration'))
        self.max_speed = float(root.getAttribute('max_speed'))
        self.explosion_sprite = resource.get_new_sprite('explosion')
        self.explosion_animation = animation.Animation(
            '0,1,2,3,4,5,6,7,8,9,10,11,2,13,14,15,16,17,18,19,20,22,23,24,25',
            0)

        #Funciones para cada estado
        self.states = {
            gameobject.NORMAL: self.__normal_state,
            gameobject.RUN: self.__run_state,
            gameobject.EXPLOSION: self.__explosion_state,
            gameobject.ERASE: self.__erase_state,
        }

        #Creamos el sistema de particulas, para cuando colisionemos con la caja
        self.explosion = False
        self.rect_explosion = self.explosion_sprite.get_frame(0).get_rect()
        self.actual_speed = 0.1
Exemple #42
0
 def __init__(self):
     '''
     @brief Constructor de cursor
     
     @param xml_path Ruta del archivo de configuración del cursor
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('cursor.xml'))
     
     root = parser.firstChild
     
     #Obtenemos la imagen para cada caso
     self.normal_image = resource.get_image(root.getAttribute('normal_image'))
     self.over_image = resource.get_image(root.getAttribute('over_image'))
     
     #La actual
     self.actual_image = self.normal_image
     
     #Inicializamos la posición del cursor
     self.x = self.y = 0
     
     #Actualizamos la posición del cursor
     self.update()
Exemple #43
0
    def __init__(self, game_control, owner, path_xml, x, y, angle):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param owner GameObject que lanza el item.
        @param path_xml Archivo xml con las características del item
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del item
        '''
        gameobject.GameObject.__init__(self, game_control)

        #Parseamos la información básica
        parser = xml.dom.minidom.parse(data.get_path_xml(path_xml))
        self.parser_basic_info(parser)

        #Propietario
        self.owner = owner

        #Definimos la posición del objeto
        self.x = self.old_x = x
        self.y = self.old_y = y

        #Si el angulo es 0, no hacemos nada
        if angle == 0:
            self.dx = 0
            self.dy = 0
        #Si es 0 actualizamos el angulo del item
        else:
            self.actual_angle = angle
            self.dx = math.cos(angle) * self.actual_speed
            self.dy = math.sin(angle) * self.actual_speed

        #Actualizamos la posicion del coche según su angulo
        self.update_position()
        #Actualizamos la rotación de la imagen del coche
        self.update_image()
        self.type = None
Exemple #44
0
 def __init__(self, xml_path):
     '''
     @brief Constructor de cursor
     
     @param xml_path Ruta del archivo de configuración del cursor
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('cursor.xml'))
     
     root = parser.firstChild
     
     #Obtenemos la imagen para cada caso
     self.normal_image = resource.get_image(root.getAttribute('normal_image'))
     self.over_image = resource.get_image(root.getAttribute('over_image'))
     
     #La actual
     self.actual_image = self.normal_image
     
     #Inicializamos la posición del cursor
     self.x = self.y = 0
     
     #Actualizamos la posición del cursor
     self.update()
Exemple #45
0
    def __init__(self, father, xml_path):
        '''
        @brief Constructor.
        
        @param father Modo de juego al que pertenece
        @param xml_path Ruta del archivo xml con la configuración básica
        '''
        basicmenu.BasicMenu.__init__(self, father)

        parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
        self.parser_basic_info(parse)

        self.classification_bar = resource.get_image('classification_bar')
        self.classification_winner = resource.get_image(
            'classification_winner')
        self.classification_player = resource.get_image(
            'classification_player')

        self.big_font = resource.get_font('cheesebu', 40)
        self.tiny_font = resource.get_font('cheesebu', 20)

        self.players_position = None
Exemple #46
0
def __initialize_module():
    '''
	@brief Función privada del módulo.Es la encargada de inicializar el módulo 
    parseando un fichero xml que contendrá todos los recursos necesarios en el 
    sistema.
	'''
    parser = xml.dom.minidom.parse(data.get_path_xml('resources.xml'))

    for element in parser.getElementsByTagName("image"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        alpha = bool(element.getAttribute("alpha"))
        __images_info[code] = (name, alpha)

    for element in parser.getElementsByTagName("sprite"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        rows = int(element.getAttribute("rows"))
        columns = int(element.getAttribute("columns"))
        alpha = bool(element.getAttribute("alpha"))
        __sprites_info[code] = (name, rows, columns, alpha)

        if __images_info.has_key(code):
            Log().error('Ya se ha cargado información para el código: ' + code)
        else:
            __images_info[code] = (name, alpha)

    for element in parser.getElementsByTagName("sound"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        __sounds_info[code] = name

    for element in parser.getElementsByTagName("font"):
        code = element.getAttribute("code")
        name = element.getAttribute("name")
        __fonts_info[code] = name
Exemple #47
0
    def __init__(self, game_control, owner, path_xml, x, y, angle):
        '''
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param owner GameObject que lanza el item.
        @param path_xml Archivo xml con las características del item
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param angle Ángulo del item
        '''
        Item.__init__(self, game_control, owner, path_xml, x, y, angle)

        #Indicamos que es de tipo bola
        self.type = BALL

        parser = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        root = parser.firstChild

        #Inicializamos atributos
        self.aceleration = float(root.getAttribute('aceleration'))
        self.max_speed = float(root.getAttribute('max_speed'))
        self.particle_code = root.getAttribute('particle_code')

        #Funciones para cada estado
        self.states = {
            gameobject.NORMAL: self.__normal_state,
            gameobject.RUN: self.__run_state,
            gameobject.EXPLOSION: self.__explosion_state,
            gameobject.ERASE: self.__erase_state,
        }

        #Creamos el sistema de particulas, para cuando colisionemos con la caja
        self.particles = None
        self.actual_speed = 0.1
Exemple #48
0
 def __init__(self, menu, xml_file, text, centerx, centery, font_code, show_text = True):
     '''
     @brief Constructor.
     
     @param menu Referencia al Menú que pertenece
     @param xml_file ruta del archivo xml donde se encuentra la configuración básica del botón
     @param text Texto que aparecera sobre el botón
     @param centerx Posición del centro x del boton 
     @param centery Posición del centro y del boton 
     '''
     self.text = text
     self.menu = menu
     parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
     
     self.centerx = centerx
     self.centery = centery 
         
     aux_rect = None
     
     father = parser.firstChild
     
     #Obtenemos la posición del texto en el boton
     self.text_position = str(father.getAttribute('text_position'))
     
     #Comprobamos si el boton mostrará el texto o no.
     if father.hasAttribute('on_button'):
         self.on_button = strTobool(str(father.getAttribute('on_button')))
     else:
         self.on_button = True
     
     self.sound_over = None
     if father.hasAttribute('sound_over'):
         self.sound_over = resource.get_sound(str(father.getAttribute('sound_over')))
         self.sound_over.set_volume(config.Config().get_sound_volume())
     
     self.sound_click = None
     if father.hasAttribute('sound_click'):
         self.sound_click = resource.get_sound(str(father.getAttribute('sound_click')))
         self.sound_click.set_volume(config.Config().get_sound_volume())
         
     #Obtenemos la imagen y sus características cuando el boton esta en estado normal
     for element in parser.getElementsByTagName('normal'):
         
         #Cargamos la imagen
         normal_image_code = str(element.getAttribute('normal_image'))
         self.normal_image = resource.get_image(normal_image_code)
         
         #obtenemos posicion de la imagen
         aux_rect = self.normal_image.get_rect()
         aux_rect.x = self.centerx
         aux_rect.y = self.centery
         self.rect_normal = pygame.Rect((0, 0, 0, 0))
         self.rect_normal.x = int(element.getAttribute('x')) + aux_rect.x
         self.rect_normal.y = int(element.getAttribute('y')) + aux_rect.y
         self.rect_normal.w = int(element.getAttribute('w'))
         self.rect_normal.h = int(element.getAttribute('h'))
     
     #Obtenemos la imagen y caracteristicas cuando el botón está seleccionado    
     for element in parser.getElementsByTagName('selected'):
         
         #Cargamos imagen
         selected_image_code = str(element.getAttribute('selected_image'))
         self.selected_image = resource.get_image(selected_image_code)
         
         #Obtenemos la posicion
         aux_rect = self.selected_image.get_rect()
         aux_rect.x = self.centerx
         aux_rect.y = self.centery
         self.rect_selected = pygame.Rect((0, 0, 0, 0))
         self.rect_selected.x = int(element.getAttribute('x')) + aux_rect.x
         self.rect_selected.y = int(element.getAttribute('y')) + aux_rect.y
         self.rect_selected.w = int(element.getAttribute('w'))
         self.rect_selected.h = int(element.getAttribute('h'))
     
     #Obtenemos el la posicion centrar de las dos imagenes
     self.rect_draw = self.normal_image.get_rect()
     self.rect_draw.centery = self.centery
     self.rect_draw.centerx = self.centerx
     
     #Si indicamos que se muestre el texto
     if show_text:
         
         #Obtenemos el texto normal que se mostrará
         for element in parser.getElementsByTagName('normal_text'):
             
             #Tamaño
             font_size = int(element.getAttribute('size'))
             
             #Color
             r = int(element.getAttribute('r'))
             g = int(element.getAttribute('g'))
             b = int(element.getAttribute('b'))
             color = (r, g, b)
             
             #Renderizamos
             self.normal_font = resource.get_font(font_code, font_size)
             self.text_render_normal = self.normal_font.render(self.text, 
                                                             True, color)
             
             #Vemos si el texto tendrá algun tipo de inclinación
             if element.hasAttribute('angle'):
                 angle = int(element.getAttribute('angle'))
                 self.text_render_normal = pygame.transform.rotozoom(self.text_render_normal, angle, 1)
             
             #Obtenemos la posicion del texto
             self.normal_text_rect = self.text_render_normal.get_rect()
             posx = int(element.getAttribute('x'))
             posy = int(element.getAttribute('y'))
             self.normal_text_rect = self.__set_rect_text(self.normal_text_rect, 
                                                         posx, posy)
         
         #Si hay opcion de cambio del color del texto cuando el botón esté seleccionado
         if len(parser.getElementsByTagName('selected_text')) > 0:
             #Obtenemos dicho texto
             for element in parser.getElementsByTagName('selected_text'):
                 
                 #tamaño
                 font_size = int(element.getAttribute('size'))
                 
                 #Color
                 r = int(element.getAttribute('r'))
                 g = int(element.getAttribute('g'))
                 b = int(element.getAttribute('b'))
                 color = (r, g, b)
                 
                 #Renderizamos
                 self.selected_font = resource.get_font(font_code, font_size)
                 self.text_render_selected = self.selected_font.render(self.text, True, color)
                 
                 #Si tiene opcion de angulo
                 if element.hasAttribute('angle'):
                     #Rotamos el texto renderizado
                     angle = int(element.getAttribute('angle'))
                     self.text_render_selected = pygame.transform.rotozoom(self.text_render_selected, angle, 1)
                 
                 #Asignamos la posición que tendrá
                 self.selected_text_rect = self.text_render_selected.get_rect()
                 posx = int(element.getAttribute('x'))
                 posy = int(element.getAttribute('y'))
                 self.selected_text_rect = self.__set_rect_text(self.selected_text_rect, posx, posy)
         #Si no hay opción de texto seleccionado, asignamos el mismo texto anterior
         else:
             self.text_render_selected = self.text_render_normal
             self.selected_text_rect = self.normal_text_rect
         
     self.selected = False
 
     #Obtenemos las mascaras de colisiones para los dos botones
     self.normal_mask = pygame.mask.from_surface(self.normal_image)
     self.selected_mask = pygame.mask.from_surface(self.selected_image)
     self.actual_mask = self.normal_mask
     self.show_text = show_text
Exemple #49
0
    def __init__(self, game, path_xml):
        '''
        @brief Constructor.
        
        @param game Referencia a Game
        @param path_xml Archivo xml con la configuración del menú
        '''
        basicmenu.BasicMenu.__init__(self, game)
        
        #Cambiamos el título de la ventana
        pygame.display.set_caption("Zycars: Circuitos")

        #Parseamos la información básica del circuito(botones, imagenes...)
        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
        self.parser_basic_info(parse)

        #Guarrada para el titulo del campeonato
        if config.Config().get_mode() == config.CHAMPIONSHIP:
            self.title = self.font.render('Campeonato', True, (0,0,0))
        
        #Mapa que contendrá los botones de cada capa
        self.buttons_layers = {}
        
        #Mapa que contendrá la imagen de un circuito dado la capa y el nombre del circuito
        self.images_circuits = {}
        
        #Mapa que contendrá los primeros circuitos de cada campeonato
        self.first_circuit = {}
        
        #Mapa con los archivos xml
        self.circuit_files = {}
        
        #Obtenemos los parametros para la posición del título de los circuitos
        self.centerx_name = 400
        self.y_name = 250
        self.rect_name = None
        self.actual_name = None
        
        self.font = resource.get_font('cheesebu', 30)
        
        #Booleanos auxiliares
        first = True
        new_layer = True
        first_layer = True
        
        #Texto a mostrar cuando no hay circuito disponible
        font = resource.get_font('cheesebu', 30)
        message = font.render('Lo sentimos, Circuito no disponible', True, 
                            (0, 0, 0))
        
        #Obtenemos la posicion de la imagen que representará al circuito
        image_pos = parse.getElementsByTagName('circuit_position')[0]
        x = int(image_pos.getAttribute('x'))
        y = int(image_pos.getAttribute('y'))
        self.circuit_position = (x, y)
        
        self.times = None
        
        self.text_laps = self.font.render('Vueltas', True, (189, 9 , 38))
        self.laps = config.Config().get_laps()
        laps = parse.getElementsByTagName('laps')[0]
        
        self.text_laps_position = (int(laps.getAttribute('text_x')), 
                                int(laps.getAttribute('text_y')))
                                
        self.laps_position = (int(laps.getAttribute('num_x')), 
                            int(laps.getAttribute('num_y')))
        
        if config.Config().get_mode() == config.TIMED:
            #Obtenemos la posición del marcador de los tiempos
            time_pos = parse.getElementsByTagName('times_position')[0]
            x = int(time_pos.getAttribute('x'))
            y = int(time_pos.getAttribute('y'))
            #Creamos el marcador de los tiempos
            self.times = Times(x, y, 'times.xml')
        
        #Recorremos las capas a mostrar, de los distintos campeonatos
        for element in parse.getElementsByTagName('layer'):
            
            #Obtenemos el nombre de la capa, debe coincidir con el del botón
            #Que hace referencia a ella
            name_layer = element.getAttribute('name')
            
            #Creamos una lista para todos los botones de esa capa
            self.buttons_layers[name_layer] = []
            
            #Creamos un mapa para cada una de las capas
            self.images_circuits[name_layer] = {}
            self.circuit_files[name_layer] = {}
            
            #Si es la primera capa que parseamos, nos quedamos con ella, para
            #mostrarla la primera
            if first_layer:
                self.actual_layer = name_layer
                first_layer = False
            
            #Obtenemos los botones de cada una de las capas
            for option in element.getElementsByTagName('button'):
                
                #Archivo xml con la configuración del botón
                xml_file = str(option.getAttribute('xml_file'))
                
                #Fuente y texto que apareceran en el boton
                font_code = str(option.getAttribute('font'))
                text = option.getAttribute('text')
                
                #Posición del botón
                x = int(option.getAttribute('x'))
                y = int(option.getAttribute('y'))
                show_text = True
                
                #Miramos si se indica si se debe mostrar o no el texto en el botón
                if option.hasAttribute('show_text'):
                    show_text = option.getAttribute('show_text')
                    show_text = button.strTobool(show_text)      
                    
                #Obtenemos el tipo de boton
                if option.hasAttribute('type'):
                    type_button = str(option.getAttribute('type'))
                
                #Según el tipo de boton obtendremos un boton u otro
                if type_button == 'normal':
                    
                    #Si es un botón normal sin imagen significa que el circuito no está disponible.
                    aux_button = button.Button(self, xml_file, text, x, y, 
                                            font_code, show_text)
                    
                    #Si que le asociamos como imagen el mensaje de que no está disponible
                    self.images_circuits[name_layer][text] = message

                elif type_button == 'image_button':
                    
                    #Obtenemos la información necesaria para ImageButton
                    image_code = str(option.getAttribute('image'))
                    image_x = int(option.getAttribute('image_x'))
                    image_y = int(option.getAttribute('image_y'))
                    
                    aux_button = imagebutton.ImageButton(self, xml_file, text, 
                                                        x, y, font_code, 
                                                        image_code, image_x, 
                                                        image_y, show_text)

                    #Obtenemos el archivo de configuración del circuito
                    circuit_file = str(option.getAttribute('circuit_file'))
                    
                    #Obtenemos la imagen que representará al circuito
                    image_circuit = str(option.getAttribute('image_circuit'))
                    
                    #Introducimos la imagen en el doble diccionario
                    self.images_circuits[name_layer][text] = resource.get_image(image_circuit)
                    #Hacemos lo mismo con el archivo xml
                    self.circuit_files[name_layer][text] = circuit_file
                
                #Nos quedamos con el primer circuito de la capa actual
                if first:
                    self.actual_circuit = text
                    
                    #También renderizamos el título del circuito
                    self.actual_name = self.font.render(text, True, 
                                                    (255, 255, 255))
                                                    
                    self.rect_name = self.actual_name.get_rect()
                    self.rect_name.y = self.y_name
                    self.rect_name.centerx = self.centerx_name
                    
                    if self.times:
                        #Nos quedamos en un principio con los tiempos del primer circuito
                        self.times.update(text)
                    
                    #Indicamos que el siguiente no será el primero
                    first = False
                
                #Nos quedamos con el primer circuito de cada una de las capas
                #para mostrarlos cuando cambiemos de capa
                if new_layer:
                    self.first_circuit[name_layer] = text
                    new_layer = False

                #Por último añadiemos el botón a la lista de botones por capa
                self.buttons_layers[name_layer].append(aux_button)
            
            new_layer = True
Exemple #50
0
    def __init__(self, game_control, xml_path):
        '''
        @brief Constructor
        
        @param game_control Referencia a GameControl.
        @param xml_path Ruta del archivo del circuito.
        '''
        self.game_control = game_control

        parser = xml.dom.minidom.parse(data.get_path_xml(xml_path, False))

        #Parseamos los distintos componentes necesarios para el circuito.
        for element in parser.getElementsByTagName('map'):
            self.width = int(element.getAttribute('width'))
            self.height = int(element.getAttribute('height'))
            self.tile_width = int(element.getAttribute('tilewidth'))
            self.tile_height = int(element.getAttribute('tileheight'))

        #print "Width: " + str(self.width) + " Height: " + str(self.height) \
        #+ " tile_width: " + str(self.tile_width) + ' tile_height: ' + str(self.tile_height)

        #Obtenemos el nombre de la imagen con el tileset del circuito
        image_name = None
        for element in parser.getElementsByTagName('image'):
            image_name = str(element.getAttribute('source'))

        #Variables auxiliares
        tileset_width = 1
        tileset_height = 1
        collision_map_name = None

        self.circuit_width = 0
        self.goal_width = 0
        self.elements_map = {}
        self.car_angle = 0

        #Parseamos las distintas propiedades editadas para el mapa, como
        #el número de tiles en el ancho del tileset y en el alto,
        #así como el mapa de colisiones correspondiente
        for element in parser.getElementsByTagName('property'):
            name = element.getAttribute('name')
            if name == 'tileset_ancho':
                tileset_width = int(element.getAttribute('value'))
            elif name == 'tileset_alto':
                tileset_height = int(element.getAttribute('value'))
            elif name == 'collision_map':
                collision_map_name = str(element.getAttribute('value'))
            elif name == 'ancho_pista':
                self.circuit_width = int(element.getAttribute('value'))
                frame = int(element.getAttribute('value'))
                self.elements_map[frame] = name
            elif name == 'ancho_meta':
                self.goal_width = int(element.getAttribute('value'))
            elif name == 'grado_coche':
                self.car_angle = int(element.getAttribute('value'))
            elif name == 'item_box':
                frame = int(element.getAttribute('value'))
                self.elements_map[frame] = name
            elif name == 'music':
                music_file = str(element.getAttribute('value'))
                self.game_control.set_music_file(music_file)

        #print "Tileset_height: " + str(tileset_height) + ' Tileset_width: ' + str(tileset_width)

        #Cargamos el tileset del circuito
        self.tileset = data.load_sprite(image_name, tileset_height,
                                        tileset_width)

        #Cargamos el mampa de colisiones para el circuito
        collision_map_prueba = data.load_sprite(
            collision_map_name, tileset_height,
            tileset_width)  #, tileset_height, tileset_width)

        #Suponiendo que 4 sera el numero de capas que tendrá el mapa
        #Self.map sera la matriz logica que indicara donse se posiciona
        #cada tile y de que tipo son.
        self.map = range(4)
        #Por cada elemento:
        for n in range(4):
            self.map[n] = range(self.height)  #reservamos para el alto.
            #astar.map = range(self.height)
            for m in range(self.height):
                self.map[n][m] = range(self.width)  #y para el ancho.
                #astar.map[m] = range(self.width)
                for o in range(self.width):
                    self.map[n][m][o] = Tile()
                    #astar.map[m][o] = astar.PASSABLE

        astar.map = range(self.width)
        for m in range(self.width):
            astar.map[m] = range(self.height)
            for o in range(self.height):
                astar.map[m][o] = astar.PASSABLE

        num_layer = 0
        num_row = 0
        num_column = 0
        n = 0
        frame = None

        #Recorremos cada una de las capas
        for layer in parser.getElementsByTagName('layer'):
            for tile in layer.getElementsByTagName('tile'):

                #Obtenemos el numero de la fila y de la columna del tile
                num_row = int(n / self.width)
                num_column = (n % self.width) % self.width

                #Obtenemos el frame referente al tileset
                frame = int(tile.getAttribute('gid'))

                #Asignamos el frame
                self.map[num_layer][num_row][num_column].frame = frame

                #Si el frame es 0 quiere decir que es un tile vacio, por lo que
                #Lo pondemos como pasabel
                if frame == 0:
                    self.map[num_layer][num_row][num_column].type = PASSABLE
                else:

                    #Comprobamos el color del tile correspondiente en el mapa de colisiones
                    #Segun el color de este indicará que el tile es de un tipo u otro
                    if collision_map_prueba[frame - 1].get_at(
                        (0, 0)) == (255, 0, 0):
                        self.map[num_layer][num_row][
                            num_column].type = PASSABLE
                        #print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " es pasable."

                    #elif pxarray[p_x][p_y] == pxarray_tile_types[1]:
                    elif collision_map_prueba[frame - 1].get_at(
                        (0, 0)) == (0, 255, 0):
                        self.map[num_layer][num_row][
                            num_column].type = NOPASSABLE
                        astar.map[num_column][num_row] = astar.NOPASSABLE
                        #print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " NO es pasable."

                    #elif pxarray[p_x][p_y] == pxarray_tile_types[2]:
                    elif collision_map_prueba[frame - 1].get_at(
                        (0, 0)) == (0, 0, 255):
                        self.map[num_layer][num_row][num_column].type = LAG
                        astar.map[num_column][num_row] = astar.LAG

                    elif collision_map_prueba[frame - 1].get_at(
                        (0, 0)) == (0, 0, 0):
                        self.map[num_layer][num_row][num_column].type = HOLE
                        astar.map[num_column][num_row] = astar.LAG

                    #Si no es ninguno de los anteriores lo seleccionamos como pasable
                    else:
                        self.map[num_layer][num_row][
                            num_column].type = PASSABLE

                n += 1
            #print n
            num_layer += 1
            n = 0

        self.x = 0
        self.y = 1

        #self.y = self.height * self.tile_height - pygame.display.get_surface().get_height()
        #y = alto_ * tile_alto_ - juego_->univ()->pantalla_alto();

        #Parseamos los objetos que se introducirán en el mapa
        for element in parser.getElementsByTagName('objectgroup'):

            #Comprobamos si estamos enla capa de los checkpoints
            if element.getAttribute('name') == 'checkpoints':

                #Parseamos cada uno de los checkpoints
                for cp in element.getElementsByTagName('object'):

                    #Obtenemos las caracteristicas
                    position = int(cp.getAttribute('name'))
                    type = str(cp.getAttribute('type'))
                    x = int(cp.getAttribute('x'))
                    y = int(cp.getAttribute('y'))

                    new_checkpoint = None

                    #Segun el tipo añadiremos un chekpoint
                    if type == 'Horizontal' or type == 'Vertical':
                        if type == 'Horizontal':
                            new_checkpoint = checkpoint.CheckPoint(
                                self.game_control, x, y,
                                self.tile_width * self.circuit_width, 2)
                        elif type == 'Vertical':
                            new_checkpoint = checkpoint.CheckPoint(
                                self.game_control, x, y, 2,
                                self.tile_height * self.circuit_width)

                        #Añadimos un nuevo checkpoint
                        self.game_control.add_checkpoint(
                            new_checkpoint, position)

                    #O la meta
                    else:
                        if type == 'GoalH':
                            new_checkpoint = checkpoint.CheckPoint(
                                self.game_control, x, y,
                                self.tile_width * self.circuit_width, 2)
                            self.game_control.set_start(
                                self, x, y, 'goal', 'horizontal',
                                self.car_angle)

                        elif type == 'GoalV':
                            new_checkpoint = checkpoint.CheckPoint(
                                self.game_control, x, y, 2,
                                self.tile_height * self.circuit_width)
                            self.game_control.set_start(
                                self, x, y, 'goal', 'vertical', self.car_angle)

                        #Añadimos la meta
                        self.game_control.set_goal(new_checkpoint)

                #Tras obtener todos los checpoints, los ordernamos para su gestión
                self.game_control.order_checkpoints()

            if element.getAttribute('name') == 'objetos':

                for ob in element.getElementsByTagName('object'):

                    #Obtenemos las caracteristicas
                    name = str(ob.getAttribute('name'))
                    type = str(ob.getAttribute('type'))
                    x = int(ob.getAttribute('x'))
                    y = int(ob.getAttribute('y'))

                    if type == 'Item_box':
                        item_box = itembox.ItemBox(self.game_control,
                                                   'elements/itembox.xml', x,
                                                   y)
                        self.game_control.add_item_box(item_box)

                    if type == 'check':

                        position = int(name)
                        rect = pygame.Rect(x, y, self.tile_width,
                                           self.tile_height)
                        print rect

                        self.game_control.ia_checks[position] = rect
                    if type == 'animation':
                        path_xml = "animations/" + name
Exemple #51
0
    def __init__(self, game, path_xml):
        '''
        @brief Constructor.
        
        @param game Referencia a game
        @param path_xml Ruta del archivo xml con la configuración
        '''
        basicmenu.BasicMenu.__init__(self, game)

        #Cambiamos el título de la ventana
        pygame.display.set_caption("Zycars: Opciones")

        parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))

        #Obtenemos los elementos básicos del menú
        self.parser_basic_info(parse)

        #Declaramos distintos atributos de la clase
        self.text_layers = {}
        self.elements_layers = {}
        self.buttons_layers = {}
        self.images_layers = {}
        self.actual_layer = None

        #Recorremos las distintas capas que tendrá el menú
        for element in parse.getElementsByTagName('layer'):

            #Obtenemos el nombre de la capa que la indetificará
            name_layer = str(element.getAttribute('name'))
            self.text_layers[name_layer] = []
            self.elements_layers[name_layer] = []
            self.buttons_layers[name_layer] = []
            self.images_layers[name_layer] = {}

            #Fuente que se usará y tamaño de esta
            font_code = str(element.getAttribute('font_code'))
            size = int(element.getAttribute('size'))
            font_temp = resource.get_font(font_code, size)

            #Obtenemos los distintos texto que aparecerán por capa
            for text in element.getElementsByTagName('text'):

                #Obtenemos texto y posición
                value = text.getAttribute('value')
                posx = int(text.getAttribute('x'))
                posy = int(text.getAttribute('y'))

                #Renderizamos
                text_render = font_temp.render(value, True, (0, 0, 0))
                text_render_rect = text_render.get_rect()
                text_render_rect.x = posx
                text_render_rect.y = posy

                #Insertamos en la lista de textos por capa
                self.text_layers[name_layer].append(
                    (text_render, text_render_rect))

            #Obtenemos los distintos objetos que tendrán cada capa
            #En primer lugar obtenemos los slider
            for slider_option in element.getElementsByTagName('slider'):

                #Obtenemos archivo de configuración
                xml_path = str(slider_option.getAttribute('xml_file'))

                #Posición
                x = int(slider_option.getAttribute('x'))
                y = int(slider_option.getAttribute('y'))

                text = str(slider_option.getAttribute('text'))
                value = 0
                if text == 'sonido':
                    value = int(config.Config().get_sound_volume() * 100)
                else:
                    value = int(config.Config().get_music_volume() * 100)
                #Obtenemos el slider
                new_slider = slider.Slider(xml_path, value, 100, x, y, text)

                #Lo introducimos en la lista de sliders
                self.elements_layers[name_layer].append(new_slider)

            for check_box in element.getElementsByTagName('checkbox'):

                xml_file = str(check_box.getAttribute('xml_file'))
                font_code = str(check_box.getAttribute('font'))
                show_text = False
                text = check_box.getAttribute('text')
                image_code = str(check_box.getAttribute('image_code'))
                image_x = int(check_box.getAttribute('image_x'))
                image_y = int(check_box.getAttribute('image_y'))
                x = int(check_box.getAttribute('x'))
                y = int(check_box.getAttribute('y'))

                new_checkbox = checkbox.CheckBox(self, xml_file, text, x, y,
                                                 font_code, image_code,
                                                 image_x, image_y, show_text)
                self.elements_layers[name_layer].append(new_checkbox)

            for button_layer in element.getElementsByTagName('button'):

                #Ruta del archivo xml con la configuración
                xml_file = str(button_layer.getAttribute('xml_file'))

                #Fuente y texto que apareceran en el boton
                font_code = str(button_layer.getAttribute('font'))
                text = button_layer.getAttribute('text')

                x = int(button_layer.getAttribute('x'))
                y = int(button_layer.getAttribute('y'))
                show_text = True

                #Miramos si se indica si se debe mostrar o no el texto
                #en el botón
                if button_layer.hasAttribute('show_text'):
                    show_text = button_layer.getAttribute('show_text')
                    show_text = button.strTobool(show_text)

                aux_button = button.Button(self, xml_file, text, x, y,
                                           font_code, show_text)

                #Lo añadimos a la lista de botones
                self.buttons_layers[name_layer].append(aux_button)

            for image in element.getElementsByTagName('image_layer'):

                image_code = image.getAttribute('image_code')
                x = int(image.getAttribute('x'))
                y = int(image.getAttribute('y'))

                self.images_layers[name_layer][image_code] = \
                                        (resource.get_image(image_code), x, y)

        for chb in self.elements_layers['Pantalla']:
            if config.Config().get_fullscreen():
                chb.set_checked()

        #La capa inicial será la de sonido
        self.actual_layer = "Sonido"
        self.direction = config.Config().get_direction()
        self.pause = 'p' if config.Config().get_pause_key() == \
                                                        pygame.K_p else 'esc'
        self.item = 'space' if config.Config().get_item_key() == \
                                                pygame.K_SPACE else 'enter'
Exemple #52
0
    def completed_race(self, player, total_time, best_lap, all_laps):
        '''
        @brief Función que gestiona la finaliación de una carrera
        
        @param player Jugador
        @param total_time Tiempo total el completar el circuito
        @param best_lap Mejor vuelta del jugador
        @param all_laps Tiempos de todas las vueltas
        '''
        old_total_time = timer.Timer('cheesebu', 1, (0, 0, 0), 0, 0, "",
                                     self.best_total_time[0],
                                     self.best_total_time[1],
                                     self.best_total_time[2])

        old_best_lap = timer.Timer('cheesebu', 1, (0, 0, 0), 0, 0, "",
                                   self.best_lap[0], self.best_lap[1],
                                   self.best_lap[2])

        #Comprobamos si mejora alguno de los tiempos
        total_improved = lap_improved = False
        if total_time.less_than(old_total_time):
            print "Ha mejorado el tiempo total"
            total_improved = True

        if best_lap.less_than(old_best_lap):
            print "Ha hecho la vuelta mas rapida"
            lap_improved = True

        #Si a mejorado alguno se procede a almacenarlos en el fichero de tiempos
        if lap_improved or total_improved:
            parse = xml.dom.minidom.parse(data.get_path_xml('times.xml'))

            for circuit in parse.getElementsByTagName('circuit'):
                if circuit.getAttribute('name') == self.circuit_name:
                    if total_improved:
                        best_race = circuit.getElementsByTagName('bestrace')[0]
                        best_race.setAttribute('minutes',
                                               str(total_time.get_minutes()))
                        best_race.setAttribute('seconds',
                                               str(total_time.get_seconds()))
                        best_race.setAttribute('hseconds',
                                               str(total_time.get_hseconds()))
                    if lap_improved:
                        fastest_lap = circuit.getElementsByTagName(
                            'fasttestlap')[0]
                        fastest_lap.setAttribute('minutes',
                                                 str(best_lap.get_minutes()))
                        fastest_lap.setAttribute('seconds',
                                                 str(best_lap.get_seconds()))
                        fastest_lap.setAttribute('hseconds',
                                                 str(best_lap.get_hseconds()))

            #Abrimos el fichero y almacenamos los cambios
            times_file = open(data.get_path_xml('times.xml'), 'wb')
            parse.writexml(times_file, encoding='utf-8', indent=' ')
            times_file.close()

        tuple_total_time = (total_time.get_minutes(), total_time.get_seconds(),
                            total_time.get_hseconds())
        tuple_best_lap = (best_lap.get_minutes(), best_lap.get_seconds(),
                          best_lap.get_hseconds())

        #Establecemos los tiempos para le menú de tiempos
        self.classification.set_results(player, tuple_total_time,
                                        total_improved, tuple_best_lap,
                                        lap_improved, all_laps)
        self.state = CLASSIFICATION