def get_sprite(sprite_code):
'''
Devuelve el sprite asociada al código de sprite dado.
'''
__check_initialize()
if __sprites.has_key(sprite_code):
print "Sprite " + sprite_code + " ya cargado"
else:
print "Sprite " + sprite_code + " no estaba cargado aún, cargando..."
__sprites[sprite_code] = data.load_sprite(__sprites_info[sprite_code][0], __sprites_info[sprite_code][1], \
__sprites_info[sprite_code][2], __sprites_info[sprite_code][3])
return __sprites[sprite_code]
def get_sprite(sprite_code):
'''
@brief función que devuelve el sprite asociada al código de sprite dado.
@param sprite_code Código del sprite a cargar.
@return Referencia al sprite cargado.
'''
__check_initialize()
#Si no estaba cargado, lo cargamos
if __sprites.has_key(sprite_code):
print "Sprite " + sprite_code + " ya cargado"
else:
print "Sprite " + sprite_code + " no estaba cargado aún, cargando..."
__sprites[sprite_code] = data.load_sprite(__sprites_info[sprite_code][0], __sprites_info[sprite_code][1], \
__sprites_info[sprite_code][2], __sprites_info[sprite_code][3])
return __sprites[sprite_code]
def get_sprite(sprite_code):
'''
@brief función que devuelve el sprite asociada al código de sprite dado.
@param sprite_code Código del sprite a cargar.
@return Referencia al sprite cargado.
'''
__check_initialize()
#Si no estaba cargado, lo cargamos
if __sprites.has_key(sprite_code):
pass
#print "Sprite " + sprite_code + " ya cargado"
else:
#print "Sprite " + sprite_code + " no estaba cargado aún, cargando..."
__sprites[sprite_code] = data.load_sprite(
__sprites_info[sprite_code][0], __sprites_info[sprite_code][1],
__sprites_info[sprite_code][2], __sprites_info[sprite_code][3])
return __sprites[sprite_code]
def __init__(self, game_control, xml_path):
'''
Game_control objeto GameControl con el que se asocia.
Xml_path ruta del archivo del circuito en cuestión.
Parseamos el archivo xml y cargamos las distintas propiedades
de los tiles, así como la posicion de estos, su capa y el tipo.
'''
self.game_control = game_control
parser = xml.dom.minidom.parse(data.get_path_xml(xml_path, False))
#Parseamos los distintos componentes necesarias para el circuito.
for element in parser.getElementsByTagName('map'):
self.width = int(element.getAttribute('width'))
self.height = int(element.getAttribute('height'))
self.tile_width = int(element.getAttribute('tilewidth'))
self.tile_height = int(element.getAttribute('tileheight'))
print "Width: " + str(self.width) + " Height: " + str(self.height) \
+ " tile_width: " + str(self.tile_width) + ' tile_height: ' + str(self.tile_height)
image_name = None
for element in parser.getElementsByTagName('image'):
image_name = str(element.getAttribute('source'))
tileset_width = 1
tileset_height = 1
collision_map_name = None
#Parseamos las distintas propiedades editadas para el mapa, como
#el número de tiles en el ancho del tileset y en el alto,
#así como el mapa de colisiones correspondiente
for element in parser.getElementsByTagName('property'):
name = element.getAttribute('name')
if name == 'tileset_ancho':
tileset_width = int(element.getAttribute('value'))
elif name == 'tileset_alto':
tileset_height = int(element.getAttribute('value'))
elif name == 'collision_map':
collision_map_name = str(element.getAttribute('value'))
print "Tileset_height: " + str(tileset_height) + ' Tileset_width: ' + str(tileset_width)
self.tileset = data.load_sprite(image_name, tileset_width, tileset_height)
#self.collision_map = data.load_image(collision_map_name)#, tileset_height, tileset_width)
#Suponiendo que 4 sera el numero de capas que tendrá el mapa
#Self.map sera la matriz logica que indicara donse se posiciona
#cada tile y de que tipo son.
self.map = range(4)
#Por cada elemento:
for n in range(4):
self.map[n] = range(self.height) #reservamos para el alto.
for m in range(self.height):
self.map[n][m] = range(self.width) #y para el ancho.
for o in range(self.width):
self.map[n][m][o] = Tile()
#Cargamos la imagen con los distinto tipos de tiles
'''tile_types = data.get_image('tile_types.png')
#Obtenemos un array de pixeles tanto de los distintos tipos de tiles.
pxarray_tile_types = pygame.PixelArray(tile_types)
#Como del mapa de colisiones, para poder hacer comprobaciones
pxarray = pygame.PixelArray(collision_map)'''
num_layer = 0
num_row = 0
num_column = 0
n = 0
frame = None
for layer in parser.getElementsByTagName('layer'):
for tile in layer.getElementsByTagName('tile'):
num_row = int(n / self.width)
num_column = (n % self.width) % self.width
frame = int(tile.getAttribute('gid'))
self.map[num_layer][num_row][num_column].frame = frame
'''if frame == 0:
self.map[num_layer][num_row][num_column].type = PASSABLE
else:
p_x = (((frame - 1) % tileset_width) % tileset_width) * self.tile_height;
p_y = ((frame - 1) / tileset_width) * self.tile_width
if pxarray[p_x][p_y] == pxarray_tile_types[0]:
self.map[num_layer][num_row][num_column].type = PASSABLE
elif pxarray[p_x][p_y] == pxarray_tile_types[1]:
self.map[num_layer][num_row][num_column].type = NOPASSABLE
elif pxarray[p_x][p_y] == pxarray_tile_types[2]:
self.map[num_layer][num_row][num_column].type = LAG
else:
self.map[num_layer][num_row][num_column].type = PASSABLE'''
n += 1
print n
num_layer += 1
n = 0
self.x = 0
#self.y = 0
self.y = self.height * self.tile_height - pygame.display.get_surface().get_height()
#y = alto_ * tile_alto_ - juego_->univ()->pantalla_alto();
print str(num_layer)
self.load_actors()
def __init__(self, game_control, xml_path):
'''
@brief Constructor
@param game_control Referencia a GameControl.
@param xml_path Ruta del archivo del circuito.
'''
self.game_control = game_control
parser = xml.dom.minidom.parse(data.get_path_xml(xml_path, False))
#Parseamos los distintos componentes necesarios para el circuito.
for element in parser.getElementsByTagName('map'):
self.width = int(element.getAttribute('width'))
self.height = int(element.getAttribute('height'))
self.tile_width = int(element.getAttribute('tilewidth'))
self.tile_height = int(element.getAttribute('tileheight'))
#print "Width: " + str(self.width) + " Height: " + str(self.height) \
#+ " tile_width: " + str(self.tile_width) + ' tile_height: ' + str(self.tile_height)
#Obtenemos el nombre de la imagen con el tileset del circuito
image_name = None
for element in parser.getElementsByTagName('image'):
image_name = str(element.getAttribute('source'))
#Variables auxiliares
tileset_width = 1
tileset_height = 1
collision_map_name = None
self.circuit_width = 0
self.goal_width = 0
self.elements_map = {}
self.car_angle = 0
#Parseamos las distintas propiedades editadas para el mapa, como
#el número de tiles en el ancho del tileset y en el alto,
#así como el mapa de colisiones correspondiente
for element in parser.getElementsByTagName('property'):
name = element.getAttribute('name')
if name == 'tileset_ancho':
tileset_width = int(element.getAttribute('value'))
elif name == 'tileset_alto':
tileset_height = int(element.getAttribute('value'))
elif name == 'collision_map':
collision_map_name = str(element.getAttribute('value'))
elif name == 'ancho_pista':
self.circuit_width = int(element.getAttribute('value'))
frame = int(element.getAttribute('value'))
self.elements_map[frame] = name
elif name == 'ancho_meta':
self.goal_width = int(element.getAttribute('value'))
elif name == 'grado_coche':
self.car_angle = int(element.getAttribute('value'))
elif name == 'item_box':
frame = int(element.getAttribute('value'))
self.elements_map[frame] = name
elif name == 'music':
music_file = str(element.getAttribute('value'))
self.game_control.set_music_file(music_file)
#print "Tileset_height: " + str(tileset_height) + ' Tileset_width: ' + str(tileset_width)
#Cargamos el tileset del circuito
self.tileset = data.load_sprite(image_name, tileset_height, tileset_width)
#Cargamos el mampa de colisiones para el circuito
collision_map_prueba = data.load_sprite(collision_map_name, tileset_height, tileset_width)#, tileset_height, tileset_width)
#Suponiendo que 4 sera el numero de capas que tendrá el mapa
#Self.map sera la matriz logica que indicara donse se posiciona
#cada tile y de que tipo son.
self.map = range(4)
#Por cada elemento:
for n in range(4):
self.map[n] = range(self.height) #reservamos para el alto.
#astar.map = range(self.height)
for m in range(self.height):
self.map[n][m] = range(self.width) #y para el ancho.
#astar.map[m] = range(self.width)
for o in range(self.width):
self.map[n][m][o] = Tile()
#astar.map[m][o] = astar.PASSABLE
astar.map = range(self.width)
for m in range(self.width):
astar.map[m] = range(self.height)
for o in range(self.height):
astar.map[m][o] = astar.PASSABLE
num_layer = 0
num_row = 0
num_column = 0
n = 0
frame = None
#Recorremos cada una de las capas
for layer in parser.getElementsByTagName('layer'):
for tile in layer.getElementsByTagName('tile'):
#Obtenemos el numero de la fila y de la columna del tile
num_row = int(n / self.width)
num_column = (n % self.width) % self.width
#Obtenemos el frame referente al tileset
frame = int(tile.getAttribute('gid'))
#Asignamos el frame
self.map[num_layer][num_row][num_column].frame = frame
#Si el frame es 0 quiere decir que es un tile vacio, por lo que
#Lo pondemos como pasabel
if frame == 0:
self.map[num_layer][num_row][num_column].type = PASSABLE
else:
#Comprobamos el color del tile correspondiente en el mapa de colisiones
#Segun el color de este indicará que el tile es de un tipo u otro
if collision_map_prueba[frame - 1].get_at((0,0)) == (255, 0, 0):
self.map[num_layer][num_row][num_column].type = PASSABLE
#print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " es pasable."
#elif pxarray[p_x][p_y] == pxarray_tile_types[1]:
elif collision_map_prueba[frame - 1].get_at((0,0)) == (0, 255, 0):
self.map[num_layer][num_row][num_column].type = NOPASSABLE
astar.map[num_column][num_row] = astar.NOPASSABLE
#print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " NO es pasable."
#elif pxarray[p_x][p_y] == pxarray_tile_types[2]:
elif collision_map_prueba[frame - 1].get_at((0,0)) == (0, 0, 255):
self.map[num_layer][num_row][num_column].type = LAG
astar.map[num_column][num_row] = astar.LAG
elif collision_map_prueba[frame - 1].get_at((0,0)) == (0, 0, 0):
self.map[num_layer][num_row][num_column].type = HOLE
astar.map[num_column][num_row] = astar.LAG
#Si no es ninguno de los anteriores lo seleccionamos como pasable
else:
self.map[num_layer][num_row][num_column].type = PASSABLE
n += 1
#print n
num_layer += 1
n = 0
self.x = 0
self.y = 1
#self.y = self.height * self.tile_height - pygame.display.get_surface().get_height()
#y = alto_ * tile_alto_ - juego_->univ()->pantalla_alto();
#Parseamos los objetos que se introducirán en el mapa
for element in parser.getElementsByTagName('objectgroup'):
#Comprobamos si estamos enla capa de los checkpoints
if element.getAttribute('name') == 'checkpoints':
#Parseamos cada uno de los checkpoints
for cp in element.getElementsByTagName('object'):
#Obtenemos las caracteristicas
position = int(cp.getAttribute('name'))
type = str(cp.getAttribute('type'))
x = int(cp.getAttribute('x'))
y = int(cp.getAttribute('y'))
new_checkpoint = None
#Segun el tipo añadiremos un chekpoint
if type == 'Horizontal' or type == 'Vertical':
if type == 'Horizontal':
new_checkpoint = checkpoint.CheckPoint(self.game_control, x, y, self.tile_width * self.circuit_width, 2)
elif type == 'Vertical':
new_checkpoint = checkpoint.CheckPoint(self.game_control, x, y, 2, self.tile_height * self.circuit_width)
#Añadimos un nuevo checkpoint
self.game_control.add_checkpoint(new_checkpoint, position)
#O la meta
else:
if type == 'GoalH':
new_checkpoint = checkpoint.CheckPoint(self.game_control, x, y, self.tile_width * self.circuit_width, 2)
self.game_control.set_start(self, x, y, 'goal', 'horizontal', self.car_angle)
elif type == 'GoalV':
new_checkpoint = checkpoint.CheckPoint(self.game_control, x, y, 2, self.tile_height * self.circuit_width)
self.game_control.set_start(self, x, y, 'goal', 'vertical', self.car_angle)
#Añadimos la meta
self.game_control.set_goal(new_checkpoint)
#Tras obtener todos los checpoints, los ordernamos para su gestión
self.game_control.order_checkpoints()
if element.getAttribute('name') == 'objetos':
for ob in element.getElementsByTagName('object'):
#Obtenemos las caracteristicas
name = str(ob.getAttribute('name'))
type = str(ob.getAttribute('type'))
x = int(ob.getAttribute('x'))
y = int(ob.getAttribute('y'))
if type == 'Item_box':
item_box = itembox.ItemBox(self.game_control, 'elements/itembox.xml', x, y)
self.game_control.add_item_box(item_box)
if type == 'check':
position = int(name)
rect = pygame.Rect(x, y, self.tile_width, self.tile_height)
print rect
self.game_control.ia_checks[position] = rect
if type == 'animation':
path_xml = "animations/" + name
def __init__(self, game_control, xml_path):
'''
@brief Constructor
@param game_control Referencia a GameControl.
@param xml_path Ruta del archivo del circuito.
'''
self.game_control = game_control
parser = xml.dom.minidom.parse(data.get_path_xml(xml_path, False))
#Parseamos los distintos componentes necesarios para el circuito.
for element in parser.getElementsByTagName('map'):
self.width = int(element.getAttribute('width'))
self.height = int(element.getAttribute('height'))
self.tile_width = int(element.getAttribute('tilewidth'))
self.tile_height = int(element.getAttribute('tileheight'))
#print "Width: " + str(self.width) + " Height: " + str(self.height) \
#+ " tile_width: " + str(self.tile_width) + ' tile_height: ' + str(self.tile_height)
#Obtenemos el nombre de la imagen con el tileset del circuito
image_name = None
for element in parser.getElementsByTagName('image'):
image_name = str(element.getAttribute('source'))
#Variables auxiliares
tileset_width = 1
tileset_height = 1
collision_map_name = None
self.circuit_width = 0
self.goal_width = 0
self.elements_map = {}
self.car_angle = 0
#Parseamos las distintas propiedades editadas para el mapa, como
#el número de tiles en el ancho del tileset y en el alto,
#así como el mapa de colisiones correspondiente
for element in parser.getElementsByTagName('property'):
name = element.getAttribute('name')
if name == 'tileset_ancho':
tileset_width = int(element.getAttribute('value'))
elif name == 'tileset_alto':
tileset_height = int(element.getAttribute('value'))
elif name == 'collision_map':
collision_map_name = str(element.getAttribute('value'))
elif name == 'ancho_pista':
self.circuit_width = int(element.getAttribute('value'))
frame = int(element.getAttribute('value'))
self.elements_map[frame] = name
elif name == 'ancho_meta':
self.goal_width = int(element.getAttribute('value'))
elif name == 'grado_coche':
self.car_angle = int(element.getAttribute('value'))
elif name == 'item_box':
frame = int(element.getAttribute('value'))
self.elements_map[frame] = name
elif name == 'music':
music_file = str(element.getAttribute('value'))
self.game_control.set_music_file(music_file)
#print "Tileset_height: " + str(tileset_height) + ' Tileset_width: ' + str(tileset_width)
#Cargamos el tileset del circuito
self.tileset = data.load_sprite(image_name, tileset_height,
tileset_width)
#Cargamos el mampa de colisiones para el circuito
collision_map_prueba = data.load_sprite(
collision_map_name, tileset_height,
tileset_width) #, tileset_height, tileset_width)
#Suponiendo que 4 sera el numero de capas que tendrá el mapa
#Self.map sera la matriz logica que indicara donse se posiciona
#cada tile y de que tipo son.
self.map = range(4)
#Por cada elemento:
for n in range(4):
self.map[n] = range(self.height) #reservamos para el alto.
#astar.map = range(self.height)
for m in range(self.height):
self.map[n][m] = range(self.width) #y para el ancho.
#astar.map[m] = range(self.width)
for o in range(self.width):
self.map[n][m][o] = Tile()
#astar.map[m][o] = astar.PASSABLE
astar.map = range(self.width)
for m in range(self.width):
astar.map[m] = range(self.height)
for o in range(self.height):
astar.map[m][o] = astar.PASSABLE
num_layer = 0
num_row = 0
num_column = 0
n = 0
frame = None
#Recorremos cada una de las capas
for layer in parser.getElementsByTagName('layer'):
for tile in layer.getElementsByTagName('tile'):
#Obtenemos el numero de la fila y de la columna del tile
num_row = int(n / self.width)
num_column = (n % self.width) % self.width
#Obtenemos el frame referente al tileset
frame = int(tile.getAttribute('gid'))
#Asignamos el frame
self.map[num_layer][num_row][num_column].frame = frame
#Si el frame es 0 quiere decir que es un tile vacio, por lo que
#Lo pondemos como pasabel
if frame == 0:
self.map[num_layer][num_row][num_column].type = PASSABLE
else:
#Comprobamos el color del tile correspondiente en el mapa de colisiones
#Segun el color de este indicará que el tile es de un tipo u otro
if collision_map_prueba[frame - 1].get_at(
(0, 0)) == (255, 0, 0):
self.map[num_layer][num_row][
num_column].type = PASSABLE
#print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " es pasable."
#elif pxarray[p_x][p_y] == pxarray_tile_types[1]:
elif collision_map_prueba[frame - 1].get_at(
(0, 0)) == (0, 255, 0):
self.map[num_layer][num_row][
num_column].type = NOPASSABLE
astar.map[num_column][num_row] = astar.NOPASSABLE
#print "El tile: " + str(self.map[num_layer][num_row][num_column].frame - 1) + " NO es pasable."
#elif pxarray[p_x][p_y] == pxarray_tile_types[2]:
elif collision_map_prueba[frame - 1].get_at(
(0, 0)) == (0, 0, 255):
self.map[num_layer][num_row][num_column].type = LAG
astar.map[num_column][num_row] = astar.LAG
elif collision_map_prueba[frame - 1].get_at(
(0, 0)) == (0, 0, 0):
self.map[num_layer][num_row][num_column].type = HOLE
astar.map[num_column][num_row] = astar.LAG
#Si no es ninguno de los anteriores lo seleccionamos como pasable
else:
self.map[num_layer][num_row][
num_column].type = PASSABLE
n += 1
#print n
num_layer += 1
n = 0
self.x = 0
self.y = 1
#self.y = self.height * self.tile_height - pygame.display.get_surface().get_height()
#y = alto_ * tile_alto_ - juego_->univ()->pantalla_alto();
#Parseamos los objetos que se introducirán en el mapa
for element in parser.getElementsByTagName('objectgroup'):
#Comprobamos si estamos enla capa de los checkpoints
if element.getAttribute('name') == 'checkpoints':
#Parseamos cada uno de los checkpoints
for cp in element.getElementsByTagName('object'):
#Obtenemos las caracteristicas
position = int(cp.getAttribute('name'))
type = str(cp.getAttribute('type'))
x = int(cp.getAttribute('x'))
y = int(cp.getAttribute('y'))
new_checkpoint = None
#Segun el tipo añadiremos un chekpoint
if type == 'Horizontal' or type == 'Vertical':
if type == 'Horizontal':
new_checkpoint = checkpoint.CheckPoint(
self.game_control, x, y,
self.tile_width * self.circuit_width, 2)
elif type == 'Vertical':
new_checkpoint = checkpoint.CheckPoint(
self.game_control, x, y, 2,
self.tile_height * self.circuit_width)
#Añadimos un nuevo checkpoint
self.game_control.add_checkpoint(
new_checkpoint, position)
#O la meta
else:
if type == 'GoalH':
new_checkpoint = checkpoint.CheckPoint(
self.game_control, x, y,
self.tile_width * self.circuit_width, 2)
self.game_control.set_start(
self, x, y, 'goal', 'horizontal',
self.car_angle)
elif type == 'GoalV':
new_checkpoint = checkpoint.CheckPoint(
self.game_control, x, y, 2,
self.tile_height * self.circuit_width)
self.game_control.set_start(
self, x, y, 'goal', 'vertical', self.car_angle)
#Añadimos la meta
self.game_control.set_goal(new_checkpoint)
#Tras obtener todos los checpoints, los ordernamos para su gestión
self.game_control.order_checkpoints()
if element.getAttribute('name') == 'objetos':
for ob in element.getElementsByTagName('object'):
#Obtenemos las caracteristicas
name = str(ob.getAttribute('name'))
type = str(ob.getAttribute('type'))
x = int(ob.getAttribute('x'))
y = int(ob.getAttribute('y'))
if type == 'Item_box':
item_box = itembox.ItemBox(self.game_control,
'elements/itembox.xml', x,
y)
self.game_control.add_item_box(item_box)
if type == 'check':
position = int(name)
rect = pygame.Rect(x, y, self.tile_width,
self.tile_height)
print rect
self.game_control.ia_checks[position] = rect
if type == 'animation':
path_xml = "animations/" + name