def __init__(self, father, xml_path):
'''
@brief Constructos.
@param father Estado padre
@param xml_path Ruta archivo xml con la configuración
'''
ClassificationMenu.__init__(self, father, xml_path)
self.player = None
self.total_time = None
self.total_improved = None
self.fast_lap = None
self.lap_improved = None
self.all_laps = None
self.total_text = self.font.render('Tiempo total', True, (0, 0, 0))
self.lap_text = self.font.render('Mejor Vuelta', True, (0, 0, 0))
self.all_laps_text = self.font.render('Tiempos por vuelta', True,
(0, 0, 0))
self.tiny_font = resource.get_font('cheesebu', 10)
self.big_font = resource.get_font('cheesebu', 60)
self.positions = {
1: self.tiny_font.render('st', True, (189, 9, 38)),
2: self.tiny_font.render('nd', True, (189, 9, 38)),
3: self.tiny_font.render('rd', True, (189, 9, 38)),
4: self.tiny_font.render('th', True, (189, 9, 38))
}
self.record_image = resource.get_image('new_record')
self.record_total_image = pygame.transform.rotozoom(
self.record_image, 30, 1)
self.record_lap_image = pygame.transform.rotozoom(
self.record_image, 30, 0.7)
def __init__(self, father, xml_path):
'''
@brief Constructos.
@param father Estado padre
@param xml_path Ruta archivo xml con la configuración
'''
ClassificationMenu.__init__(self, father, xml_path)
self.player = None
self.total_time = None
self.total_improved = None
self.fast_lap = None
self.lap_improved = None
self.all_laps = None
self.total_text = self.font.render('Tiempo total', True, (0, 0, 0))
self.lap_text = self.font.render('Mejor Vuelta', True, (0, 0, 0))
self.all_laps_text = self.font.render('Tiempos por vuelta', True,
(0, 0, 0))
self.tiny_font = resource.get_font('cheesebu', 10)
self.big_font = resource.get_font('cheesebu', 60)
self.positions = {1: self.tiny_font.render('st', True, (189, 9, 38)),
2: self.tiny_font.render('nd', True, (189, 9, 38)),
3: self.tiny_font.render('rd', True, (189, 9, 38)),
4: self.tiny_font.render('th', True, (189, 9, 38))}
self.record_image = resource.get_image('new_record')
self.record_total_image = pygame.transform.rotozoom(self.record_image, 30, 1)
self.record_lap_image = pygame.transform.rotozoom(self.record_image, 30, 0.7)
def __init__(self, text, x, y, normal_image_code, selected_image_code, font_code, center = False):
self.normal_image = resource.get_image(normal_image_code)
self.selected_image = resource.get_image(selected_image_code)
self.rect = self.normal_image.get_rect()
if center:
self.rect.centerx = x
self.rect.centery = y
self.centerx = x
self.centery = y
else:
self.rect.x = x
self.rect.y = y
self.centerx = self.rect.w - seef.rect.x
self.centery = self.rect.h - seef.rect.y
self.mask = pygame.mask.from_surface(self.normal_image)
self.list_rect = self.mask.get_bounding_rects()
self.font = resource.get_font(font_code, 40)
self.font2 = resource.get_font(font_code, 45)
self.text = text
self.selected = False
self.change = True
self.text_render_normal = self.font.render("Prueba", True, (248, 179, 51))
self.text_render_selected = self.font2.render("Prueba", True, (188, 8, 37))
def __init__(self, x, y, font_code, image_code):
'''
@brief Consturctor de CarFeatures
@param x posición de las características en el eje x
@param y posición en el eje y
@param font_code código de la fuente a usar
@param image_code código de la imagen a usar
'''
#Asignamos posición en la pantalla
self.x = x
self.y = y
#Cargamos los nombres de cada carcterísticas
self.text_speed = resource.get_font(font_code,
30).render('Velocidad', True,
(0, 0, 0))
#Situamos la posición de cada una de ellas
self.text_speed_y = y
self.text_aceleration = resource.get_font(font_code, 30).render(
u'Aceleración', True, (0, 0, 0))
self.text_aceleration_y = self.y + self.text_speed.get_height() + 15
self.text_rotation = resource.get_font(font_code, 30).render(
'Giro', True, (0, 0, 0))
self.text_rotation_y = self.text_aceleration_y + self.text_aceleration.get_height(
) + 15
#Cargamos la imagen
self.indicator = resource.get_image(image_code)
#Inicializamos los valores de cada una de las características
self.speed = 0
self.aceleration = 0
self.rotation = 0
def __init__(self, game, path_xml):
"""
@brief Constructor
@param game Referencia a game
@param path_xml Ruta del archivo xml con las características del menú
"""
basicmenu.BasicMenu.__init__(self, game)
# Cambiamos el titulo de la ventana
pygame.display.set_caption("Zycars: Menú Principal")
parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
# Le pasamos el archivo parseado a BasicMenu para que obtenga los elementos básicos
self.parser_basic_info(parse)
self.tiny_font = resource.get_font("cheesebu", 18)
self.developer = self.font.render("Desarrollador", True, (0, 0, 0))
self.developer_name = self.font.render(u"José J. Marente Florín", True, (189, 9, 38))
self.developer_email = self.tiny_font.render(u"*****@*****.**", True, (189, 9, 38))
self.developer_web = self.tiny_font.render(u"http://code.google.com/p/zycars/", True, (189, 9, 38))
self.artist = self.font.render(u"Diseñador gráfico", True, (0, 0, 0))
self.artist_name = self.font.render(u"David Nieto Rojas", True, (189, 9, 38))
self.artist_email = self.tiny_font.render("*****@*****.**", True, (189, 9, 38))
self.artist_web = self.tiny_font.render(u"http://www.deividart.com", True, (189, 9, 38))
self.music = self.font.render(u"Música", True, (0, 0, 0))
self.music_name1 = self.font.render(u"Bob Wizman", True, (189, 9, 38))
self.music_name2 = self.font.render(u"Pirato Ketchup", True, (189, 9, 38))
self.music_name3 = self.font.render(u"Los Cadaver", True, (189, 9, 38))
self.music_name4 = self.font.render(u"The Wavers", True, (189, 9, 38))
self.music_name5 = self.font.render(u"Zamalska", True, (189, 9, 38))
self.music_web = self.tiny_font.render(u"http://www.jamendo.com", True, (189, 9, 38))
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, 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, message, font_code, max_size, increase, centerx,
centery, color, time):
'''
@brief Constructor.
@param message Cadena de texto con el mensaje a mostrar.
@param font_code Codigo de la fuente a usar.
@param max_size Tamaño máximo de la fuente.
@param increase Incermento de la superficie
@param centerx Posición central del mensaje en x.
@param centery Posición central del mensaje en y.
@param color Color del mensaje.
@param time Duración del mensaje en pantalla.
'''
#Asignamos los distintos valores
self.font = resource.get_font(font_code, max_size)
self.message = self.font.render(message, True, color)
self.actual_surface = self.message
self.centerx = centerx
self.centery = centery
self.total_time = time
self.start_time = None
self.scale = 0
self.increase_scale = increase
self.complete_advice = False
#Obtenemos la superficie inicial, con el tamaño mas pequeño de la escala
self.actual_surface = pygame.transform.rotozoom(
self.message, 0, self.scale)
self.rect = self.actual_surface.get_rect()
self.rect.centerx = centerx
self.rect.centery = centery
def __init__(self, message, font_code, max_size, increase, centerx,
centery, color, time):
'''
@brief Constructor.
@param message Cadena de texto con el mensaje a mostrar.
@param font_code Codigo de la fuente a usar.
@param max_size Tamaño máximo de la fuente.
@param increase Incermento de la superficie
@param centerx Posición central del mensaje en x.
@param centery Posición central del mensaje en y.
@param color Color del mensaje.
@param time Duración del mensaje en pantalla.
'''
#Asignamos los distintos valores
self.font = resource.get_font(font_code, max_size)
self.message = self.font.render(message, True, color)
self.actual_surface = self.message
self.centerx = centerx
self.centery = centery
self.total_time = time
self.start_time = None
self.scale = 0
self.increase_scale = increase
self.complete_advice = False
#Obtenemos la superficie inicial, con el tamaño mas pequeño de la escala
self.actual_surface = pygame.transform.rotozoom(self.message, 0,
self.scale)
self.rect = self.actual_surface.get_rect()
self.rect.centerx = centerx
self.rect.centery = centery
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 get_font(self, cls, name):
if debug_theme:
print "Theme.get_font(%r, %r)" % (cls, name)
spec = self.get(cls, name)
if spec:
if debug_theme:
print "font spec =", spec
return resource.get_font(*spec)
def get_font(self, cls, name): if debug_theme: print "Theme.get_font(%r, %r)" % (cls, name) spec = self.get(cls, name) if spec: if debug_theme: print "font spec =", spec return resource.get_font(*spec)
def __init__(self,
font_code,
size_font,
inicial_scale,
increase_scale,
color,
number=3,
sound_file=None):
'''
@brief Constructor
@param font_code Código de la fuente a usar
@param size_font Tamaño de la fuente a usar
@param inicial_scale Escala inicial
@param increase_scale Parametro de incremento de la escala
@param color Color de la fuente
@param number Número en segundos de la cuenta atrás
'''
#Obtenemos la fuente
self.font = resource.get_font(font_code, size_font)
#Creamos la cola de elementos
self.elements = deque()
self.sound = None
if sound_file:
self.sound = resource.get_sound(sound_file)
self.sound.set_volume(config.Config().get_sound_volume())
#Introducimos todos los elementos
for i in range(1, number + 1):
self.elements.appendleft(self.font.render(str(i), True, color))
#Introducimos el fin de la cuenta atras
self.elements.append(self.font.render('Go!!!', True, color))
#Obtenemos el primer elemento de la cola
self.actual_element = self.elements.popleft()
self.element_modify = self.actual_element
#Asinamos valores
self.inicial_scale = inicial_scale
self.increase_scale = increase_scale
self.scale = inicial_scale
#Obtenemos el centro de la pantalla para que todos los número queden
#igual posicionados
self.centerx = pygame.display.get_surface().get_width() / 2
self.centery = pygame.display.get_surface().get_height() / 2
#Variables que representan posicion de destino, tiempo inicial y
#condicion de parada, respectivamente
self.rect_destiny = self.actual_element.get_rect()
self.rect_destiny.centerx = self.centerx
self.rect_destiny.centery = self.centery
self.__start = None
self.sound_start = False
self.stop = False
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, 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, 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 __init__(self,
font_code,
font_size,
color,
x,
y,
text,
minutes=0,
seconds=0,
hseconds=0):
'''
@brief Constructor de timer.
@param font_code Código de la fuente a usar.
@param font_size Tamaño de la fuente.
@param color Color de la fuente.
@param x Posición en el eje x.
@param y Posición en el eje y.
@param text Texto que representará al cronómetro.
@param minutes Minutos iniciales, por defecto 0.
@param seconds Segundos iniciales, por defecto 0.
@param hseconds Centésimas de segundo inidicales, por defecto 0.
'''
#Pasamos los minutos a segundos
self.__start = minutes * 60.0
#Añadimos los segundos
self.__start += seconds
#Pasamos las centésimas de segundo a segundos
self.__start += hseconds / 100.0
#Asignamos variable
self.minutes = minutes
self.seconds = seconds
self.hseconds = hseconds
#Chivatos
self.running = False
self.time_paused = False
self.time_stopped = False
#Cargamos la fuente necesaria
self.font = resource.get_font(font_code, font_size)
self.color = color
self.x = x
self.y = y
#Obtenemos la superficie con el texto dado
self.text = self.font.render(text, True, color)
self.rect_text = self.text.get_rect()
self.surface = None
self.update_surface()
def __init__(self, font_code, size_font, inicial_scale, increase_scale,
color, number = 3, sound_file = None):
'''
@brief Constructor
@param font_code Código de la fuente a usar
@param size_font Tamaño de la fuente a usar
@param inicial_scale Escala inicial
@param increase_scale Parametro de incremento de la escala
@param color Color de la fuente
@param number Número en segundos de la cuenta atrás
'''
#Obtenemos la fuente
self.font = resource.get_font(font_code, size_font)
#Creamos la cola de elementos
self.elements = deque()
self.sound = None
if sound_file:
self.sound = resource.get_sound(sound_file)
self.sound.set_volume(config.Config().get_sound_volume())
#Introducimos todos los elementos
for i in range(1, number + 1):
self.elements.appendleft(self.font.render(str(i), True, color))
#Introducimos el fin de la cuenta atras
self.elements.append(self.font.render('Go!!!', True, color))
#Obtenemos el primer elemento de la cola
self.actual_element = self.elements.popleft()
self.element_modify = self.actual_element
#Asinamos valores
self.inicial_scale = inicial_scale
self.increase_scale = increase_scale
self.scale = inicial_scale
#Obtenemos el centro de la pantalla para que todos los número queden
#igual posicionados
self.centerx = pygame.display.get_surface().get_width() / 2
self.centery = pygame.display.get_surface().get_height() / 2
#Variables que representan posicion de destino, tiempo inicial y
#condicion de parada, respectivamente
self.rect_destiny = self.actual_element.get_rect()
self.rect_destiny.centerx = self.centerx
self.rect_destiny.centery = self.centery
self.__start = None
self.sound_start = False
self.stop = False
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 __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):
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, font_code, font_size, color, x, y, text, minutes = 0,
seconds = 0, hseconds = 0):
'''
@brief Constructor de timer.
@param font_code Código de la fuente a usar.
@param font_size Tamaño de la fuente.
@param color Color de la fuente.
@param x Posición en el eje x.
@param y Posición en el eje y.
@param text Texto que representará al cronómetro.
@param minutes Minutos iniciales, por defecto 0.
@param seconds Segundos iniciales, por defecto 0.
@param hseconds Centésimas de segundo inidicales, por defecto 0.
'''
#Pasamos los minutos a segundos
self.__start = minutes * 60.0
#Añadimos los segundos
self.__start += seconds
#Pasamos las centésimas de segundo a segundos
self.__start += hseconds / 100.0
#Asignamos variable
self.minutes = minutes
self.seconds = seconds
self.hseconds = hseconds
#Chivatos
self.running = False
self.time_paused = False
self.time_stopped = False
#Cargamos la fuente necesaria
self.font = resource.get_font(font_code, font_size)
self.color = color
self.x = x
self.y = y
#Obtenemos la superficie con el texto dado
self.text = self.font.render(text, True, color)
self.rect_text = self.text.get_rect()
self.surface = None
self.update_surface()
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):
'''
#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):
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,
game,
game_mode,
path,
best_total_time,
best_lap,
laps=3):
'''
@brief Constructor
@param game Referencia a game
@param path archivo xml del circuito en cuestión
'''
state.State.__init__(self, game)
#Musica circuito
self.music_file = None
self.game_mode = game_mode
#Coche del jugador.
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 0, 0, 0)
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 500, 400, 0)
#Grupo de sprites que contentrá los coches de la IA.
self.ia_cars = []
#Checkpoints para la ia
self.ia_checkpoints = [
checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self)
]
#Grupo de sprites que contendrá las cajas de items.
#self.items_box = pygame.sprite.Group()
self.items_box = pygame.sprite.Group()
#Checkpoints que posee el circuito
self.checkpoints = checkpoint.CheckPoints(self)
#Puntos objetivos por los que tienen que pasar la IA
self.ia_checks = {}
#Grupo de sprite que contendrá las balas.
self.bullets = pygame.sprite.Group()
#Grupo de sprite que contendrás las manchas de aceite
self.oils = pygame.sprite.Group()
#Grupo para las pelotas
self.balls = pygame.sprite.Group()
#Grupo para las pelotas
self.gums = pygame.sprite.Group()
#Animaciones que estarán en el juego
self.static_animations = []
self.advices = []
#Gestor de colisiones
self.collision_manager = collisionmanager.CollisionManager()
#Linea de salida
self.start = None
self.complete = False
#Vueltas al circuito
self.max_laps = laps
self.actual_laps = 0
#Fuentes que usaremos
self.font = resource.get_font('cheesebu', 35)
self.font2 = resource.get_font('cheesebu', 70)
#Contador de vuelta
self.laps_counter = None
self.laps_counter_rect = None
#Obtenemos una superficie negra del mismo tamaño que la pantalla
self.fade_surface = pygame.Surface(
(pygame.display.get_surface().get_width(),
pygame.display.get_surface().get_height()))
self.fadein = True
self.fadeout = False
self.fade_speed = 5
self.fadeout_speed = 5
self.actual_alpha = 255
#Actualizamos el contador
self.update_laps_counter()
#Cronómetros de carrera
self.actual_time = timer.Timer('cheesebu', 20, (0, 0, 0), 725, 10,
"Actual:")
self.total_time = timer.Timer('cheesebu', 20, (0, 0, 0), 725, 80,
"Total:")
#Mejor tiempo total del circuito
self.best_total_time = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 80,
"Mejor total:", best_total_time[0],
best_total_time[1],
best_total_time[2])
#Mejor tiempo de vuelta del circuito
self.best_time = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 10,
"Mejor Vuelta:", best_lap[0], best_lap[1],
best_lap[2])
#Mejor vuelta del jugador
self.best_lap_player = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 10,
"Mejor Vuelta:", 100, 0, 0)
#Tiempos por vueltas
self.lap_times = []
#Circuito actual que vamos a jugar.
self.circuit = circuit.Circuit(self, path)
#Menú de pausa
self.pause = pausemenu.PauseMenu(self.game, self, 'menu/pausemenu.xml')
#Cuenta atras
#self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05, (221, 113, 5), 3, 'countdown')
self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05,
(0, 0, 0), 3, 'countdown')
#Marcador de las posiciones de los jugadores
self.position_board = PositionBoard(20, 10, 'image_position1',
'image_position2')
#Pasamos al estado de cuenta atras
self.actual_state = None
self.position = {1: 'st', 2: 'nd', 3: 'rd', 4: 'th'}
self.player_position = 1
#Actualizamos al jugador y la IA para posicionar bien la pantalla
self.player.update()
aux_ia_cars = []
#Actualizamos a la IA una primera vez y le situamos los puntos objetivos
for i in range(len(self.ia_cars)):
self.ia_cars[i].update()
self.ia_cars[i].set_targets(self.ia_checks)
#Asociamos checkpoints con la IA
aux_ia_cars.append((self.ia_cars[i], self.ia_checkpoints[i]))
self.ia_cars = aux_ia_cars
#Actualizamos por primera vez el marcador de posiciones
self.position_board.update((self.player, self.checkpoints),
self.ia_cars)
#Posicionamos la pantalla
self.scroll_control()
#Sonidos de juego
self.sounds = {}
self.sounds['collected_item'] = resource.get_sound('item_collected')
self.sounds['missile_explosion'] = resource.get_sound(
'missile_explosion')
self.sounds['ball_explosion'] = resource.get_sound('ball_explosion')
self.sounds['ball_rebound'] = resource.get_sound('ball_rebound')
self.sounds['yaw'] = resource.get_sound('yaw')
for key in self.sounds.keys():
self.sounds[key].set_volume(config.Config().get_sound_volume())
def __init__(self, game, game_mode, path, best_total_time, best_lap,
laps = 3):
'''
@brief Constructor
@param game Referencia a game
@param path archivo xml del circuito en cuestión
'''
state.State.__init__(self, game)
#Musica circuito
self.music_file = None
self.game_mode = game_mode
#Coche del jugador.
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 0, 0, 0)
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 500, 400, 0)
#Grupo de sprites que contentrá los coches de la IA.
self.ia_cars = []
#Checkpoints para la ia
self.ia_checkpoints = [checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self),
checkpoint.CheckPoints(self)]
#Grupo de sprites que contendrá las cajas de items.
#self.items_box = pygame.sprite.Group()
self.items_box = pygame.sprite.Group()
#Checkpoints que posee el circuito
self.checkpoints = checkpoint.CheckPoints(self)
#Puntos objetivos por los que tienen que pasar la IA
self.ia_checks = {}
#Grupo de sprite que contendrá las balas.
self.bullets = pygame.sprite.Group()
#Grupo de sprite que contendrás las manchas de aceite
self.oils = pygame.sprite.Group()
#Grupo para las pelotas
self.balls = pygame.sprite.Group()
#Grupo para las pelotas
self.gums = pygame.sprite.Group()
#Animaciones que estarán en el juego
self.static_animations = []
self.advices = []
#Gestor de colisiones
self.collision_manager = collisionmanager.CollisionManager()
#Linea de salida
self.start = None
self.complete = False
#Vueltas al circuito
self.max_laps = laps
self.actual_laps = 0
#Fuentes que usaremos
self.font = resource.get_font('cheesebu', 35)
self.font2 = resource.get_font('cheesebu', 70)
#Contador de vuelta
self.laps_counter = None
self.laps_counter_rect = None
#Obtenemos una superficie negra del mismo tamaño que la pantalla
self.fade_surface = pygame.Surface((pygame.display.get_surface().get_width(), pygame.display.get_surface().get_height()))
self.fadein = True
self.fadeout = False
self.fade_speed = 5
self.fadeout_speed = 5
self.actual_alpha = 255
#Actualizamos el contador
self.update_laps_counter()
#Cronómetros de carrera
self.actual_time = timer.Timer('cheesebu', 20, (0, 0, 0), 725, 10,
"Actual:")
self.total_time = timer.Timer('cheesebu', 20, (0, 0, 0), 725, 80,
"Total:")
#Mejor tiempo total del circuito
self.best_total_time = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 80,
"Mejor total:", best_total_time[0],
best_total_time[1],best_total_time[2])
#Mejor tiempo de vuelta del circuito
self.best_time = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 10,
"Mejor Vuelta:", best_lap[0],
best_lap[1], best_lap[2])
#Mejor vuelta del jugador
self.best_lap_player = timer.Timer('cheesebu', 20, (0, 0, 0), 600, 10,
"Mejor Vuelta:", 100, 0, 0)
#Tiempos por vueltas
self.lap_times = []
#Circuito actual que vamos a jugar.
self.circuit = circuit.Circuit(self, path)
#Menú de pausa
self.pause = pausemenu.PauseMenu(self.game, self, 'menu/pausemenu.xml')
#Cuenta atras
#self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05, (221, 113, 5), 3, 'countdown')
self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05,
(0, 0, 0), 3, 'countdown')
#Marcador de las posiciones de los jugadores
self.position_board = PositionBoard(20, 10, 'image_position1',
'image_position2')
#Pasamos al estado de cuenta atras
self.actual_state = None
self.position = {1: 'st', 2: 'nd', 3: 'rd', 4: 'th'}
self.player_position = 1
#Actualizamos al jugador y la IA para posicionar bien la pantalla
self.player.update()
aux_ia_cars = []
#Actualizamos a la IA una primera vez y le situamos los puntos objetivos
for i in range(len(self.ia_cars)):
self.ia_cars[i].update()
self.ia_cars[i].set_targets(self.ia_checks)
#Asociamos checkpoints con la IA
aux_ia_cars.append((self.ia_cars[i], self.ia_checkpoints[i]))
self.ia_cars = aux_ia_cars
#Actualizamos por primera vez el marcador de posiciones
self.position_board.update((self.player, self.checkpoints),
self.ia_cars)
#Posicionamos la pantalla
self.scroll_control()
#Sonidos de juego
self.sounds = {}
self.sounds['collected_item'] = resource.get_sound('item_collected')
self.sounds['missile_explosion'] = resource.get_sound('missile_explosion')
self.sounds['ball_explosion'] = resource.get_sound('ball_explosion')
self.sounds['ball_rebound'] = resource.get_sound('ball_rebound')
self.sounds['yaw'] = resource.get_sound('yaw')
for key in self.sounds.keys():
self.sounds[key].set_volume(config.Config().get_sound_volume())
def parser_basic_info(self, parse):
'''
@brief Método que parsea los componentes básicos del menú
@param parse Archivo xml parsea com xml.dom.minidom
'''
parent = parse.firstChild
#Obtenemos la imagen de fondo
image_code = str(parent.getAttribute('background'))
self.background = resource.get_image(image_code)
#Obtenemos el cursor del menú
#cursor_xml = str(parent.getAttribute('cursor'))
#self.cursor = cursor.Cursor(data.get_path_xml(cursor_xml))
self.cursor = cursor.Cursor()
self.music_file = None
if parent.hasAttribute('music'):
self.music_file = str(parent.getAttribute('music'))
#Obtenemos el titulo del menú
for element in parse.getElementsByTagName('title'):
#Obtenemos tamaño y fuente
font_code = str(element.getAttribute('font'))
font_size = int(element.getAttribute('size'))
self.font = resource.get_font(font_code, font_size)
text = element.getAttribute('text')
#Colores
r = int(element.getAttribute('r'))
g = int(element.getAttribute('g'))
b = int(element.getAttribute('b'))
color = (r, g, b)
#Renderizamos
self.title = self.font.render(text, True, color)
#Obtenemos la posición
self.title_rect = self.title.get_rect()
self.title_rect.x = int(element.getAttribute('x'))
self.title_rect.y = int(element.getAttribute('y'))
#Obtenemos todas las imagenes que aparecen
for element in parse.getElementsByTagName('image'):
#Obtenemos la imagen
image_code = str(element.getAttribute('image_code'))
image = resource.get_image(image_code)
#Si la imagen tiene el atributo scale
if element.hasAttribute('scale'):
#Escalamos la imagen
scale = float(element.getAttribute('scale'))
if scale != 1:
temporal = image.copy()
image = pygame.transform.rotozoom(temporal, 0, scale)
#Obtenemos la posición de la imagen
rect = image.get_rect()
rect.x = int(element.getAttribute('x'))
rect.y = int(element.getAttribute('y'))
#La incluimos en la lista de imagenes
self.images.append((image_code, image, rect))
#Obtenemos los distintos botones del menú
for element in parse.getElementsByTagName('option'):
#Ruta del archivo xml con la configuración
xml_file = str(element.getAttribute('xml_file'))
#Fuente y texto que apareceran en el boton
font_code = str(element.getAttribute('font'))
text = element.getAttribute('text')
x = int(element.getAttribute('x'))
y = int(element.getAttribute('y'))
show_text = True
#Miramos si se indica si se debe mostrar o no el texto en el botón
if element.hasAttribute('show_text'):
show_text = element.getAttribute('show_text')
show_text = button.strTobool(show_text)
type_button = 'normal'
#Obtenemos el tipo de boton
if element.hasAttribute('type'):
type_button = str(element.getAttribute('type'))
#Según el tipo de boton obtendremos un boton u otro
if type_button == 'normal':
aux_button = button.Button(self, xml_file, text, x, y,
font_code, show_text)
elif type_button == 'image_button':
image_code = str(element.getAttribute('image'))
image_x = int(element.getAttribute('image_x'))
image_y = int(element.getAttribute('image_y'))
aux_button = imagebutton.ImageButton(self, xml_file, text, x,
y, font_code, image_code,
image_x, image_y,
show_text)
#Lo añadimos a la lista de botones
self.buttons.append(aux_button)
def parser_basic_info(self, parse):
parent = parse.firstChild
image_code = str(parent.getAttribute('background'))
self.background = resource.get_image(image_code)
cursor_xml = str(parent.getAttribute('cursor'))
self.cursor = cursor.Cursor(data.get_path_xml(cursor_xml))
for element in parse.getElementsByTagName('title'):
font_code = str(element.getAttribute('font'))
font_size = int(element.getAttribute('size'))
font = resource.get_font(font_code, font_size)
text = element.getAttribute('text')
r = int(element.getAttribute('r'))
g = int(element.getAttribute('g'))
b = int(element.getAttribute('b'))
color = (r, g, b)
self.title = font.render(text, True, color)
self.title_rect = self.title.get_rect()
self.title_rect.x = int(element.getAttribute('x'))
self.title_rect.y = int(element.getAttribute('y'))
for element in parse.getElementsByTagName('image'):
image_code = str(element.getAttribute('image_code'))
image = resource.get_image(image_code)
if element.hasAttribute('scale'):
scale = float(element.getAttribute('scale'))
if scale != 1:
temporal = image.copy()
image = pygame.transform.rotozoom(temporal, 0, scale)
rect = image.get_rect()
rect.x = int(element.getAttribute('x'))
rect.y = int(element.getAttribute('y'))
self.images.append((image_code, image, rect))
for element in parse.getElementsByTagName('option'):
xml_file = str(element.getAttribute('xml_file'))
font_code = str(element.getAttribute('font'))
text = element.getAttribute('text')
x = int(element.getAttribute('x'))
y = int(element.getAttribute('y'))
show_text = True
if element.hasAttribute('show_text'):
show_text = element.getAttribute('show_text')
show_text = button.strTobool(show_text)
type_button = 'normal'
if element.hasAttribute('type'):
type_button = str(element.getAttribute('type'))
image_button = None
if type_button == 'normal':
aux_button = button.Button(xml_file, text, x, y, font_code, show_text, True)
elif type_button == 'image_button':
image_code = str(element.getAttribute('image'))
image_x = int(element.getAttribute('image_x'))
image_y = int(element.getAttribute('image_y'))
aux_button = imagebutton.ImageButton(xml_file, text, x, y, font_code, image_code, image_x, image_y, show_text, True)
self.buttons.append(aux_button)
def __init__(self, game, path, laps = 3):
'''
@brief Constructor
@param game Referencia a game
@param path archivo xml del circuito en cuestión
'''
state.State.__init__(self, game)
#Coche del jugador.
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 0, 0, 0)
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 500, 400, 0)
#Grupo de sprites que contentrá los coches de la IA.
self.ia_cars = []
#Checkpoints para la ia
self.ia_checkpoints = [checkpoint.CheckPoints(self),]
#Grupo de sprites que contendrá las cajas de items.
#self.items_box = pygame.sprite.Group()
self.items_box = pygame.sprite.Group()
#Checkpoints que posee el circuito
self.checkpoints = checkpoint.CheckPoints(self)
#Puntos objetivos por los que tienen que pasar la IA
self.ia_checks = {}
#Grupo de sprite que contendrá las balas.
self.bullets = pygame.sprite.Group()
#Grupo de sprite que contendrás las manchas de aceite
self.oils = pygame.sprite.Group()
#Grupo para las pelotas
self.balls = pygame.sprite.Group()
#Animaciones que estarán en el juego
self.static_animations = []
#Gestor de colisiones
self.collision_manager = collisionmanager.CollisionManager()
#Linea de salida
self.start = None
#Vueltas al circuito
self.max_laps = laps
self.actual_laps = 0
#Fuentes que usaremos
self.font = resource.get_font('cheesebu', 35)
self.font2 = resource.get_font('cheesebu', 70)
#Contador de vuelta
self.laps_counter = None
self.laps_counter_rect = None
#Actualizamos el contador
self.update_laps_counter()
#Cronómetros de carrera
self.actual_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 10, "Actual:")
self.best_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 80, "Mejor:")
self.best_time.set_minutes(10)
self.total_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 150, "Total:")
#Circuito actual que vamos a jugar.
self.circuit = circuit.Circuit(self, path)
#Rejilla
self.grid = resource.get_image("rejilla")
#Menú de pausa
self.pause = pausemenu.PauseMenu(self.game, self, 'menu/pausemenu.xml')
#Cuenta atras
self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05, (221, 113, 5), 0)
#Marcador de las posiciones de los jugadores
self.position_board = PositionBoard(20, 10, 'image_position1', 'image_position2')
#Pasamos al estado de cuenta atras
self.actual_state = 'countdown'
self.position = {1: 'st', 2: 'nd', 3: 'rd', 4: 'th'}
self.player_position = 1
#Actualizamos al jugador y la IA para posicionar bien la pantalla
self.player.update()
aux_ia_cars = []
#Actualizamos a la IA una primera vez y le situamos los puntos objetivos
for i in range(len(self.ia_cars)):
self.ia_cars[i].update()
self.ia_cars[i].set_targets(self.ia_checks)
#Asociamos checkpoints con la IA
aux_ia_cars.append((self.ia_cars[i], self.ia_checkpoints[i]))
self.ia_cars = aux_ia_cars
#Actualizamos por primera vez el marcador de posiciones
self.position_board.update((self.player, self.checkpoints), self.ia_cars)
#Posicionamos la pantalla
self.scroll_control()
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 __init__(self, xml_file, text, centerx, centery, font_code, center=True):
self.text = text
parser = xml.dom.minidom.parse(data.get_path_xml(xml_file))
self.centerx = centerx
self.centery = centery
aux_rect = None
father = parser.firstChild
self.text_position = str(father.getAttribute("text_position"))
if father.hasAttribute("on_button"):
self.on_button = strTobool(str(father.getAttribute("on_button")))
else:
self.on_button = True
for element in parser.getElementsByTagName("normal"):
normal_image_code = str(element.getAttribute("normal_image"))
self.normal_image = resource.get_image(normal_image_code)
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"))
for element in parser.getElementsByTagName("selected"):
selected_image_code = str(element.getAttribute("selected_image"))
self.selected_image = resource.get_image(selected_image_code)
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"))
self.rect_draw = self.normal_image.get_rect()
self.rect_draw.centery = self.centery
self.rect_draw.centerx = self.centerx
for element in parser.getElementsByTagName("normal_text"):
font_size = int(element.getAttribute("size"))
r = int(element.getAttribute("r"))
g = int(element.getAttribute("g"))
b = int(element.getAttribute("b"))
color = (r, g, b)
self.normal_font = resource.get_font(font_code, font_size)
self.text_render_normal = self.normal_font.render(self.text, True, color)
if element.hasAttribute("angle"):
angle = int(element.getAttribute("angle"))
self.text_render_normal = pygame.transform.rotozoom(self.text_render_normal, angle, 1)
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)
if len(parser.getElementsByTagName("selected_text")) > 0:
for element in parser.getElementsByTagName("selected_text"):
font_size = int(element.getAttribute("size"))
r = int(element.getAttribute("r"))
g = int(element.getAttribute("g"))
b = int(element.getAttribute("b"))
color = (r, g, b)
self.selected_font = resource.get_font(font_code, font_size)
self.text_render_selected = self.selected_font.render(self.text, True, color)
if element.hasAttribute("angle"):
angle = int(element.getAttribute("angle"))
self.text_render_selected = pygame.transform.rotozoom(self.text_render_selected, angle, 1)
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)
else:
self.text_render_selected = self.text_render_normal
self.selected_text_rect = self.normal_text_rect
self.selected = False
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
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, laps = 3):
'''
@brief Constructor
@param game Referencia a game
@param path archivo xml del circuito en cuestión
'''
state.State.__init__(self, game)
#Coche del jugador.
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 0, 0, 0)
#self.player = playercar.PlayerCar(self, 'cars/coche_prueba_yellow.xml', 500, 400, 0)
#Grupo de sprites que contentrá los coches de la IA.
self.ia_cars = pygame.sprite.Group()
#Grupo de sprites que contendrá las cajas de items.
#self.items_box = pygame.sprite.Group()
self.items_box = pygame.sprite.Group()
#Checkpoints que posee el circuito
self.checkpoints = checkpoint.CheckPoints(self)
#Grupo de sprite que contendrá las balas.
self.bullets = pygame.sprite.Group()
#Grupo de sprite que contendrás las manchas de aceite
self.oils = pygame.sprite.Group()
#Grupo para las pelotas
self.balls = pygame.sprite.Group()
#Gestor de colisiones
self.collision_manager = collisionmanager.CollisionManager()
#Linea de salida
self.start = None
#Vueltas al circuito
self.max_laps = laps
self.actual_laps = 0
#Contador de vueltas
self.font = resource.get_font('cheesebu', 30)
self.laps_counter = None
self.laps_counter_rect = None
self.update_laps_counter()
#Cronómetros de carrera
self.actual_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 10, "Actual:")
self.best_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 80, "Mejor:")
self.best_time.set_minutes(10)
self.total_time = timer.Timer('cheesebu', 30, (0, 0, 0), 700, 150, "Total:")
#Circuito actual que vamos a jugar.
self.circuit = circuit.Circuit(self, path)
#Rejilla
self.grid = resource.get_image("rejilla")
#Menú de pausa
self.pause = pausemenu.PauseMenu(self.game, self, 'menu/pausemenu.xml')
#Cuenta atras
self.count_down = countdown.CountDown('cheesebu', 300, 0.02, 0.05, (221, 113, 5), 0)
#Indicamos el estado
self.actual_state = ''
#Actualizamos el estado en carrera para posicionar bien la pantalla
#self.update()
self.player.update()
for ia_car in self.ia_cars:
ia_car.update(self.player.rect.x, self.player.rect.y)
self.scroll_control()
#Pasamos al estado de cuenta atras
self.actual_state = 'countdown'
def __init__(self, menu, xml_file, text, centerx, centery, font_code, show_text = True, center = 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
#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, 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 init_light_theme():
color1 = (227, 227, 159) # a light yellow
color2 = (173, 222, 78) # a light green
color3 = (77, 148, 83) # a dark green
color4 = white_color
color5 = near_white_color
color6 = light_gray_color
color7 = gray_color
color8 = dark_gray_color
color9 = black_color
light_theme.set(class_name='View',
state='normal',
key='background_color',
value=(color4, color5))
light_theme.set(class_name='View',
state='focused',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='View',
state='selected',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='View',
state='normal',
key='border_color',
value=color6)
light_theme.set(class_name='View',
state='normal',
key='border_widths',
value=0)
light_theme.set(class_name='View',
state='normal',
key='margin',
value=(6, 6))
light_theme.set(class_name='View',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='View',
state='normal',
key='shadowed',
value=False)
light_theme.set(class_name='Scene',
state='normal',
key='background_color',
value=(color5, color4))
light_theme.set(class_name='Label',
state='normal',
key='text_color',
value=color8)
light_theme.set(class_name='Label',
state='selected',
key='text_color',
value=color3)
light_theme.set(class_name='Label',
state='normal',
key='text_shadow_color',
value=color4)
light_theme.set(class_name='Label',
state='normal',
key='text_shadow_offset',
value=(0, 1))
light_theme.set(class_name='Label',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='Label',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='Label',
state='normal',
key='font',
value=resource.get_font(16))
light_theme.label_height = 16 + 6 * 2 # font size + padding above/below
light_theme.set(class_name='Button',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='Button',
state='focused',
key='background_color',
value=color1)
light_theme.set(class_name='Button',
state='normal',
key='text_color',
value=color8)
light_theme.set(class_name='Button',
state='normal',
key='font',
value=resource.get_font(16, use_bold=True))
light_theme.set(class_name='Button',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='Button',
state='normal',
key='border_color',
value=color6)
light_theme.button_height = 16 + 6 * 2 # font size + padding above/below
light_theme.set(class_name='ImageButton',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='ImageButton',
state='focused',
key='background_color',
value=color1)
light_theme.set(class_name='ImageButton',
state='normal',
key='border_color',
value=color6)
light_theme.set(class_name='ImageButton',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='ImageButton',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='ScrollbarThumbView',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='ScrollbarThumbView',
state='focused',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='ScrollbarThumbView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='ScrollbarView',
state='normal',
key='background_color',
value=color5)
light_theme.set(class_name='ScrollbarView',
state='normal',
key='border_widths',
value=(1, 1, 0, 0)) # t l b r
light_theme.set(class_name='ScrollView',
state='normal',
key='hole_color',
value=whites_twin_color)
light_theme.set(class_name='ScrollView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SliderTrackView',
state='normal',
key='background_color',
value=(color5, color4))
light_theme.set(class_name='SliderTrackView',
state='normal',
key='value_color',
value=(color1, color2))
light_theme.set(class_name='SliderTrackView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SliderView',
state='normal',
key='background_color',
value=clear_color)
light_theme.set(class_name='SliderView',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='ImageView',
state='normal',
key='background_color',
value=None)
light_theme.set(class_name='ImageView',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='Checkbox',
state='normal',
key='background_color',
value=clear_color)
light_theme.set(class_name='Checkbox',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='Checkbox',
state='focused',
key='check_label.background_color',
value=(color1, color2))
light_theme.set(class_name='Checkbox',
state='normal',
key='check_label.border_widths',
value=1)
light_theme.set(class_name='Checkbox',
state='normal',
key='label.background_color',
value=clear_color)
light_theme.set(class_name='SpinnerView',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='DialogView',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='DialogView',
state='normal',
key='shadowed',
value=True)
light_theme.shadow_size = 140
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.background_color',
value=color7)
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.text_color',
value=color4)
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.text_shadow_offset',
value=None)
light_theme.set(class_name='AlertView',
state='normal',
key='message_label.background_color',
value=clear_color)
light_theme.set(class_name='AlertView',
state='normal',
key='font',
value=resource.get_font(16))
light_theme.set(class_name='AlertView',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='NotificationView',
state='normal',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='NotificationView',
state='normal',
key='border_color',
value=color3)
light_theme.set(class_name='NotificationView',
state='normal',
key='border_widths',
value=(0, 2, 2, 2))
light_theme.set(class_name='NotificationView',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='NotificationView',
state='normal',
key='message_label.background_color',
value=clear_color)
light_theme.set(class_name='SelectView',
state='normal',
key='disclosure_triangle_color',
value=color8)
light_theme.set(class_name='SelectView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SelectView',
state='normal',
key='top_label.focusable',
value=False)
light_theme.set(class_name='TextField',
state='focused',
key='label.background_color',
value=(color1, color2))
light_theme.set(class_name='TextField',
state='normal',
key='placeholder_text_color',
value=color6)
light_theme.set(class_name='TextField',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='TextField',
state='normal',
key='text_color',
value=color9)
light_theme.set(class_name='TextField',
state='disabled',
key='text_color',
value=color6)
light_theme.set(class_name='TextField',
state='normal',
key='blink_cursor',
value=True)
light_theme.set(class_name='TextField',
state='normal',
key='cursor_blink_duration',
value=450)
light_theme.set(class_name='GridView',
state='normal',
key='background_color',
value=color4)
light_theme.set(class_name='GridView',
state='normal',
key='line_color',
value=color6)
def init_light_theme():
color1 = (0, 0, 0) # a light yellow
color2 = (255, 255, 255) # a light green
color3 = (0, 0, 0) # a dark green
color4 = white_color
color5 = near_white_color
color6 = light_gray_color
color7 = gray_color
color8 = dark_gray_color
color9 = black_color
light_theme.set(class_name='View',
state='normal',
key='background_color',
value=(color4, color5))
light_theme.set(class_name='View',
state='focused',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='View',
state='selected',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='View',
state='normal',
key='border_color',
value=color6)
light_theme.set(class_name='View',
state='normal',
key='border_widths',
value=0)
light_theme.set(class_name='View',
state='normal',
key='margin',
value=(6, 6))
light_theme.set(class_name='View',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='View',
state='normal',
key='shadowed',
value=False)
light_theme.set(class_name='Scene',
state='normal',
key='background_color',
value=(color5, color4))
light_theme.set(class_name='Label',
state='normal',
key='text_color',
value=color8)
light_theme.set(class_name='Label',
state='selected',
key='text_color',
value=color3)
light_theme.set(class_name='Label',
state='normal',
key='text_shadow_color',
value=color4)
light_theme.set(class_name='Label',
state='normal',
key='text_shadow_offset',
value=(0, 1))
light_theme.set(class_name='Label',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='Label',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='Label',
state='normal',
key='font',
value=resource.get_font(16))
light_theme.label_height = 16 + 6 * 2 # font size + padding above/below
light_theme.set(class_name='Button',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='Button',
state='focused',
key='background_color',
value=color1)
light_theme.set(class_name='Button',
state='normal',
key='text_color',
value=color8)
light_theme.set(class_name='Button',
state='normal',
key='font',
value=resource.get_font(12, use_bold=True))
light_theme.set(class_name='Button',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='Button',
state='normal',
key='border_color',
value=color6)
light_theme.button_height = 16 + 6 * 2 # font size + padding above/below
light_theme.set(class_name='ImageButton',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='ImageButton',
state='focused',
key='background_color',
value=color1)
light_theme.set(class_name='ImageButton',
state='normal',
key='border_color',
value=color6)
light_theme.set(class_name='ImageButton',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='ImageButton',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='ScrollbarThumbView',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='ScrollbarThumbView',
state='focused',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='ScrollbarThumbView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='ScrollbarView',
state='normal',
key='background_color',
value=color5)
light_theme.set(class_name='ScrollbarView',
state='normal',
key='border_widths',
value=(1, 1, 0, 0)) # t l b r
light_theme.set(class_name='ScrollView',
state='normal',
key='hole_color',
value=whites_twin_color)
light_theme.set(class_name='ScrollView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SliderTrackView',
state='normal',
key='background_color',
value=(color5, color4))
light_theme.set(class_name='SliderTrackView',
state='normal',
key='value_color',
value=(color1, color2))
light_theme.set(class_name='SliderTrackView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SliderView',
state='normal',
key='background_color',
value=clear_color)
light_theme.set(class_name='SliderView',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='ImageView',
state='normal',
key='background_color',
value=None)
light_theme.set(class_name='ImageView',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='Checkbox',
state='normal',
key='background_color',
value=clear_color)
light_theme.set(class_name='Checkbox',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='Checkbox',
state='focused',
key='check_label.background_color',
value=(color1, color2))
light_theme.set(class_name='Checkbox',
state='normal',
key='check_label.border_widths',
value=1)
light_theme.set(class_name='Checkbox',
state='normal',
key='label.background_color',
value=clear_color)
light_theme.set(class_name='SpinnerView',
state='normal',
key='border_widths',
value=None)
light_theme.set(class_name='DialogView',
state='normal',
key='background_color',
value=(color4, color6))
light_theme.set(class_name='DialogView',
state='normal',
key='shadowed',
value=True)
light_theme.shadow_size = 140
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.background_color',
value=color7)
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.text_color',
value=color4)
light_theme.set(class_name='AlertView',
state='normal',
key='title_label.text_shadow_offset',
value=None)
light_theme.set(class_name='AlertView',
state='normal',
key='message_label.background_color',
value=clear_color)
light_theme.set(class_name='AlertView',
state='normal',
key='font',
value=resource.get_font(16))
light_theme.set(class_name='AlertView',
state='normal',
key='padding',
value=(6, 6))
light_theme.set(class_name='NotificationView',
state='normal',
key='background_color',
value=(color1, color2))
light_theme.set(class_name='NotificationView',
state='normal',
key='border_color',
value=color3)
light_theme.set(class_name='NotificationView',
state='normal',
key='border_widths',
value=(0, 2, 2, 2))
light_theme.set(class_name='NotificationView',
state='normal',
key='padding',
value=(0, 0))
light_theme.set(class_name='NotificationView',
state='normal',
key='message_label.background_color',
value=clear_color)
light_theme.set(class_name='SelectView',
state='normal',
key='disclosure_triangle_color',
value=color8)
light_theme.set(class_name='SelectView',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='SelectView',
state='normal',
key='top_label.focusable',
value=False)
light_theme.set(class_name='TextField',
state='focused',
key='label.background_color',
value=(color1, color2))
light_theme.set(class_name='TextField',
state='normal',
key='placeholder_text_color',
value=color6)
light_theme.set(class_name='TextField',
state='normal',
key='border_widths',
value=1)
light_theme.set(class_name='TextField',
state='normal',
key='text_color',
value=color9)
light_theme.set(class_name='TextField',
state='disabled',
key='text_color',
value=color6)
light_theme.set(class_name='TextField',
state='normal',
key='blink_cursor',
value=True)
light_theme.set(class_name='TextField',
state='normal',
key='cursor_blink_duration',
value=450)
light_theme.set(class_name='GridView',
state='normal',
key='background_color',
value=color4)
light_theme.set(class_name='GridView',
state='normal',
key='line_color',
value=color6)