def loadLevel(name): tramps = pygame.sprite.Group() monsters = pygame.sprite.Group() stars = pygame.sprite.Group() entities = pygame.sprite.Group() ground = [] world_map = tmxreader.TileMapParser().parse_decode(name) resources = helperspygame.ResourceLoaderPygame() resources.load(world_map) sprite_layers = helperspygame.get_layers_from_map(resources) monsters_layer_1 = sprite_layers[0] for monster in monsters_layer_1.objects: x = monster.x y = monster.y mn = Monster_1(x, y) monsters.add(mn) entities.add(monsters) monsters_layer_2 = sprite_layers[1] for monster in monsters_layer_2.objects: x = monster.x y = monster.y mn = Monster_2(x, y) monsters.add(mn) entities.add(monsters) monsters_layer_3 = sprite_layers[2] for monster in monsters_layer_3.objects: x = monster.x y = monster.y mn = Monster_3(x, y) monsters.add(mn) entities.add(monsters) stars_layer = sprite_layers[3] for star in stars_layer.objects: x = star.x y = star.y st = Star(x, y) stars.add(st) entities.add(stars) tramps_layer = sprite_layers[4] for tramp in tramps_layer.objects: x = tramp.x y = tramp.y tr = Trampoline(x, y) tramps.add(tr) entities.add(tramps) for i in range(200): gr = Ground(i * 32, 390) ground.append(gr) tp = Ground(i * 32, 0) ground.append(tp) entities.add(ground) colliders = (monsters, stars, tramps, ground) return sprite_layers, entities, colliders
def load(self, file_name): #Cargamos el mapa self.world_map = tmxreader.TileMapParser().parse_decode(file_name) for layer in self.world_map.layers: if 'level' in layer.properties: if self.maxh < int(layer.properties['level']): self.maxh = int(layer.properties['level']) print("loaded map:", self.world_map.map_file_name) print("tiles used:", self.world_map.width, self.world_map.height) print("found '", len(self.world_map.layers), "' layers on this map") print("max height:", self.maxh)
def __init__(self, tile_map, track_name): self.level_over = False # Level sprites self.entities = pygame.sprite.Group() self.walls = pygame.sprite.Group() self.enemies = pygame.sprite.Group() self.hero = None # Miscellaneous self.track_name = track_name self.background = Surface( (WIN_WIDTH, WIN_HEIGHT)) # create a surface (image) self.background.fill( Color(BACKGROUND_COLOR)) # fill the surface with background color # Parse a tile map path = os.path.join(os.getcwd(), "images", "tiles") world_map = tmxreader.TileMapParser().parse_decode('%s/%s.tmx' % (path, tile_map)) resources = helperspygame.ResourceLoaderPygame() resources.load(world_map) self.sprite_layers = helperspygame.get_layers_from_map(resources) walls_layer = self.sprite_layers[1] goblins_layer = self.sprite_layers[2] hero_layer = self.sprite_layers[3] # Create walls for row in range(0, walls_layer.num_tiles_x): for col in range(0, walls_layer.num_tiles_y): if walls_layer.content2D[col][row] is not None: wall = Wall(row * BLOCK_SIZE, col * BLOCK_SIZE) self.walls.add(wall) # Create goblins for gob in goblins_layer.objects: if gob is not None: goblin = Goblin(self, gob.x, gob.y) self.enemies.add(goblin) # Create a hero hero = hero_layer.objects[0] self.hero = Viking(hero.x, hero.y, self) # Assemble entities list (game objects that need to be drawn every cycle) self.entities.add(self.enemies) self.entities.add(self.hero)
def load_level(self): world_map = tmxreader.TileMapParser().parse_decode( f'levels/{self.level_now}.tmx') resources = helperspygame.ResourceLoaderPygame() resources.load(world_map) self.sprite_layers = helperspygame.get_layers_from_map(resources) platforms_layer = self.sprite_layers[0] spike_layer = self.sprite_layers[1] for row in range(0, platforms_layer.num_tiles_x): for col in range(0, platforms_layer.num_tiles_y): if platforms_layer.content2D[col][row] is not None: p = platforms.Platform(row * 32, col * 32) self.platforms_group.add(p) if spike_layer.content2D[col][row] is not None: s = platforms.Spike(row * 32, col * 32) self.spikes.add(s) exit_layer = self.sprite_layers[3] for exit in exit_layer.objects: try: x = exit.x y = exit.y except: pass else: self.exit = platforms.Exit(x, y) self.all_objects.add(self.exit) player_layer = self.sprite_layers[2] for pl in player_layer.objects: try: self.start_x = pl.x self.start_y = pl.y - 64 except: pass else: self.player = player.Player(self.start_x, self.start_y) self.all_objects.add(self.player) self.total_x = platforms_layer.num_tiles_x * 32 self.total_y = platforms_layer.num_tiles_y * 32 self.camera = camera.Camera(self.camera_configure, self.total_x, self.total_y)
def demo_pygame(file_name): """ Example showing how to use the paralax scrolling feature. """ # parser the map (it is done here to initialize the # window the same size as the map if it is small enough) world_map = tmxreader.TileMapParser().parse_decode(file_name) # init pygame and set up a screen pygame.init() pygame.display.set_caption("tiledtmxloader - " + file_name + " - keys: arrows, 0-9") screen_width = min(1024, world_map.pixel_width) screen_height = min(768, world_map.pixel_height) screen = pygame.display.set_mode((screen_width, screen_height)) # load the images using pygame resources = helperspygame.ResourceLoaderPygame() resources.load(world_map) # prepare map rendering assert world_map.orientation == "orthogonal" # renderer renderer = helperspygame.RendererPygame() # create hero sprite # use floats for hero position hero_pos_x = screen_width hero_pos_y = screen_height hero = create_hero(hero_pos_x, hero_pos_y) # cam_offset is for scrolling cam_world_pos_x = hero.rect.centerx cam_world_pos_y = hero.rect.centery # set initial cam position and size renderer.set_camera_position_and_size(cam_world_pos_x, cam_world_pos_y, screen_width, screen_height) # retrieve the layers sprite_layers = helperspygame.get_layers_from_map(resources) # filter layers sprite_layers = [ layer for layer in sprite_layers if not layer.is_object_group ] # add the hero the the right layer, it can be changed using 0-9 keys layer = get_sprite_layer(1, sprite_layers, world_map.layers) if layer is not None: layer.add_sprite(hero) # layer add/remove hero keys num_keys = [pygame.K_0, pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4, \ pygame.K_5, pygame.K_6, pygame.K_7, pygame.K_8, pygame.K_9] # variables for the main loop clock = pygame.time.Clock() running = True speed = 0.075 * 10 # set up timer for fps printing pygame.time.set_timer(pygame.USEREVENT, 1000) # mainloop while running: dt = clock.tick() # event handling for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.USEREVENT: print("fps: ", clock.get_fps()) elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: running = False elif event.key in num_keys: # find out which layer to manipulate idx = num_keys.index(event.key) # make sure this layer exists if idx < len(world_map.layers): layer = get_sprite_layer(idx, sprite_layers, world_map.layers) if layer is not None: if layer.contains_sprite(hero): layer.remove_sprite(hero) print("removed hero sprite from layer", idx) else: layer.add_sprite(hero) print("added hero sprite to layer", idx) else: print("no such layer or more than 10 layers: " + str(idx)) # find directions pressed = pygame.key.get_pressed() direction_x = pressed[pygame.K_RIGHT] - \ pressed[pygame.K_LEFT] direction_y = pressed[pygame.K_DOWN] - \ pressed[pygame.K_UP] # make sure the hero moves with same speed in all directions (diagonal!) dir_len = math.hypot(direction_x, direction_y) dir_len = dir_len if dir_len else 1.0 # update position hero_pos_x += speed * dt * direction_x / dir_len hero_pos_y += speed * dt * direction_y / dir_len hero.rect.midbottom = (hero_pos_x, hero_pos_y) # adjust camera according to the hero's position, follow him renderer.set_camera_position(hero.rect.centerx, hero.rect.centery) # clear screen, might be left out if every pixel is redrawn anyway screen.fill((255, 0, 255)) # render the map for sprite_layer in sprite_layers: if sprite_layer.is_object_group: # we dont draw the object group layers # you should filter them out if not needed continue else: renderer.render_layer(screen, sprite_layer) pygame.display.flip()
def loadLevel(name, game): global playerX, playerY # объявляем глобальные переменные, это координаты героя global total_level_height, total_level_width global sprite_layers # все слои карты world_map = tmxreader.TileMapParser().parse_decode( '%s/%s.tmx' % (FILE_DIR, name)) # загружаем карту resources = helperspygame.ResourceLoaderPygame( ) # инициируем преобразователь карты resources.load(world_map) # и преобразуем карту в понятный pygame формат sprite_layers = helperspygame.get_layers_from_map( resources) # получаем все слои карты # берем слои по порядку 0 - слой фона, 1- слой блоков, 2 - слой смертельных блоков # 3 - слой объектов монстров, 4 - слой объектов телепортов platforms_layer = sprite_layers[1] dieBlocks_layer = sprite_layers[2] for row in range( 0, platforms_layer.num_tiles_x): # перебираем все координаты тайлов for col in range(0, platforms_layer.num_tiles_y): if platforms_layer.content2D[col][row] is not None: pf = Platform(row * PLATFORM_WIDTH, col * PLATFORM_WIDTH ) # как и прежде создаем объкты класса Platform game.entities.add(pf) game.platforms.append(pf) if dieBlocks_layer.content2D[col][row] is not None: bd = BlockDie(row * PLATFORM_WIDTH, col * PLATFORM_WIDTH) game.dieskeletgroup.add(bd) game.entities.add(bd) game.platforms.append(bd) teleports_layer = sprite_layers[4] for teleport in teleports_layer.objects: try: # если произойдет ошибка на слое телепортов goX = int(teleport.properties["goX"]) * PLATFORM_WIDTH + 35 goY = int(teleport.properties["goY"]) * PLATFORM_HEIGHT x = teleport.x y = teleport.y - PLATFORM_HEIGHT tp = BlockTeleport(x, y, goX, goY) game.entities.add(tp) game.platforms.append(tp) game.teleport.add(tp) except: # то игра не вылетает, а просто выводит сообщение о неудаче print(u"Ошибка на слое телепортов") monsters_layer = sprite_layers[3] for monster in monsters_layer.objects: try: x = monster.x y = monster.y if monster.name == "Player": playerX = x playerY = y - PLATFORM_HEIGHT elif monster.name == "Princess": cp = Cup(x, y - 10) game.cupgroup.add(cp) game.entities.add(cp) game.platforms.append(cp) else: up = int(monster.properties["up"]) maxUp = int(monster.properties["maxUp"]) left = int(monster.properties["left"]) maxLeft = int(monster.properties["maxLeft"]) mn = Monster(x, y - PLATFORM_HEIGHT, left, up, maxLeft, maxUp) game.monsters.add(mn) except: print(u"Ошибка на слое монстров") total_level_width = platforms_layer.num_tiles_x * PLATFORM_WIDTH # Высчитываем фактическую ширину уровня total_level_height = platforms_layer.num_tiles_y * PLATFORM_HEIGHT # высоту
def subload(self, ld): gd = self.gd world_map = tmxreader.TileMapParser().parse_decode( "../tiled-maps/grave.tmx") print(world_map.tile_sets[0].images[0].source) used = list( sorted( set( sum([list(l.decoded_content) for l in world_map.layers], [])) - {0})) print('used', used) self.world_map = world_map self.used = used ts = world_map.tile_sets[0] tw = int(ts.tilewidth) th = int(ts.tileheight) im = (Image.open(world_map.tile_sets[0].images[0].source)) def extract(i): if hasattr(ts, 'columns'): w = int(ts.columns) elif not hasattr(ts, 'spacing'): w = im.size[0] // tw else: w = (im.size[0] + ts.spacing) // (tw + ts.spacing) x = ts.margin + (tw + ts.spacing) * (i % w) y = ts.margin + (th + ts.spacing) * (i // w) print(i, 'is at', (x, y)) r = im.crop((x + 0, y + 0, x + tw, y + th)) r.save("x%d.png" % i) if 0 and scale: r = r.resize((stw, sth), Image.ANTIALIAS) return r if 0: for ti in used: t = extract(ti).resize((90, 90), Image.BICUBIC) print(ti, t) gd.BitmapHandle(0) ld.Lastc("grave-moon.astc") gd.BitmapHandle(1) ld.L4(Image.open("grave-bg0.png").convert("L")) gd.BitmapSize(gd3.BILINEAR, gd3.REPEAT, gd3.BORDER, 1280, 95) tilebase = ld.a gd.BitmapHandle(2) if 1: for ti in used: ti -= 1 print('loading', ti) t = extract(ti).resize((TD, TD), Image.BICUBIC) (_, d) = gameduino2.convert.convert(t, False, gd3.ARGB4) ld.add(d) gd.cmd_setbitmap(tilebase, gd3.ARGB4, TD, TD) h = 120 walks = [] for i in range(1, 11): walk = Image.open("zombie/Walk (%d).png" % i).resize( (430 * h // 519, h), Image.BILINEAR) walks.append(walk) gd.BitmapHandle(3) ld.ARGB4s(walks) print('end', hex(ld.a))
def loadLevel(name): world_map = tmxreader.TileMapParser().parse_decode( '%s/%s.tmx' % (FILE_DIR, name)) # загружаем карту resources = helperspygame.ResourceLoaderPygame( ) # инициируем преобразователь карты resources.load(world_map) # и преобразуем карту в понятный pygame формат sprite_layers = helperspygame.get_layers_from_map( resources) # получаем все слои карты # берем слои по порядку # 0 - слой фона, # 1 - слой блоков, # 2 - слой смертельных блоков # 3 - слой объектов монстров, # 4 - слой объектов телепортов platforms_layer = sprite_layers[1] dieBlocks_layer = sprite_layers[2] for row in range( 0, platforms_layer.num_tiles_x): # перебираем все координаты тайлов for col in range(0, platforms_layer.num_tiles_y): if platforms_layer.content2D[col][row]: pf = Platform(row * PLATFORM_WIDTH, col * PLATFORM_WIDTH ) # как и прежде создаем объкты класса Platform platforms.append(pf) if dieBlocks_layer.content2D[col][row]: bd = BlockDie(row * PLATFORM_WIDTH, col * PLATFORM_WIDTH) platforms.append(bd) teleports_layer = sprite_layers[4] for teleport in teleports_layer.objects: goX = int(teleport.properties["goX"]) * PLATFORM_WIDTH goY = int(teleport.properties["goY"]) * PLATFORM_HEIGHT x = teleport.x y = teleport.y - PLATFORM_HEIGHT tp = BlockTeleport(x, y, goX, goY) entities.add(tp) platforms.append(tp) animatedEntities.add(tp) playerX = 65 playerY = 65 monsters_layer = sprite_layers[3] for monster in monsters_layer.objects: x = monster.x y = monster.y if monster.name == "Player": playerX = x playerY = y - PLATFORM_HEIGHT elif monster.name == "Princess": pr = Princess(x, y - PLATFORM_HEIGHT) platforms.append(pr) entities.add(pr) animatedEntities.add(pr) else: up = int(monster.properties["up"]) maxUp = int(monster.properties["maxUp"]) left = int(monster.properties["left"]) maxLeft = int(monster.properties["maxLeft"]) mn = Monster(x, y - PLATFORM_HEIGHT, left, up, maxLeft, maxUp) entities.add(mn) platforms.append(mn) monsters.add(mn) total_level_width = platforms_layer.num_tiles_x * PLATFORM_WIDTH # Высчитываем фактическую ширину уровня total_level_height = platforms_layer.num_tiles_y * PLATFORM_HEIGHT # высоту return playerX, playerY, total_level_height, total_level_width, sprite_layers
def demo_pyglet(file_name): """Demonstrates loading, rendering, and traversing a Tiled map in pyglet. TODO: Maybe use this to put topleft as origin: glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, (double)mTarget->w, (double)mTarget->h, 0.0, -1.0, 1.0); """ import pyglet from pyglet.gl import glTranslatef, glLoadIdentity world_map = tmxreader.TileMapParser().parse_decode(file_name) # delta is the x/y position of the map view. # delta is a list so that it can be accessed from the on_draw method of # window and the update function. Note that the position is in integers to # match Pyglet Sprites. Using floating-point numbers causes graphical # problems. See http://groups.google.com/group/pyglet-users/browse_thread/thread/52f9ae1ef7b0c8fa?pli=1 delta = [200, -world_map.pixel_height + 150, 0] frames_per_sec = 1.0 / 30.0 # Disable vsync is mandatory for fps > 60 window = pyglet.window.Window(vsync=False, width=1024, height=768) fps_display = pyglet.clock.ClockDisplay() pyglet.clock.set_fps_limit(0) @window.event def on_draw(): window.clear() # Reset the "eye" back to the default location. glLoadIdentity() # Move the "eye" to the current location on the map. glTranslatef(*delta) # TODO: [21:03] thorbjorn: DR0ID_: You can generally determine the range of tiles that are visible before your drawing loop, which is much faster than looping over all tiles and checking whether it is visible for each of them. # [21:06] DR0ID_: probably would have to rewrite the pyglet demo to use a similar render loop as you mentioned # [21:06] thorbjorn: Yeah. # [21:06] DR0ID_: I'll keep your suggestion in mind, thanks # [21:06] thorbjorn: I haven't written a specific OpenGL renderer yet, so not sure what's the best approach for a tile map. # [21:07] thorbjorn: Best to create a single texture with all your tiles, bind it, set up your vertex arrays and fill it with the coordinates of the tiles currently on the screen, and then let OpenGL draw the bunch. # [21:08] DR0ID_: for each layer? # [21:08] DR0ID_: yeah, probably a good approach # [21:09] thorbjorn: Ideally for all layers at the same time, if you don't have to draw anything in between. # [21:09] DR0ID_: well, the NPC and other dynamic things need to be drawn in between, right? # [21:09] thorbjorn: Right, so maybe once for the bottom layers, then your complicated stuff, and then another time for the layers on top. batch.draw() pyglet.graphics.draw( len(coord_points) // 2, pyglet.gl.GL_POINTS, ('v2i', coord_points)) # fps_display cost a bit of performances, use print every second instead # glLoadIdentity() # fps_display.draw() keys = pyglet.window.key.KeyStateHandler() window.push_handlers(keys) resources = ResourceLoaderPyglet() resources.load(world_map) def update(dt): # The speed is 3 by default. # When left Shift is held, the speed increases. # The speed interpolates based on time passed, so the demo navigates # at a reasonable pace even on huge maps. speed = (3 + keys[pyglet.window.key.LSHIFT] * 6) * \ int(dt / frames_per_sec) if keys[pyglet.window.key.LEFT]: delta[0] += speed if keys[pyglet.window.key.RIGHT]: delta[0] -= speed if keys[pyglet.window.key.UP]: delta[1] -= speed if keys[pyglet.window.key.DOWN]: delta[1] += speed # Generate the graphics for every visible tile. batch = pyglet.graphics.Batch() sprites = [] coord_points = tuple() group_num = 0 for layer in world_map.layers: if not layer.visible: continue if layer.is_object_group: # This is unimplemented in this minimal-case example code. # Should you as a user of tmxreader need this layer, # I hope to have a separate demo using objects as well. continue for y_tile in range(layer.height): group = pyglet.graphics.OrderedGroup(group_num) group_num += 1 for x_tile in range(layer.width): image_id = layer.content2D[x_tile][y_tile] if image_id > 0: image_file = resources.indexed_tiles[image_id][2] # The loader needed to load the images upside-down to match # the tiles to their correct images. This reversal must be # done again to render the rows in the correct order. sprites.append( pyglet.sprite.Sprite(image_file, world_map.tilewidth * x_tile, world_map.tileheight * (layer.height - y_tile), batch=batch, group=group)) coord_points = coord_points + (world_map.tilewidth * x_tile, world_map.tileheight * (layer.height - y_tile)) pyglet.clock.schedule_interval(update, frames_per_sec) def print_fps(delta): print("FPS : " + str(pyglet.clock.get_fps())) pyglet.clock.schedule_interval(print_fps, 1) pyglet.clock.set_fps_limit(0) pyglet.app.run()