示例#1
0
    def start(self):
        self._game_maps = []
        self._current_map = None

        tmx_path_i = os.path.join('assets', 'maps', 'indoor.tmx')
        tmx_path_o = os.path.join('assets', 'maps', 'field.tmx')

        self.indoor_tiles_resource = tiles.load(tmx_path_i)
        self.outdoor_tiles_resource = tiles.load(tmx_path_o)

        self.collision_manager = CollisionManagerGrid(**constants.collision_params)
        self.scrolling_manager = ScrollingManager()

        self.player = self._init_player()

        self._game_maps.append(GameMap(self.indoor_tiles_resource, self.scrolling_manager, self.collision_manager))
        self._game_maps.append(GameMap(self.outdoor_tiles_resource, self.scrolling_manager, self.collision_manager))
        self.change_map(0)

        self._spawn_player()

        self.add(self.scrolling_manager, z=0)
        self.add(MessageBox(), name='msg_box', z=2)  # there's only one message box in the scene

        self.schedule(self._current_map.update)
        self.schedule(self.player.update)

        director.run(self)
def main():
	global keyboard
	global scroller # This variable is going to become a scrolling manager to enable us to scroll along the map
	
	# Initialize director
	director.init(width=800, height=600, caption="In the beginning everything was Kay-O", autoscale=True, resizable=True)
	
	# Create player layer and add player onto it
	# This time make it a ScrollableLayer type rather than simply Layer
	player_layer = layer.ScrollableLayer()
	player = sprite.Sprite('images/mr-saturn.png')
	player_layer.add(player)

	# Sets initial position and velocity of player
	player.position = (750, 1200)
	player.velocity = (0, 0)

	# Set the sprite's movement class
	player.do(Player())
	
	# Create a new ScrollingManager object so we can scroll the view along with the player
	# The ScrollingManager object lets us separate "world" coordinates and "screen" coordinates
	# In this way, we can keep track of where the player is across the entire map but keep the viewport local
	#(http://python.cocos2d.org/doc/api/cocos.layer.scrolling.html#cocos.layer.scrolling.ScrollingManager)
	scroller = layer.ScrollingManager()
	
	# Now we will create a map layer based on our TMX file
	# I called the ground layer "Ground" in the tmx file, which is what we specify here as an identifier
	# This is located in the <layer> tags in map.tmx
	# We do the same thing for TopLayer
	# See README in this folder for more information
	ground_layer = tiles.load('tiles/map.tmx')['Ground']
	top_layer = tiles.load('tiles/map.tmx')['TopLayer']
	
	# Creates a text layer and adds an instance of BigText() to it
	text_layer = BigText()
	
	# Add player sprite and player_layer to the ScrollingManager
	# We have also added a second argument to the add() calls
	# This is the z-index, which explicity determines the order of layers.
	# Here, the player has a z-index of 1 and the text has an index of 2 so it will overlay the player.
	# And 0 will be the background
	scroller.add(ground_layer, z = 0)
	scroller.add(top_layer, z = 1)
	scroller.add(player_layer, z = 1) 
	
	# Here we initialize the scene with initial layer "scroller" which holds all of the layers
	main_scene = scene.Scene(scroller)
	# Here we add the text_layer containing the instance of BigText() to the main scene
	main_scene.add(text_layer, z = 2)

	keyboard = key.KeyStateHandler()
	director.window.push_handlers(keyboard)
	
	# Run the scene we've built in the window
	director.run(main_scene)
示例#3
0
    def __init__(self, edit_level_xml):
        super(EditorScene, self).__init__()

        self.manager = tiles.ScrollingManager(director.window)
        #if bg_level_xml:
            #level = tiles.load(bg_level_xml)[bg_level_id]
            #self.manager.append(level)
            #level.opacity = 100
            #self.add(level, z=0)

        level_to_edit = tiles.load(edit_level_xml)

        mz = 0
        for id, layer in level_to_edit.find(tiles.MapLayer):
            self.manager.add(layer, z=layer.origin_z)
            mz = max(layer.origin_z, mz)
        self.add(self.manager)

        s = TileSetLayer(level_to_edit)
        self.add(s, z=mz+2)

        e = TileEditorLayer(self.manager, level_to_edit, s, edit_level_xml)
        self.manager.add(e, z=mz+1)

        self.manager.set_focus(0, 0)
def main():
    global keyboard, scroller
    from cocos.director import director
    director.init(width=600, height=300, do_not_scale=True, resizable=True)

    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    car.do(DriveCar())

    scroller = layer.ScrollingManager()
    test_layer = tiles.load('road-map.xml')['map0']
    scroller.add(test_layer)
    scroller.add(car_layer)

    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
            test_layer.set_debug(True)
    director.window.push_handlers(on_key_press)

    director.run(main_scene)
示例#5
0
def main():
    global keyboard, scroller
    from cocos.director import director
    director.init(width=960, height=640, autoscale=False, resizable=True)

    scroller = layer.ScrollingManager()
    test_layer = tiles.load('road-map.tmx')['map0']
    scroller.add(test_layer)

    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
            test_layer.set_debug(True)

    director.window.push_handlers(on_key_press)

    director.run(main_scene)
示例#6
0
    def __init__(self):
        """initializer"""
        Scene.__init__(self)
        self.config = Config()
        self.gallery = Gallery()
        # creating map
        raw_map = tiles.load("{}/{}.{}".format(self.config.resources, "combat", self.config.map_format) )
        self.tw = self.config.tile_width = raw_map.contents["combat"].tw

    
        snow_base = ColorLayer( 250, 250, 250, 255, director.window.width, director.window.height)
        self.add(snow_base, name="display_worldmap_snow")
        cz = 1
        self.add(DisplayCombatMapscroll(0), z=cz, name="display_combat_mapscroll")
        cz +=1
        padding_x, padding_y = self.get_initial_padding(raw_map)
        print('e')
        for layer_name in [ "combat"]:  # TODO remove this hardcoded stuff, where is the Z value?
            cz += 1
            self.get("display_combat_mapscroll").add(raw_map.contents[layer_name], z=cz, name=layer_name) #z=len(self.children), name=layer_name)
            self.get("display_combat_mapscroll").get(layer_name).set_view(padding_x, padding_y, director.window.width + padding_x, director.window.height + padding_y)
        print('e')
        cz +=1
        self.get("display_combat_mapscroll").init_tactical_map()
        print('e')
#        self.add(DisplayWorldmapLauncher(), z=cz, name="display_worldmap_launcher")
#        cz +=1
        self.MapInZoom=True
        print('e')
        self.display_combat_mapscroll=self.get("display_combat_mapscroll")    
        print('e')
示例#7
0
    def __init__(self, hud):
        super().__init__()

        try:
            fullmap = load("mario-world1-1.tmx")
        except Exception as e:
            raise SystemExit(e)

        bg_map = fullmap["Background"]
        fg_map = fullmap["Foreground"]
        ob_map = fullmap["Objects"]
        tileset = fullmap["Mario"]

        fg_map.do(BlinkBricks())
        fg_map.set_cell_opacity(64, 5, 0)

        scroller = ScrollingManager()
        scroller.add(bg_map, z=0)
        scroller.add(fg_map, z=2)
        scroller.add(GameLayer(hud, fg_map, ob_map, tileset), z=1)

        scroller.scale = 2.5

        self.add(ColorLayer(107, 140, 255, 255), z=0)
        self.add(scroller, z=1)
        self.add(hud, z=10)
示例#8
0
def main():
    global keyboard, scroller
    director.init(width=800, height=600, autoscale=False, resizable=True)
    """
    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    car.do(DriveCar())
    """
#   scroller.add(car_layer)
    level_map = tiles.load('test-field.tmx')
    bg_layer = level_map['bg']
    walls_layer = level_map['walls']
    scroller = layer.ScrollingManager()
    scroller.add(bg_layer)
    scroller.add(walls_layer)
    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)
    """
    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
            bg_layer.set_debug(True)
    director.window.push_handlers(on_key_press)
    """
    director.run(main_scene)
    def CreateTileMap(self):

        # First load the file - This seems awfully slow...
        self.test_layer = tiles.load('Maps/Map-Ch1-St1.tmx')

        # Extract the background layer
        bg_layer = self.test_layer['Background']

        # Add background layer to the scroller.
        DG.scroller.add(bg_layer)

        # Extract the properties into a dictionary
        tileDataArray = {}
        x = 0
        y = 0

        for col in bg_layer.cells:
            for cell in col:
                tileDataArray[x,y] = TileData(cell.position,cell.tile.properties['MovementCost'],cell.tile,cell)
                y += 1

            x += 1
            y = 0

        DG.tileData = tileDataArray
        # Add the background layer as a permanent field
        DG.bg = bg_layer
示例#10
0
    def map(self, width, height):
        """
        Creates and returns a new randomly generated map
        """
        template = ti.load(os.path.join(script_dir, 'assets',
                                        'template.tmx'))['map0']
        #template.set_view(0, 0, template.px_width, template.px_height)
        template.set_view(0, 0, width * template.tw, height * template.th)

        # TODO: Save the generated map.
        #epoch = int(time.time())
        #filename = 'map_' + str(epoch) + '.tmx'

        # Draw borders
        border_x = template.cells[width]
        for y in xrange(0, height + 1):
            border_x[y].tile = template.cells[0][0].tile

        for x in xrange(0, width):
            template.cells[x][height].tile = template.cells[0][0].tile

        # Start within borders
        #self.recursive_division(template.cells, 3, (template.px_width/template.tw)-1, (template.px_height/template.th)-1, 0, 0)
        self.recursive_division(template.cells, 3, width, height, 0, 0)

        return template
示例#11
0
    def __init__(self):

        super(World, self).__init__()
        self.player = Car(self)
        self.newMap(30, 20)
        self.map = tiles.load('tilemap.xml')['map0']
        self.checkSpawnPoint()
        self.exitPoint = self.checkExitPoint()
        self.blockKeys = 0.0
        self.blockKeysFull = 0.3
        self.bindings = {
            key.LEFT: 'left',
            key.RIGHT: 'right',
            key.UP: 'up',
            key.DOWN: 'down',
            key.E: 'down_level',
            key.Z: 'scale',
                        }
        buttons = {}
        for k in self.bindings:
            buttons[self.bindings[k]] = 0
        self.buttons = buttons

        self.overlaidCells = []
        #self.overlay = layer.util_layers.ColorLayer(0, 0, 0, 128, 20*128, 30*128)

        #self.map.add(self.overlay)
        self.carLayer = layer.ScrollableLayer()
        self.carLayer.add(self.player)
        self.manager = layer.ScrollingManager()
        self.manager.add(self.map)
        self.manager.add(self.carLayer)
        self.add(self.manager)

        self.schedule(self.update)
示例#12
0
    def __init__(self, edit_level_xml):
        super(EditorScene, self).__init__()

        self.manager = tiles.ScrollingManager(director.window)
        #if bg_level_xml:
        #level = tiles.load(bg_level_xml)[bg_level_id]
        #self.manager.append(level)
        #level.opacity = 100
        #self.add(level, z=0)

        level_to_edit = tiles.load(edit_level_xml)

        mz = 0
        for id, layer in level_to_edit.find(tiles.MapLayer):
            self.manager.add(layer, z=layer.origin_z)
            mz = max(layer.origin_z, mz)
        self.add(self.manager)

        s = TileSetLayer(level_to_edit)
        self.add(s, z=mz + 2)

        e = TileEditorLayer(self.manager, level_to_edit, s, edit_level_xml)
        self.manager.add(e, z=mz + 1)

        self.manager.set_focus(0, 0)
示例#13
0
def main():
    global keyboard, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False, resizable=True)

    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    car.do(DriveCar())

    scroller = layer.ScrollingManager()
    test_layer = tiles.load('road-map.tmx')['map0']
    scroller.add(test_layer)
    scroller.add(car_layer)

    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
            test_layer.set_debug(True)

    director.window.push_handlers(on_key_press)

    director.run(main_scene)
示例#14
0
 def __init__(self):
     super().__init__()
     level_map = tiles.load('test-field.tmx')
     bg_layer = level_map['bg']
     walls_layer = level_map['walls']
     scroller = scrolling.ScrollingManager()
     scroller.add(bg_layer)
     scroller.add(walls_layer)
     self.add(scroller)
def main():
    global keyboard, tilemap, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)
    # create a layer to put the player in
    player_layer = layer.ScrollableLayer()
    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController())

    # add the tilemaps and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    fullmap = tiles.load('platformer-map.xml')
    tilemap_walls = fullmap['walls']
    scroller.add(tilemap_walls, z=0)
    tilemap_decoration = fullmap['decoration']
    scroller.add(tilemap_decoration, z=1)
    scroller.add(player_layer, z=2)

    # set the player start using the player_start token from the map
    start = tilemap_decoration.find_cells(player_start=True)[0]
    r = player.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    player.position = r.center

    # give a collision handler to the player
    mapcollider = mapcolliders.RectMapCollider(velocity_on_bump='slide')
    player.collision_handler = mapcolliders.make_collision_handler(
        mapcollider, tilemap_walls)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # allow display info about cells / tiles
    def on_key_press(key, modifier):
        if key == pyglet.window.key.D:
            tilemap_walls.set_debug(True)

    director.window.push_handlers(on_key_press)

    # run the scene
    director.run(platformer_scene)
示例#16
0
def main():
    global keyboard, tilemap, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)
    # create a layer to put the player in
    player_layer = layer.ScrollableLayer()
    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController())

    # add the tilemaps and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    fullmap = tiles.load('platformer-map.xml')
    tilemap_walls = fullmap['walls']
    scroller.add(tilemap_walls, z=0)
    tilemap_decoration = fullmap['decoration']
    scroller.add(tilemap_decoration, z=1)
    scroller.add(player_layer, z=2)

    # set the player start using the player_start token from the map
    start = tilemap_decoration.find_cells(player_start=True)[0]
    r = player.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    player.position = r.center

    # give a collision handler to the player
    mapcollider = mapcolliders.RectMapCollider(velocity_on_bump='slide')
    player.collision_handler = mapcolliders.make_collision_handler(
        mapcollider, tilemap_walls)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # allow display info about cells / tiles 
    def on_key_press(key, modifier):
        if key == pyglet.window.key.D:
            tilemap.set_debug(True)
    director.window.push_handlers(on_key_press)

    # run the scene
    director.run(platformer_scene)
示例#17
0
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)
    # create the scrolling manager that will hold all game entities
    scroller = layer.ScrollingManager()

    # load the map layer of interest and add to the level
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    scroller.add(walls, z=0)

    # create a layer to put the player in; it will care for player scroll
    player_layer = layer.ScrollableLayer()

    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController2())
    scroller.add(player_layer, z=1)

    # set the player start using the object with the 'player_start' property
    player_start = walls.find_cells(player_start=True)[0]

    # for convenience the player start was give the same dimensions as player,
    # so put player.center over player start center
    player.position = player_start.center

    # set focus so the player is in view
    scroller.set_focus(*player.position)

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # give a collision handler to the player
    mapcollider = mapcolliders.TmxObjectMapCollider()
    mapcollider.on_bump_handler = mapcollider.on_bump_slide
    player.collision_handler = mapcolliders.make_collision_handler(
        mapcollider, walls)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#18
0
    def __init__(self, buildSelectScene):

        super(MainMap, self).__init__()
        self.build_select_scene = buildSelectScene

        self.map_loaded = tiles.load('background_map.tmx')['tile_layer_1']

        self.add(self.map_loaded, z=0)
        center = self.map_loaded.cells[10][7].center
        self.map_loaded.set_view(5, 5, 15, 15, 0, 0)
        self.set_focus(center[0], center[1])
        self.hexes = []
示例#19
0
    def __init__(self, buildSelectScene):

        super(MainMap, self).__init__()
        self.build_select_scene = buildSelectScene

        self.map_loaded = tiles.load('background_map.tmx')['tile_layer_1']

        self.add(self.map_loaded, z=0)
        center = self.map_loaded.cells[10][7].center
        self.map_loaded.set_view(5, 5, 15, 15, 0, 0)
        self.set_focus(center[0], center[1])
        self.hexes = []
示例#20
0
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)
    # create the scrolling manager that will hold all game entities
    scroller = layer.ScrollingManager()

    # load the map layer of interest and add to the level
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    scroller.add(walls, z=0)

    # create a layer to put the player in; it will care for player scroll
    player_layer = layer.ScrollableLayer()

    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController2())
    scroller.add(player_layer, z=1)

    # set the player start using the object with the 'player_start' property
    player_start = walls.find_cells(player_start=True)[0]

    # for convenience the player start was give the same dimensions as player,
    # so put player.center over player start center
    player.position = player_start.center

    # set focus so the player is in view
    scroller.set_focus(*player.position)

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # give a collision handler to the player
    mapcollider = mapcolliders.TmxObjectMapCollider()
    mapcollider.on_bump_handler = mapcollider.on_bump_slide
    player.collision_handler = mapcolliders.make_collision_handler(mapcollider, walls)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#21
0
    def __init__(self):
        super(Level1Scene, self).__init__()

        global keyboard, scroller, game_controller, map_layer
        scroller = ScrollingManager()
        keyboard = key.KeyStateHandler()
        director.window.push_handlers(keyboard)

        map_layer = load("tiles/map1/map_3.tmx")['base']
        map_h = (map_layer.cells[-1][-1].y // map_layer.tw + 1)
        map_layer_bg_0 = load("tiles/map1/map_3.tmx")['background']
        map_layer_bg_1 = load("tiles/map1/map_3.tmx")['decorations']

        main_layer = MainLayer()

        scroller.add(map_layer_bg_0, z=-2)
        scroller.add(map_layer_bg_1, z=-1)
        scroller.add(map_layer, z=0)
        scroller.add(main_layer, z=1)

        self.add(scroller)
示例#22
0
 def load_from_file_location(self, filename):
     """
     Create scrollable Level from tmx map
     """
     scroller = self.scroller
     data = tiles.load(filename)
     back = data['Background']
     force = data['Player Level']
     scripts = data['Scripts']
     player_layer = Location_Layer(scripts, force, scroller, self.keyboard, self.mouse)
     self.locations[self.x][self.y] = [force, back, player_layer]
     return self._create_location(force, back, player_layer)
示例#23
0
 def newLevel(self):
     # TODO Make this better
     self.killChildren()
     self.manager = layer.ScrollingManager()
     self.newMap(30, 30)
     self.map = tiles.load('tilemap.xml')['map0']
     self.checkSpawnPoint()
     self.carLayer = layer.ScrollableLayer()
     self.carLayer.add(self.player)
     self.manager = layer.ScrollingManager()
     self.manager.add(self.map)
     self.manager.add(self.carLayer)
     self.add(self.manager)
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    scroller.add(walls, z=0)

    # make the function to handle collision between actors and walls
    mapcollider = TmxObjectMapCollider()
    mapcollider.on_bump_handler = mapcollider.on_bump_bounce
    fn_collision_handler = mapcolliders.make_collision_handler(
        mapcollider, walls)

    # make the function to set visual focus at position
    fn_set_focus = scroller.set_focus

    # create a layer to put the player in
    actors_layer = layer.ScrollableLayer()
    ball = Ball((300, 300), (600, 600), fn_collision_handler, fn_set_focus,
                (255, 0, 255))
    actors_layer.add(ball)

    scroller.add(actors_layer, z=1)

    # set the player start using the object with the 'player_start' property
    player_start = walls.find_cells(player_start=True)[0]
    ball.position = player_start.center

    # set focus so the player is in view
    scroller.set_focus(*ball.position)

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#25
0
 def __init__(self):
     super(TestScene, self).__init__()
     scroller = layer.ScrollingManager()
     scrollable = tiles.load('road-map.tmx')['map0']
     scroller.add(scrollable)
     self.add(scroller)
     template_action = (CallFunc(scroller.set_focus, 0, 0) + Delay(1) +
                        CallFunc(scroller.set_focus, 768, 0) + Delay(1) +
                        CallFunc(scroller.set_focus, 768, 768) + Delay(1) +
                        CallFunc(scroller.set_focus, 1500, 768) + Delay(1) +
                        ScaleTo(0.75, 1) + Delay(1) +
                        CallFunc(scrollable.set_debug, True) + Delay(1) +
                        CallFunc(director.window.set_size, 800, 600))
     scroller.do(template_action)
示例#26
0
def main():
    director.init(800, 600, resizable=True)
    bg = cocos.layer.ColorLayer(0, 127, 127, 255)

    map_layer = load("maps/world.tmx")["tiles"]  # cocos.tiles.RectMapLayer
    car_layer = CarLayer()
    scroller = ScrollingManager()  # cocos.layer.scrolling.ScrollingManager
    scroller.add(map_layer)
    scroller.add(car_layer)
    print(scroller)

    # main_scene = Scene(ActionMenu(actions))
    main_scene = Scene(TransitionMenu(transitions))
    director.run(Scene(scroller))
示例#27
0
def main():
    global keyboard, tilemap, scroller
    from cocos.director import director

    director.init(width=960, height=540, autoscale=True, fullscreen=False)

    print(description)
    # create a layer to put the player in
    player_layer = layer.ScrollableLayer()
    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite("res/fez.png")
    player_layer.add(player)
    player.do(PlatformerController())

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    tilemap = tiles.load("res/tile_map1.xml")["level0"]
    # tilemap = tiles.load('platformer-map.xml')['level0']
    scroller.add(tilemap, z=0)
    scroller.add(player_layer, z=1)

    # set the player start using the player_start token from the tilemap
    start = tilemap.find_cells(player_start=True)[0]
    r = player.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    player.position = r.midtop

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(70, 200, 255, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # allow display info about cells / tiles
    def on_key_press(key, modifier):
        if key == pyglet.window.key.D:
            tilemap.set_debug(True)

    director.window.push_handlers(on_key_press)

    # run the scene
    director.run(platformer_scene)
    def __init__(self, g_c):
        super(Level1Scene, self).__init__()

        global scroller, game_controller, map_layer
        game_controller = g_c
        scroller = ScrollingManager()
        director.window.push_handlers(keyboard)

        map_layer = load("tiles/map1/map_3.tmx")['base']
        map_h = (map_layer.cells[-1][-1].y // map_layer.tw + 1)
        map_layer_bg_0 = load("tiles/map1/map_3.tmx")['background']
        map_layer_bg_1 = load("tiles/map1/map_3.tmx")['decorations']

        main_layer = MainLayer((500, 500))

        scroller.add(map_layer_bg_0, z=-2)
        scroller.add(map_layer_bg_1, z=-1)
        scroller.add(map_layer, z=0)
        scroller.add(main_layer, z=1)

        self.add(scroller)
        self.schedule_interval(main_layer.update,
                               1 / 30)  # 30 times per second
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    scroller.add(walls, z=0)

    # make the function to handle collision between actors and walls
    mapcollider = TmxObjectMapCollider()
    mapcollider.on_bump_handler = mapcollider.on_bump_bounce
    fn_collision_handler = mapcolliders.make_collision_handler(mapcollider, walls)

    # make the function to set visual focus at position
    fn_set_focus = scroller.set_focus
    
    # create a layer to put the player in
    actors_layer = layer.ScrollableLayer()
    ball = Ball((300, 300), (600, 600), fn_collision_handler, fn_set_focus, (255, 0, 255)) 
    actors_layer.add(ball)

    scroller.add(actors_layer, z=1)

    # set the player start using the object with the 'player_start' property
    player_start = walls.find_cells(player_start=True)[0]
    ball.position = player_start.center

    # set focus so the player is in view
    scroller.set_focus(*ball.position)

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#30
0
    def __init__(self,level_xml,speed=30, contents=None):
        super(GameMapBaseScene, self).__init__(contents)

        self.manager = ScrollingManager()
        self.add(self.manager)
        level = tiles.load(level_xml)
        mz = 0
        mx = 0
        for id, layer in level.find(tiles.MapLayer):
            self.manager.add(layer, z=layer.origin_z)
            mz = max(layer.origin_z, mz)
            mx = max(layer.px_width, mx)

        self.level = level
        self.px_width = mx
 def __init__(self):
     super(TestScene, self).__init__()
     scroller = layer.ScrollingManager()
     scrollable = tiles.load('road-map.xml')['map0']
     scroller.add(scrollable)
     self.add(scroller)
     template_action = ( CallFunc(scroller.set_focus, 0, 0) + Delay(1) +
                         CallFunc(scroller.set_focus, 768, 0) + Delay(1) +
                         CallFunc(scroller.set_focus, 768, 768) +Delay(1) +
                         CallFunc(scroller.set_focus, 1500, 768) +Delay(1) +
                         ScaleTo(0.75, 1) +
                         CallFunc(scrollable.set_debug, True) + Delay(1) +
                         CallFunc(director.window.set_size, 800, 600)
                       )
     scroller.do(template_action)
示例#32
0
    def __init__(self, level_xml, speed=30, contents=None):
        super(GameMapBaseScene, self).__init__(contents)

        self.manager = ScrollingManager()
        self.add(self.manager)
        level = tiles.load(level_xml)
        mz = 0
        mx = 0
        for id, layer in level.find(tiles.MapLayer):
            self.manager.add(layer, z=layer.origin_z)
            mz = max(layer.origin_z, mz)
            mx = max(layer.px_width, mx)

        self.level = level
        self.px_width = mx
示例#33
0
def main():
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False, resizable=True)
    glClearColor(255, 255, 255, 255)

    scroller = layer.ScrollingManager()
    maploaded = tiles.load('obj.tmx')
    test_layer = maploaded["tiles_layer_1"]
    scroller.add(test_layer)
    object_layer = maploaded['test_object_layer']
    scroller.add(object_layer)
    main_scene = cocos.scene.Scene(scroller)
    print(test_layer.px_width, test_layer.px_height)
    scroller.set_focus(test_layer.px_width // 2, test_layer.px_height // 2)

    director.run(main_scene)
示例#34
0
def main():
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False, resizable=True)
    glClearColor(255, 255, 255, 255)

    scroller = layer.ScrollingManager()
    maploaded = tiles.load('obj.tmx')
    test_layer = maploaded["tiles_layer_1"]
    scroller.add(test_layer)
    object_layer = maploaded['test_object_layer']
    scroller.add(object_layer)
    main_scene = cocos.scene.Scene(scroller)
    print(test_layer.px_width , test_layer.px_height)
    scroller.set_focus(test_layer.px_width // 2, test_layer.px_height //2)

    director.run(main_scene)
示例#35
0
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)

    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    worker_action = car.do(DriveCar())

    # add the map and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    worker_action.walls = walls
    scroller.add(walls, z=0)
    scroller.add(car_layer, z=1)

    player_start = walls.find_cells(player_start=True)[0]

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # give car access to the walls so it can change colors
    car.walls = walls

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
def main():
    global walls, scroller, platformer_scene
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    scroller.add(walls, z=0)

    # make the function to handle collision between actors and walls
    mapcollider = TmxObjectMapCollider()
    mapcollider.on_bump_handler = mapcollider.on_bump_bounce
    fn_collision_handler = mapcolliders.make_collision_handler(mapcollider, walls)

    # make the function to set visual focus at position
    fn_set_focus = scroller.set_focus
    
    scroller.add(Actors(fn_collision_handler), z=1)

    # set the player start using the object with the 'player_start' property
    player_start = walls.find_cells(player_start=True)[0]

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # set focus 
    scroller.set_focus(300, 300)

    # handle zoom and pan commands
    director.window.push_handlers(on_key_press)

    # run the scene
    director.run(platformer_scene)
示例#37
0
def main():
    global keyboard, walls, scroller
    from cocos.director import director
    director.init(width=800, height=600, autoscale=False)

    print(description)

    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    worker_action = car.do(DriveCar())

    # add the map and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    walls = tiles.load('tmx_collision.tmx')['walls']
    assert isinstance(walls, tiles.TmxObjectLayer)
    worker_action.walls = walls
    scroller.add(walls, z=0)
    scroller.add(car_layer, z=1)

    player_start = walls.find_cells(player_start=True)[0]

    # extract the player_start, which is not a wall
    walls.objects.remove(player_start)

    # give car access to the walls so it can change colors
    car.walls = walls

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#38
0
def main():
    global keyboard, tilemap, scroller
    from cocos.director import director
    director.init(width=800, height=600, do_not_scale=True)

    print description
    # create a layer to put the player in
    player_layer = layer.ScrollableLayer()
    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController())

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    tilemap = tiles.load('platformer-map.xml')['level0']
    scroller.add(tilemap, z=0)
    scroller.add(player_layer, z=1)

    # set the player start using the player_start token from the tilemap
    start = tilemap.find_cells(player_start=True)[0]
    r = player.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    player.position = r.center

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#39
0
def main():
    global keyboard, tilemap, scroller
    from cocos.director import director
    director.init(width=800, height=600, do_not_scale=True)

    print description
    # create a layer to put the player in
    player_layer = layer.ScrollableLayer()
    # NOTE: the anchor for this sprite is in the CENTER (the cocos default)
    # which means all positioning must be done using the center of its rect
    player = cocos.sprite.Sprite('witch-standing.png')
    player_layer.add(player)
    player.do(PlatformerController())

    # add the tilemap and the player sprite layer to a scrolling manager
    scroller = layer.ScrollingManager()
    tilemap = tiles.load('platformer-map.xml')['level0']
    scroller.add(tilemap, z=0)
    scroller.add(player_layer, z=1)

    # set the player start using the player_start token from the tilemap
    start = tilemap.find_cells(player_start=True)[0]
    r = player.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    player.position = r.center

    # construct the scene with a background layer color and the scrolling layers
    platformer_scene = cocos.scene.Scene()
    platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
    platformer_scene.add(scroller, z=1)

    # track keyboard presses
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # run the scene
    director.run(platformer_scene)
示例#40
0
def loadLvl(level, gamemode):
    global scroller
    global player_layer
    global player
    global fullmap
    global gamemoderun
    global start
    global r
    global mapcollider
    global tilemap_decorations, tilemap_walls
    global bgLayer
    try:
        fullmap = tiles.load(level.datapath)
        tilemap_walls = fullmap["walls"]
        tilemap_decorations = fullmap["decorations"]

        scroller.add(bgLayer, z=-2)
        scroller.add(tilemap_decorations, z=-1)
        scroller.add(tilemap_walls, z=0)
        scroller.add(player_layer, z=1)

        start = tilemap_walls.find_cells(player_start=True)[0]
        r = player.get_rect()
        r.midbottom = start.midbottom
        player.position = r.center

        mapcollider = mapcolliders.RectMapCollider(velocity_on_bump="slide")
        player.collision_handler = mapcolliders.make_collision_handler(
            mapcollider, tilemap_walls)

        gamemoderun = player.do(gamemode.main())

    except Exception as e:
        # TODO:
        if cfg.configuration["Debug"]["developer"] == "False":
            logger.addLog(
                "An error was caught rendering the level.\n" + str(e),
                logger.loglevel["error"])
        else:
            raise e
示例#41
0
文件: foo.py 项目: zergylord/Umwelt
def main():
  global tilemap, keyboard, scroller
  from cocos.director import director
  director.init(width=800,height=600, do_not_scale=True, resizable=True)

  actor_layer = layer.ScrollableLayer()
  actor = cocos.sprite.Sprite('car.png')
  actor_layer.add(actor)
  actor.position = (200,100)
  actor.do(ActorController())

  scroller = layer.ScrollingManager()
  tilemap = tiles.load('desert.tmx')['Ground']
  scroller.add(tilemap)
  scroller.add(actor_layer)

  main_scene = cocos.scene.Scene(scroller)

  keyboard = key.KeyStateHandler()
  director.window.push_handlers(keyboard)

  director.run(main_scene)
def main():
    
  # Declare these as global so they can be accessed within class methods.
  global keyboard
  global scroller
  
  # Initialize the window.
  director.init(width=800, height=600, do_not_scale=True, resizable=True)
  
  # Create a layer and add a sprite to it.
  player_layer = layer.ScrollableLayer()
  me = sprite.Sprite('human-female.png')
  player_layer.add(me)
  
  # Set initial position and velocity.
  me.position = (100, 100)
  me.velocity = (0, 0)
  
  # Set the sprite's movement class.
  me.do(Me())
  
  # Create scroller object and load tiles.
  scroller = layer.ScrollingManager()
  map_layer = tiles.load('tiles/map.xml')['map0']
  
  # Add map and player layers.
  scroller.add(map_layer)
  scroller.add(player_layer)

  # Create a scene and set its initial layer.
  main_scene = scene.Scene(scroller)

  # Attach a KeyStateHandler to the keyboard object.
  keyboard = key.KeyStateHandler()
  director.window.push_handlers(keyboard)

  # Play the scene in the window.
  director.run(main_scene)
示例#43
0
def main():

    # Declare these as global so they can be accessed within class methods.
    global keyboard
    global scroller

    # Initialize the window.
    director.init(width=800, height=600, do_not_scale=True, resizable=True)

    # Create a layer and add a sprite to it.
    player_layer = layer.ScrollableLayer()
    me = sprite.Sprite('human-female.png')
    player_layer.add(me)

    # Set initial position and velocity.
    me.position = (100, 100)
    me.velocity = (0, 0)

    # Set the sprite's movement class.
    me.do(Me())

    # Create scroller object and load tiles.
    scroller = layer.ScrollingManager()
    map_layer = tiles.load('tiles/map.xml')['map0']

    # Add map and player layers.
    scroller.add(map_layer)
    scroller.add(player_layer)

    # Create a scene and set its initial layer.
    main_scene = scene.Scene(scroller)

    # Attach a KeyStateHandler to the keyboard object.
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    # Play the scene in the window.
    director.run(main_scene)
示例#44
0
    def load_xml(self, level_xml):
        try:
            self.remove(self.manager)
            self.remove(self.dialog_layer)
            self.map_layer.walk(self.map_layer.remove)
        except:
            pass

        self.manager = cocos.layer.ScrollingManager()
        self.add(self.manager)
        level = tiles.load(level_xml)
        mz = 0
        mx = 0
        my = 0
        for id, layer in level.find(tiles.MapLayer):
            self.manager.add(layer, z=layer.origin_z)
            self.active_layer = layer
            mz = max(layer.origin_z, mz)
            mx = max(layer.px_width, mx)
            my = max(layer.px_height, my)

        self.level = level
        self.mx = mx
        self.my = my
        self.mz = mz
        self.add(self.dialog_layer,z = mz + 2)

        self.tilesets = []
        for id,t in level.findall(tiles.TileSet):
            self.tilesets.append(t)
#            print "id is %s"%id
#            print "t is %s"%t
#            print dir(t)
        self.reload_tileset()
        self.level_xml = level_xml
        self.level_edited = level
示例#45
0
def main():
    global keyboard, scroller, old_ij, old_cell, old_highlighted_color
    from cocos.director import director
    director.init(width=600, height=300, autoscale=False, resizable=True)

    car_layer = layer.ScrollableLayer()
    car = cocos.sprite.Sprite('car.png')
    car_layer.add(car)
    car.position = (200, 100)
    car.max_forward_speed = 200
    car.max_reverse_speed = -100
    car.do(DriveCar())

    scroller = layer.ScrollingManager()
    map_loaded = tiles.load('hexmap.tmx')
    # In Tiled we named 'tile_layer_1' our sample layer 
    test_layer = map_loaded['tile_layer_1']
    tint_green_hexmap_borders(test_layer)
    scroller.add(test_layer)
    scroller.add(car_layer)

    old_ij = 'nonexist'
    old_highlighted_color = None
    old_cell = None
    
    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
            test_layer.set_debug(True)
        elif key == pyglet.window.key.Q:
            tint_red_hexmap_borders(test_layer)
    director.window.push_handlers(on_key_press)

    def on_mouse_motion(x, y, dx, dy ):
        global scroller, old_ij, old_cell, old_highlighted_color
        #vh, vy = director.get_virtual_coordinates(x, y)
        vx, vy = scroller.screen_to_world(x,y)
        ij = test_layer.get_key_at_pixel(vx, vy)
        if ij == old_ij:
            return
        # restore color
        if old_cell:
            p, q = old_ij
            if old_highlighted_color is None:
                test_layer.set_cell_color(p, q, (255, 255, 255))
                del old_cell.properties['color4']
            else:
                test_layer.set_cell_color(p, q, old_highlighted_color[:3])

        # record info and set color
        old_ij = ij
        i, j = ij
        print(i,j)
        old_cell = test_layer.get_cell(i, j)
        if old_cell is None:
            return
        old_highlighted_color = old_cell.properties.get('color4', None)
        test_layer.set_cell_color(i, j, (255, 0, 0))
    director.window.push_handlers(on_mouse_motion)
            
        
    director.run(main_scene)
示例#46
0
from cocos import tiles, layer, actions

class HelloWorld(cocos.layer.Layer):
    def __init__(self):
        self.back_layer = tiles.load('test.tmx')['Background']
        scroller = layer.ScrollingManager()
        scroller.add(self.back_layer)
        

if __name__ == '__main__':
    # director init takes the same arguments as pyglet.window
    cocos.director.director.init()

    # We create a new layer, an instance of HelloWorld
    #hello_layer = HelloWorld ()
    tilemap = tiles.load('test.tmx')
    back_layer = tilemap['Background']
    objects = tilemap['Objects']
    start = objects['SpawnPoint']
    scroller = layer.ScrollingManager()
    scroller.add(back_layer)

    # A scene that contains the layer hello_layer
    main_scene = cocos.scene.Scene (scroller)

    # And now, start the application, starting with main_scene
    cocos.director.director.run (main_scene)

    # or you could have written, without so many comments:
    #      director.run( cocos.scene.Scene( HelloWorld() ) )
示例#47
0
class GameObj:
    my_director = director
    my_director.init()
    map_layer = load('map01.tmx')['solid']
    scroller = ScrollingManager()
    keyboard = key.KeyStateHandler()
示例#48
0
        self.y += math.cos(r) * s
        scroller.set_focus(self.x, self.y)

if __name__ == "__main__":
    from cocos.director import director
    director.init(width=600, height=300, do_not_scale=True)

    car_layer = tiles.ScrollableLayer()
    car = CarSprite('car.png')
    car.x=200
    car.y=100
    car.schedule(car.update)
    car_layer.add(car)

    scroller = tiles.ScrollingManager()
    test_layer = tiles.load('road-map.xml')['map0']
    scroller.add(test_layer)
    scroller.add(car_layer)

    main_scene = cocos.scene.Scene(scroller)

    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == .75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(.75, 2))
        elif key == pyglet.window.key.D:
示例#49
0

# For this scene, we'll be using a map with a high rectangular block that we don't want the player to be able to pass

# Just as before, I start by initializing the director
director.init(width=700, height=500, autoscale=False, resizable=True)
# This is because, as stated before, many other objects depend on the director being initialized

# And, one again, we set the keyboard and scrolling managers
scroller = ScrollingManager()
keyboard = key.KeyStateHandler()

# I'll also throw in the line that pushes Cocos's handlers to the keyboard object
director.window.push_handlers(keyboard)

mapLayer = load("mapa.tmx")["platformy"]


# This time we'll make an action that extends both the Action class and the new RectMapCollider
# The RectMapCollider, you guessed it, lets us collide with rectmaps (A.K.A. tilemaps)
class GameAction(Action, RectMapCollider):
    # To begin, we'll add a function for when the Action starts
    # I use the start function instead of an __init__ function because of the way the Action parent class is structured
    def start(self):
        # We simply set the velocity of the target sprite to zero
        self.target.velocity = 0, 0

        # We also tell the game that our sprite is starting on the ground
        self.on_ground = True

    def on_bump_handler(self, vx, vy):
示例#50
0
 def __init__(self):
     self.back_layer = tiles.load('test.tmx')['Background']
     scroller = layer.ScrollingManager()
     scroller.add(self.back_layer)
示例#51
0
		position = self.target.get_rect().copy() # get rekt
		position.x += dx
		position.y += dy

		self.target.position = position.center

		scroller.set_focus(*position.center)


class PlayerLayer(ScrollableLayer):
	def __init__(self):
		super(PlayerLayer, self).__init__()

		spritesheet = image.load('dude.png')
		frames = image.ImageGrid(spritesheet, 4, 3)
		
		self.sprite = PlayerSprite()

		self.add(self.sprite)
		self.sprite.do(PlayerAction())

player_layer = PlayerLayer()

MapLayer = load('test.tmx')['base']

scroller.add(MapLayer)
scroller.add(player_layer)

director.window.push_handlers(keyboard)
director.run(Scene(scroller))
示例#52
0
文件: map.py 项目: fyabc/MiniGames
__author__ = 'fyabc'

from cocos.tiles import load
from cocos.layer import ScrollingManager
from cocos.director import director
from cocos.scene import Scene


# This code might seem odd as there are no classes or functions or anything...
# That's because when we load a map, it generates that Layer for us

# We start off by initializing the director. This is important, as we need the director for the rest of the code to work
director.init()

# Next we load the map, and we specifically state what layer of the map we want to load
MapLayer = load("assets/mapmaking.tmx")["map0"]
# If you want to, check the mapmaking.tmx file in the assets folder to see where I declare map0
# Otherwise, make sure you name the map properly in Tiled and refer to that name in the brackets after the load function

# Here is something new! I make a ScrollingManager object to contain my map layer
scroller = ScrollingManager()
# What the ScrollingManager does is, you guessed it, manage scrolling from us
# Cocos spares us the pain of having to deal with adding support for the map scrolling when you move to the sides of it

# From here we simply add the MapLayer we made out of the map to the ScrollingManager
scroller.add(MapLayer)

# And then we make a scene out of the ScrollingManager and run it in the director!
director.run(Scene(scroller))

# I highly recommend you try making an easy program like this with your own map
示例#53
0
 def __init__(self, *args, **kwargs):
     super(ScrollingManager, self).__init__(*args, **kwargs)
     self.map_layer = load("maps/world.tmx")["tiles"]
     self.add(self.map_layer)
示例#54
0
from cocos.tiles import load
from cocos.layer import ScrollingManager
from cocos.director import director
from cocos.scene import Scene

director.init()
MapLayer = load("assets/mapmaking.tmx")["map0"]
scroller = ScrollingManager()
scroller.add(MapLayer)
director.run(Scene(scroller))
示例#55
0
    def on_key_release(self, k, _):
        self.pressed[k] = 0

    def on_mouse_press(self, x, y, buttons, modifiers):
        world_x, world_y = self.scroller.screen_to_world(x, y)
        cell = self.obstacle_layer.get_at_pixel(world_x, world_y)
        cell.tile = self.tileset[46]
        self.obstacle_layer.set_dirty()

    def update(self, dt):
        self.actor.update_position(dt, self.pressed)


if __name__ == "__main__":
    director.init(caption="Ball Drops", width=320, height=416)

    map = load("map.tmx")
    background_layer = map["background"]
    obstacle_layer = map["obstacle"]
    objects = map["objects"]
    tileset = map["tileset"]

    scroller = ScrollingManager()
    scroller.add(background_layer, z=0)
    scroller.add(obstacle_layer, z=1)
    scroller.add(GameLayer(obstacle_layer, objects, tileset), z=2)

    scene = Scene()
    scene.add(scroller)
    director.run(scene)
示例#56
0
def main():
    global keyboard, scroller, game_map
    # 初始化创建窗口
    director.init(width=800, height=640, do_not_scale=True, resizable=True)

    # 创建坦克图层
    tank_layer = layer.ScrollableLayer()

    # 创建坦克对象
    tank = cocos.sprite.Sprite(image=resources.tank_image, position=(340, 80))

    # 把坦克对象添加到坦克图层中
    tank_layer.add(tank)

    # 设置坦克的最大前进和后退速度
    tank.max_forward_speed = 200
    tank.max_reverse_speed = -100

    # 坦克对象执行一个action
    tank.do(TankController())

    # 创建滚动图层管理器,添加游戏背景图层和坦克图层到图层管理器
    scroller = layer.ScrollingManager()
    tank_map = tiles.load("test_tank.tmx")
    print type(tank_map)
    game_map = tank_map["backgroud"]

    #    print tank_map.get_resource('tank_object')
    #    tank_flag = tank_map['tank_object']
    #    scroller.add(tank_flag, z=0)

    print type(game_map), len(game_map.cells)
    print len(game_map.cells[0]), type(game_map.cells)
    #    for cell in game_map.cells:
    #        print cell
    scroller.add(game_map, z=0)
    scroller.add(tank_layer, z=1)

    # set the player start using the player_start token from the tilemap
    print len(game_map.cells)
    start = game_map.cells[21]
    print len(start)
    print type(start[4])
    # 为了不让RectCell显示,可以使其tile为None,这样就可以不加载tile图片到窗口中
    start[3].tile = None
    start = start[3]
    print game_map.is_visible(start)
    r = tank.get_rect()

    # align the mid bottom of the player with the mid bottom of the start cell
    #    r.midbottom = start.midbottom

    # player image anchor (position) is in the center of the sprite
    #    tank.position = r.center

    # 创建游戏主场景scene
    main_scene = cocos.scene.Scene()
    main_scene.add(scroller)

    #
    keyboard = key.KeyStateHandler()
    director.window.push_handlers(keyboard)

    def on_key_press(key, modifier):
        if key == pyglet.window.key.Z:
            if scroller.scale == 0.75:
                scroller.do(actions.ScaleTo(1, 2))
            else:
                scroller.do(actions.ScaleTo(0.75, 2))
        elif key == pyglet.window.key.D:
            game_map.set_debug(True)

    director.window.push_handlers(on_key_press)

    director.run(main_scene)
示例#57
0
# For this scene, we'll be using a map with a high rectangular block that we don't want the player to be able to pass

# Just as before, I start by initializing the director
director.init(width=700, height=500, autoscale=False, resizable=True)
# This is because, as stated before, many other objects depend on the director being initialized

# And, one again, we set the keyboard and scrolling managers
scroller = ScrollingManager()
keyboard = key.KeyStateHandler()

# I'll also throw in the line that pushes Cocos's handlers to the keyboard object
director.window.push_handlers(keyboard)

# We'll also load the tilemap here for clarity, as I will be using it in the class below
map_layer = load("assets/platformer_map.xml")['map0']


# I use Cocos's XML spec for this map! Check it out if you want to see how to code your own Cocos style maps
# This time we'll make an action that extends both the Action class and the new RectMapCollider
# The RectMapCollider, you guessed it, lets us collide with rectmaps (A.K.A. tilemaps)
class GameAction(Action, RectMapCollider):
    # To begin, we'll add a function for when the Action starts
    # I use the start function instead of an __init__ function because of the way the Action parent class is structured
    def start(self):
        # We simply set the velocity of the target sprite to zero
        self.target.velocity = 0, 0

        # We also tell the game that our sprite is starting on the ground
        self.on_ground = True