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, 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):
'''
#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, 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
