コード例 #1
0
ファイル: resource.py プロジェクト: BGCX262/zycars-svn-to-git
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]
コード例 #2
0
ファイル: resource.py プロジェクト: BGCX262/zycars-svn-to-git
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]
コード例 #3
0
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]
コード例 #4
0
ファイル: circuit.py プロジェクト: BGCX262/zycars-svn-to-git
    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()            
コード例 #5
0
ファイル: circuit.py プロジェクト: BGCX262/zycars-svn-to-git
    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
コード例 #6
0
ファイル: circuit.py プロジェクト: jmarente/zycars
    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