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]
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)
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')
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)
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()
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')
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" }
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
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()
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()
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))
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
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
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')
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
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
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)
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
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)
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()
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
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
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, 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]
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
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_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
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"
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))
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
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
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
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
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()
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
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()
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
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()
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
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
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
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
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
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
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'
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