def __init__(self, version) -> None: self.FPS = 60 self.version = version self.state = STATES["playing"] self.screen = pygame.display.set_mode((800, 600), locals.RESIZABLE) pygame.display.set_caption("Le trésor de Klah") pygame.font.init() self.pixel_verdana = pygame.font.Font("assets/fonts/PixelFJVerdana12pt.ttf", 12) self.last_action = "nothing here :)" # charger la carte self.tmx_data = pytmx.util_pygame.load_pygame("assets/maps/spawn.tmx") self.map_data = pyscroll.data.TiledMapData(self.tmx_data) self.map_layer = pyscroll.orthographic.BufferedRenderer(self.map_data, self.screen.get_size()) self.map_layer.zoom = 2 self.map = "spawn" # générer un joueur player_position = self.tmx_data.get_object_by_name("playerspawn") self.player = player.Player(player_position.x, player_position.y) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=2) self.group.add(self.player) # liste de collisions + items self.walls = [] self.items = [] for obj in self.tmx_data.objects: if obj.type == "collision": self.walls.append(pygame.Rect(obj.x, obj.y, obj.width, obj.height)) if obj.name == "coin": coin = item.Item(obj.x, obj.y, 'purse', loot={ 'coin': random.randint(5, 10), 'emerald': 0 if random.randint(1, 10) != 1 else random.randint(1, 5), 'mushroom': 0 if random.randint(1, 5) != 1 else random.randint(0, 10), 'bone': 0 if random.randint(1, 20) != 1 else random.randint(0, 1), 'cheese': 0 if random.randint(1, 100) != 1 else random.randint(0, 1) } ) self.group.add(coin) self.items.append(coin) elif obj.name == "apple": apple = item.Item(obj.x, obj.y, 'food/redapple', loot={'apple': 1}) self.group.add(apple) self.items.append(apple) elif obj.name == "dictionary": dictionary = item.Item(obj.x, obj.y, 'books/book14', loot={'dictionary': 1}) self.group.add(dictionary) self.items.append(dictionary) elif obj.name == "map": dictionary = item.Item(obj.x, obj.y, 'parchment2', loot={'map': 1}) self.group.add(dictionary) self.items.append(dictionary) elif obj.name == "rock": rock = item.Item(obj.x, obj.y, 'rock', loot={'rock': 1}) self.group.add(rock) self.items.append(rock)
def __init__(self, event_manager, world): """ :param event_manager: event Manager :type event_manager: events.EventManager :param world: game world :type world: gameWorld.GameWorld """ self.world = world self.event_manager = event_manager self.event_manager.register_listener(self) #Set game screen self.screen = world.screen w, h = world.screen.get_size() #Create new renderer (camera) self.map_layer = pyscroll.BufferedRenderer(self.world.level.map_data, (w, h), clamp_camera=False) #The sprite should to be on top of layer named "decoration behind" #Find layer number of the layer named "decoration behind" self.render_layer = 0 for layer_index in range(len(self.world.level.tmx_data.layers)): if self.world.level.tmx_data.layers[layer_index].name == "decoration behind": self.render_layer = layer_index self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=self.render_layer)
def setup(self): pygame.init() init_spritesheet() from src.spritesheet import RougeSheet self.screen_size = (960, 600) self.screen = pygame.display.set_mode(self.screen_size) pygame.display.set_caption("Scroller Game") self.clock = pygame.time.Clock() self.map_data = load_map("map4") self.map = pyscroll.TiledMapData(self.map_data) self.map_layer = pyscroll.BufferedRenderer(self.map, self.screen_size) self.map_layer.zoom = 3 self.walls = create_walls(self.map_data) self.player = basic_player(self, RougeSheet) self.enemies = pygame.sprite.Group() add_mobs(self, self.map_data) self.all_sprites = pyscroll.PyscrollGroup(map_layer=self.map_layer) self.all_sprites.add(self.player) self.all_sprites.add(self.enemies) self.all_sprites.center(self.player.rect.center)
def switch_world(self): tmx_data = pytmx.util_pygame.load_pygame('carte.tmx') map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) map_layer.zoom = 2 # liste collision self.walls = [] for obj in tmx_data.objects: if obj.type == "collision": self.walls.append( pygame.Rect(obj.x, obj.y, obj.width, obj.height)) # dessiner le groupe de calques self.group = pyscroll.PyscrollGroup(map_layer=map_layer, default_layer=7) self.group.add(self.player) # enter_house system enter_house = tmx_data.get_object_by_name('enter_house') self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y, enter_house.width, enter_house.height) #recup le point de spawn devant maison spawn_house_point = tmx_data.get_object_by_name('enter_house_exit') self.player.position[0] = spawn_house_point.x self.player.position[1] = spawn_house_point.y + 5
def __init__(self, mapfile): self._move_queue = [] self.running = False self.last_position_update = 0 map = load_pygame(mapfile) self.layer = map.layers[1] map_data = pyscroll.data.TiledMapData(map) w, h = screen.get_size() self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size(), clamp_camera=True) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=2) self.map_layer.zoom = .5 self.player = Player(PLAYER_IMAGE) self.player.position = self.map_layer.map_rect.center self.group.add(self.player) self.mesh = Pathfinder(map)
def __init__(self, mapName="WorldMap", nameInZone="StartPointWorld", screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)): super().__init__() # Beginning MAP DATA self.nameMap = mapName # A set-up to shut down the logger 'orthographic' in pyscroll logger = logging.getLogger('orthographic') logger.setLevel(logging.ERROR) self.tmxData = pytmx.util_pygame.load_pygame( self.reqImageName(self.nameMap)) self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData) self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData, screenSize, clamp_camera=True) self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer, default_layer=SPRITE_LAYER) # Spawn point of the player valBool = False for obj in self.tmxData.objects: if obj.name == "InZone": if obj.StartPoint == nameInZone: self.spawmPointPlayerx = obj.x self.spawmPointPlayery = obj.y
def __init__(self): #céation fenetre self.screen = pygame.display.set_mode((800, 600)) pygame.display.set_caption("JeuPython") #charger la carte tmx_data = pytmx.util_pygame.load_pygame('carte.tmx') map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) map_layer.zoom = 2 #generer un joueur player_position = tmx_data.get_object_by_name("player") self.player = Player(player_position.x, player_position.y) #liste collision self.walls = [] for obj in tmx_data.objects: if obj.type == "collision": self.walls.append( pygame.Rect(obj.x, obj.y, obj.width, obj.height)) #dessiner le groupe de calques self.group = pyscroll.PyscrollGroup(map_layer=map_layer, default_layer=7) self.group.add(self.player) #enter_house system self.map = 'world' enter_house = tmx_data.get_object_by_name('enter_house') self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y, enter_house.width, enter_house.height)
def __init__(self, filename, renderer): # Load TMX data self.tmx_data = load_pysdl2(filename=filename, renderer=renderer) # Make data source for the map self.map_data = pyscroll.TiledMapData(self.tmx_data) # Make the scrolling layer screen_size = (400, 400) map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size) # make the pygame SpriteGroup with a scrolling map group = pyscroll.PyscrollGroup(map_layer=map_layer) # Add sprites to the group group.add(sprite) # Center the layer and sprites on a sprite group.center(sprite.rect.center) # Draw the layer # If the map covers the entire screen, do not clear the screen: # Clearing the screen is not needed since the map will clear it when drawn # This map covers the screen, so no clearing! group.draw(screen) # adjust the zoom (out) map_layer.zoom = .5 # adjust the zoom (in) map_layer.zoom = 2.0
def switch_world(self): # chargement de la carte tmx tmx_data = pytmx.util_pygame.load_pygame('carte.tmx') map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) map_layer.zoom = 2 # liste des collisions self.walls = [] for object in tmx_data.objects: if object.type == 'collision': self.walls.append( pygame.Rect(object.x, object.y, object.width, object.height)) # dessin du groupe de calques self.group = pyscroll.PyscrollGroup(map_layer=map_layer, default_layer=5) self.group.add(self.player) # collision pour entrer dans la maison enter_house = tmx_data.get_object_by_name('enter_house') self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y, enter_house.width, enter_house.height) # récupérer le point de spawn devant la maison spawn_house_point = tmx_data.get_object_by_name('enter_house_exit') self.player.position[0] = spawn_house_point.x self.player.position[1] = spawn_house_point.y + 20
def __init__(self, event_manager, world): """ :param event_manager: event Manager :type event_manager: events.EventManager :param world: game world :type world: gameWorld.GameWorld """ self.world = world self.event_manager = event_manager self.event_manager.register_listener(self) self.screen = world.screen w, h = world.screen.get_size() #Create new renderer/camera self.map_layer = pyscroll.BufferedRenderer(self.world.level.map_data, (w, h), clamp_camera=False, colorkey=None, alpha=True) #The player, enemies, items etc. should to be on top of #layer named in TMX "decoration behind" #Find layer number of the layer named "decoration behind" self.render_layer = 0 for layer_index in range(len(self.world.level.tmx_data.layers)): if self.world.level.tmx_data.layers[layer_index].name == "walls": self.render_layer = layer_index #content will be drawn on top of walls layer self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=self.render_layer) #Players image position is actually camera position player_image_position = self.world.appearance[self.world.player].rect #Parallax background self.star_field = parallaxStarfield.ParallaxStarfield( w, h, player_image_position.x, player_image_position.y)
def __init__(self, mapName="WorldMap", nameInZone="StartPointWorld", screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)): self.nameMap = mapName self.tmxData = pytmx.util_pygame.load_pygame( self.reqImageName(self.nameMap)) self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData) self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData, screenSize, clamp_camera=True) self.cameraPlayer # self.soundController = soundPlayerController() self.allSprites = pygame.sprite.Group() self.enemyGroup = pygame.sprite.Group() self.itemGroup = pygame.sprite.Group() self.friendlyBullet = pygame.sprite.Group() self.friendlyExplosion = pygame.sprite.Group() self.enemyBullet = pygame.sprite.Group() self.spritesHUD = pygame.sprite.Group() eFactory = EnemyFactory() iFactory = ItemFactory() for obj in self.tmxData.objects: if obj.type == "enemy": enemy = eFactory.create(obj, self) self.allSprites.add(enemy) self.enemyGroup.add(enemy) # if obj.type == "item": # item = iFactory.create(obj) # self.allSprites.add(item) # self.itemGroup.add(item) # Put camera in mapData self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer, default_layer=SPRITE_LAYER) self.camera.add(self.allSprites) # Spawn point of the player valBool = False for obj in self.tmxData.objects: if obj.name == "InZone": if obj.StartPoint == nameInZone: self.spawmPointPlayerx = obj.x self.spawmPointPlayery = obj.y valBool = True else: print('No starting point') # The game is not complete? if valBool == False: quitGame()
def load_world_map(map_file, screen): tmx_data = load_pygame(map_file) map_data = pyscroll.data.TiledMapData(tmx_data) w, h = screen.get_size() map_renderer = pyscroll.BufferedRenderer( map_data, (int(w * 0.65), int(h * 0.65))) # map renderer map_group = pyscroll.PyscrollGroup(map_layer=map_renderer, default_layer=5) # Sprite group for map return tmx_data, map_renderer, map_group
def load_world(self, world: World): w, h = self.screen.get_size() self.map_layer = pyscroll.BufferedRenderer(world.map_data, (w / SCREEN_SCALE, h / SCREEN_SCALE), clamp_camera=True) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=4) self.group.add(world.player) self.group.add(world.lemons) self.group.add(world.juice, layer=5)
def __init__(self, mapName="WorldMap", nameInZone="StartPointWorld", screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)): self.nameMap = mapName self.tmxData = pytmx.util_pygame.load_pygame( self.reqImageName(self.nameMap)) self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData) self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData, screenSize, clamp_camera=True) # self.soundController = soundPlayerController() self.allSprites = pygame.sprite.Group() self.enemyGroup = pygame.sprite.Group() self.itemGroup = pygame.sprite.Group() self.friendlyBullet = pygame.sprite.Group() self.enemyBullet = pygame.sprite.Group() self.spritesHUD = pygame.sprite.Group() self.notifySet = weakref.WeakSet( ) #Set of all object that needs to be notified of events. Weak references are used to prevent this set from keeping objects alive eFactory = EnemyFactory() iFactory = ItemFactory() for obj in self.tmxData.objects: if obj.type == "enemy": enemy = eFactory.create(obj, self) if enemy is not None: self.allSprites.add(enemy) self.enemyGroup.add(enemy) # if obj.type == "item": # item = iFactory.create(obj) # self.allSprites.add(item) # self.itemGroup.add(item) # Put camera in mapData self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer, default_layer=SPRITE_LAYER) self.camera.add(self.allSprites) # Spawn point of the player valBool = False for obj in self.tmxData.objects: if obj.name == "InZone": if obj.StartPoint == nameInZone: self.spawmPointPlayerx = obj.x self.spawmPointPlayery = obj.y valBool = True # The game is not complete? if valBool == False: quitGame()
def __init__(self, game, filename): self.game = game self.tmx_data = load_pygame('assets/maps/' + filename) self.map_data = pyscroll.TiledMapData(self.tmx_data) self.size = [ self.map_data.map_size[0] * self.map_data.tile_size[0], self.map_data.map_size[1] * self.map_data.tile_size[1] ] self.map_layer = pyscroll.BufferedRenderer(self.map_data, self.size) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
def __init__(self): self.screen = pygame.display.set_mode((1080, 720)) pygame.display.set_caption("Hero Quest") # chargement de la carte tmx_data = pytmx.util_pygame.load_pygame("map jeu.tmx") map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) # chargement du groupe avec la map self.group = pyscroll.PyscrollGroup(map_layer=map_layer, default_layer=1) #récupération de la position du spawn du joueur self.spawn_point = tmx_data.get_object_by_name("player_spawn") self.spawn_point_bis = tmx_data.get_object_by_name("spawn_2") self.sortie = tmx_data.get_object_by_name("player_spawn2") #chargement du joueur self.player = Player(self.spawn_point.x, self.spawn_point.y) self.group.add(self.player) #Zoom de la map map_layer.zoom = 2.5 #chargement de toutes les collisions self.walls = [] self.void = [] self.exit = [] self.exit2 = [] #group des monstres self.monster = pygame.sprite.Group() for obj in tmx_data.objects: if obj.name == "collision": self.walls.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) for obj in tmx_data.objects: if obj.name == "void": self.void.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) for obj in tmx_data.objects: if obj.name == "exit": self.exit.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) for obj in tmx_data.objects: if obj.name == "exit2": self.exit2.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) for obj in tmx_data.objects: if obj.name == "ennemy": self.cobra = Cobra(obj.x, obj.y) self.monster.add(self.cobra) for obj in tmx_data.objects: if obj.name == "pnj": pnj = Pnj(obj.x, obj.y) self.monster.add(pnj) #chargement des monstres self.group.add(self.monster)
def restart(): global group, enemy, obstacles, hero_group, heart, staminaa, pole, other, PILL_COUNTER del group, enemy, obstacles, hero_group, heart, staminaa, pole, other, PILL_COUNTER group = pyscroll.PyscrollGroup(map_layer=map_layer) pole = pygame.sprite.Group() enemy = pygame.sprite.Group() other = pygame.sprite.Group() PILL_COUNTER = 0 obstacles = pygame.sprite.Group() hero_group = pygame.sprite.Group() heart = pygame.sprite.Group() staminaa = pygame.sprite.Group() start_screen()
def init_graphics(self): pygame.display.set_caption('Dinos äventyr') self.screen = pygame.display.set_mode(self.size, pygame.RESIZABLE) self.background = pygame.Surface(self.screen.get_size()) self.tmx_data = pytmx.load_pygame("real_map.tmx") # Make data source for the map self.map_data = pyscroll.TiledMapData(self.tmx_data) # Make the scrolling layer screen_size = (self.width, self.height) self.map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size, clamp_camera=True, tall_sprites=1) self.map_layer.zoom = 2 # make the PyGame SpriteGroup with a scrolling map self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
def __init__(self): Scene.__init__(self) # Set window caption pygame.display.set_caption(WINDOW_CAPTION) # TODO: rewrite scenes class to allow resizing of screen globally. # See end paragraph of this article:https://nerdparadise.com/programming/pygame/part7 screen_size = [SCREEN_WIDTH, SCREEN_HEIGHT] # List variable for layers - 0 = background color; 1 = scenery; 2 = level; 3 = player; 4 = foreground # Each layer is a seperate surface. self.layers = [pygame.Surface(screen_size) for i in range(4)] # Create a sprite group of active sprites, which are all rendered in draw() function self.active_sprite_list = pygame.sprite.Group() # Create instance of player self.player_one = Player(150, 50, self) # Add player to list of active sprites, so it gets rendered in draw() function self.active_sprite_list.add(self.player_one) # Time to load our TMX level map. self.lvl1_tmx_data = pytmx.load_pygame(LEVEL_01_TMX) # Create new data source for pyscroll self.map_data = pyscroll.data.TiledMapData(self.lvl1_tmx_data) # Create new renderer (camera) # Clamp_camera is used to prevent the map from scrolling past the edge # TODO: remove screen width/height constants once we get dynamic screen sizes figured out self.map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size, clamp_camera=True) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer) # TODO: Figure out how to center player in map. # TODO: uncomment the following lines of code, and remove/rewrite active_sprite_list # For that, see https://github.com/bitcraft/pyscroll/wiki/Tutorial-(WIP) # Add our player to the group self.group.add(self.player_one) # Can be switched on with F10 key, for that see events() self.debug_mode = False self.jump_key_pressed = False self.platforms = self.get_solid_platforms( self.lvl1_tmx_data.get_layer_by_name("Collision Mask"))
def __init__(self, mapfile): self._move_queue = [] self.running = False self.last_position_update = 0 map = load_pygame(mapfile) self.mapp = load_pygame(mapfile) self.objectlist = list(self.mapp.get_tile_locations_by_gid(20)) self.objectlist2 = list(self.mapp.get_tile_locations_by_gid(20)) self.moveCounter = 0 self.layer = map.layers[1] self.objectlayer = map.layers[3] self.charizardLayer = map.layers[4] self.blastoiseLayer = map.layers[5] self.ironLayer = map.layers[6] self.venusaurLayer = map.layers[7] self.snorlaxLayer = map.layers[8] self.blastoiseLayer.visible = 0 self.ironLayer.visible = 0 self.venusaurLayer.visible = 0 self.snorlaxLayer.visible = 0 self.objectType = ["pokemon", "item"] self.rarity = [1, 2, 3, 4, 5, 6, 8] self.type = ["fire", "grass", "water", "normal"] self.itemType = ["heal", "upgrade"] self.catchableOrShiny = ["y", "n"] self.itemUseless = [0] self.apdp = [10, 15, 20, 25, 30, 35, 40, 50] self.hpOfPokemonAndPlayer = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] self.pokemonCounter = 0 self.itemCounter = 0 self.moveHelper = self.objectlist[0] self.moveCounter2 = 0 self.itemActive = 0 self.screenHelper = 1 self.hpPlayer = 100 map_data = pyscroll.data.TiledMapData(map) w, h = screen.get_size() self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size(), clamp_camera=True) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=4) self.map_layer.zoom = 1.5 self.player = Player(PLAYER_IMAGE) self.player.position = self.map_layer.map_rect.center self.group.add(self.player) self.mesh = Pathfinder(map)
def set_up_map(self): """ Sets up the map and the scrolling """ GameMap.set_up_map() pyscroll_map_data = pyscroll.data.TiledMapData(GameMap.map_data) # Scrolling Layer w, h = self.screen.get_size() self.map_layer = pyscroll.orthographic.BufferedRenderer( pyscroll_map_data, (w / 2, h / 2), clamp_camera=True) # Make group with scrolling map self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer) self.map_layer.zoom = 1.0
def switch_map(self, map_name='monestary', spawn=True): """ Switches to input map """ self.current_map = map_name # Pyscroll tm = pytmx.load_pygame(path.join(self.maps_folder, '{}.tmx'.format(map_name)), pixelalpha=True) self.map_data = pyscroll.TiledMapData(tm) screen_size = (WIDTH, HEIGHT) self.map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size) # Instantiate all_sprites group self.all_sprites = pyscroll.PyscrollGroup(map_layer=self.map_layer) for tile_object in tm.objects: obj_center = vector(tile_object.x + tile_object.width / 2, tile_object.y + tile_object.height / 2) if tile_object.name == 'player': if spawn: self.player = Player(self, obj_center.x, obj_center.y) elif not spawn: self.all_sprites.add(self.player) if tile_object.name == 'mob': Mob(self, obj_center.x, obj_center.y, tile_object.type) if tile_object.name == 'npc': Npc(self, obj_center.x, obj_center.y, tile_object.type) if tile_object.name == 'wall': Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height) if tile_object.name == 'portal': Portal(self, obj_center.x, obj_center.y, tile_object.width, tile_object.height, tile_object.type) if tile_object.name == 'spawn': Spawn(self, obj_center.x, obj_center.y, tile_object.width, tile_object.height, tile_object.type) if tile_object.name == 'readable': Readable(self, obj_center.x, obj_center.y, tile_object.width, tile_object.height, tile_object.type) if tile_object.name in POTION_ITEMS: Potion(self, obj_center, tile_object.name) if tile_object.name in SPELL_ITEMS: Spell(self, obj_center, tile_object.name) self.paused = False self.night = False self.inventory = False self.effect_sounds['level_start'].play()
def reload(self, filename, screen, music): super().__init__(filename) self.filename = filename self.music = music self.map_data = pyscroll.data.TiledMapData(self.tmx_data) self.map_layer = pyscroll.BufferedRenderer(self.map_data, (screen.get_rect().width , screen.get_rect().height), clamp_camera=True) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer) self.blockers = make_object(self, 'blocker') # 禁止角色横跨的位置 self.doors = make_object(self, 'door') # 通往其它地图的门 self.start_points = make_object(self, 'start point') # 角色在一张地图的起始点 self.sprites = make_object(self, 'sprite') # 精灵对象 self.nobattle_area = make_object(self, 'nobattle') # 非战斗区域 self.info = make_object(self, 'info') self.image_sprites = [] # 储存精灵图片对象 self.screen = screen self.create_sprite_object() pygame.mixer.music.set_volume(const.BGM_VOL / 10)
def __init__(self): self.screen = pygame.display.set_mode((1080, 720)) pygame.display.set_caption("HappyCakeQuest") # charger la carte tmx_data = pytmx.util_pygame.load_pygame('carte.tmx') map_data = pyscroll.data.TiledMapData(tmx_data) self.map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) self.map_layer.zoom = 2.8 # le group avec la map self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=3) # recuperer le point de spawn du joueur self.spawn_point = tmx_data.get_object_by_name('player_spawn') self.monsters = pygame.sprite.Group() win_point = tmx_data.get_object_by_name('win') self.win_rect = pygame.Rect(win_point.x, win_point.y, win_point.width, win_point.height) # charger le joueur self.player = Player(self.spawn_point.x, self.spawn_point.y) self.group.add(self.player) # charger les blocks de collisions self.walls = [] self.void = [] for obj in tmx_data.objects: if obj.type == "collision": self.walls.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) if obj.type == "void": self.void.append( pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height)) if obj.type == "monster": scorpion = Scorpion(obj.x, obj.y) self.monsters.add(scorpion) self.group.add(self.monsters)
def __init__(self): self.map = 'world' # fenêtre du jeu self.screen = pygame.display.set_mode((1280, 720)) pygame.display.set_caption("Pygame - Jeu 2D") # chargement de la carte tmx tmx_data = pytmx.util_pygame.load_pygame('carte.tmx') map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.orthographic.BufferedRenderer( map_data, self.screen.get_size()) map_layer.zoom = 2 # génération du joueur player_position = tmx_data.get_object_by_name("player") self.player = Player(player_position.x, player_position.y) # liste des collisions self.walls = [] for object in tmx_data.objects: if object.type == 'collision': self.walls.append( pygame.Rect(object.x, object.y, object.width, object.height)) # dessin du groupe de calques self.group = pyscroll.PyscrollGroup(map_layer=map_layer, default_layer=5) self.group.add(self.player) # collision pour entrer dans la maison enter_house = tmx_data.get_object_by_name('enter_house') self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y, enter_house.width, enter_house.height)
def load_map(self, map_name, spawn_point): self.tmx_data = load_pygame(BASEDIR / "assets" / "maps" / f"{map_name}.tmx") self.map_data = pyscroll.TiledMapData(self.tmx_data) self.map_layer = pyscroll.BufferedRenderer(self.map_data, self.GAME_AREA_SIZE_PIXELS) self.map_sprite_group = pyscroll.PyscrollGroup( map_layer=self.map_layer, default_layer=3) # Find first spawn point spawns_layer = self.tmx_data.get_layer_by_name("spawns") self.spawns = { spawn.name: [spawn.x, spawn.y] for spawn in spawns_layer } self.hero.position = self.spawns[spawn_point] self.map_sprite_group.add(self.hero) # Build impassable rect list impassables_layer = self.tmx_data.get_layer_by_name("impassables") self.impassables = [object_to_rect(o) for o in impassables_layer] doors_layer = self.tmx_data.get_layer_by_name("doors") self.doors = [(object_to_rect(o), o) for o in doors_layer]
def __init__(self): # Init game parameters pg.init() pg.font.init() self.screen = pg.display.set_mode(W_SIZE, pg.RESIZABLE) self.tmp_surface = pg.Surface(W_SIZE).convert() pg.display.set_caption("Zombie Mania - It's just a flesh wound!") self.background = load_images("BACKGROUND") # Load data from TMX-map self.map_path = "../res/maps/map0.tmx" self.tmx_data = load_pygame(self.map_path) self.map_data = pyscroll.data.TiledMapData(self.tmx_data) #self.misc_layer = self.tmx_data.layernames["Misc"] # Add static obstacles to a dict for easy collision checking self.obstacles = [] for obs in self.tmx_data.get_layer_by_name("Map"): if obs[2] != 0: pos = (obs[0] * BLOCK_SIZE, obs[1] * BLOCK_SIZE) tmp_rect = pg.Rect(pos, (BLOCK_SIZE, BLOCK_SIZE)) self.obstacles.append(tmp_rect) # Create renderer (camera) # clamp_camera is used to prevent the map from scrolling past the edge # TODO: Fix so that the renderer doesn't render the whole screen, only the visible self.map_layer = pyscroll.BufferedRenderer(self.map_data, W_SIZE, clamp_camera=True, alpha=True, tall_sprites=1) self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer) self.zombie = Zombie() self.group.add(self.zombie)
(obj.x + obj.width, 0)] for p in obj.points: print(p) # Make data source for the map map_data = pyscroll.TiledMapData(tmx_data) # Make the scrolling layer for p in tmx_data.properties.keys(): print("%s: %s", p, tmx_data.properties[p]) map_layer = pyscroll.BufferedRenderer(map_data, screen_size, alpha=False) # make the pygame SpriteGroup with a scrolling map group = pyscroll.PyscrollGroup(map_layer=map_layer) px, py = (map_layer.map_rect.width / 2, map_layer.map_rect.height / 2) group.center((px, py)) # Add sprites to the group #group.add(sprite) # Center the layer and sprites on a sprite # Draw the layer # If the map covers the entire screen, do not clear the screen: # Clearing the screen is not needed since the map will clear it when drawn # This map covers the screen, so no clearing! #bgimage = tmx_data.layers[1].image #pygame.image.save(bgimage, "exit.jpg")
def game_loop(): clock=pygame.time.Clock() recording=False terrain=make_terrain() terrain_d=TERRAIN_DIRTY() objects=[] map_layer = pyscroll.BufferedRenderer(MyData(terrain), (screen_w,screen_h)) group = pyscroll.PyscrollGroup(map_layer=map_layer) macro=[] mobs=[] dwarves=[] dw_index=0 position=TILE*2500,TILE*50 a_dwarf=Dwarf(2500*16,40*16,terrain,terrain_d,group,objects) another_dwarf=Dwarf(2502*16,40*16,terrain,terrain_d,group,objects) yet_another_dwarf=Dwarf(2505*16,40*16,terrain,terrain_d,group,objects) fourth_dwarf=Dwarf(2507*16,40*16,terrain,terrain_d,group,objects) dwarves.append(a_dwarf) group.add(a_dwarf) dwarves.append(another_dwarf) group.add(another_dwarf) dwarves.append(yet_another_dwarf) group.add(yet_another_dwarf) dwarves.append(fourth_dwarf) group.add(fourth_dwarf) a_hammer=Hammer() a_pick=PickAxe() a_sickle=Sickle() a_ladder=Ladder() group.add(a_hammer) group.add(a_pick) group.add(a_sickle) group.add(a_ladder) the_dwarf=dwarves[dw_index] a_dwarf.inventory=a_pick another_dwarf.inventory=a_ladder yet_another_dwarf.inventory=a_sickle fourth_dwarf.inventory=a_hammer while True: if android: OuyaController.startOfFrame() delta=clock.tick(30) if android: if android.check_pause(): android.wait_for_resume() events = pygame.event.get() keys = pygame.key.get_pressed() mouse = pygame.mouse.get_pressed() for e in events: if e.type==pygame.QUIT: return if e.type==pygame.KEYDOWN and e.key==pygame.K_q: return if e.type==pygame.KEYDOWN and e.key==pygame.K_k: if not recording: dw_index=(dw_index+1)%len(dwarves) if e.type==pygame.KEYDOWN and e.key==pygame.K_j: if not recording: dw_index=(dw_index-1)%len(dwarves) if e.type==pygame.KEYDOWN and e.key==pygame.K_r: if not recording: macro=["LOOP"] else: program=the_dwarf.commands_behave(macro) the_dwarf.behaviour=program macro=[] recording=not recording the_dwarf=dwarves[dw_index] the_dwarf.command=None the_dwarf.parameter=None if keys[pygame.K_c] and keys[pygame.K_RIGHT]: if the_dwarf.inventory is not None: the_dwarf.command="USE-RIGHT" elif keys[pygame.K_c] and keys[pygame.K_LEFT]: if the_dwarf.inventory is not None: the_dwarf.command="USE-LEFT" elif keys[pygame.K_c] and keys[pygame.K_DOWN]: if the_dwarf.inventory is not None: the_dwarf.command="USE-DOWN" elif keys[pygame.K_c] and keys[pygame.K_UP]: if the_dwarf.inventory is not None: the_dwarf.command="USE-UP" elif keys[pygame.K_c]: if the_dwarf.inventory is not None: the_dwarf.command="USE" elif keys[pygame.K_UP]: the_dwarf.command="UP" elif keys[pygame.K_LEFT]: the_dwarf.command="LEFT" elif keys[pygame.K_RIGHT]: the_dwarf.command="RIGHT" elif keys[pygame.K_DOWN]: the_dwarf.command="DOWN" elif keys[pygame.K_s]: if the_dwarf.inventory is not None: the_dwarf.command="PUT" elif keys[pygame.K_x]: if the_dwarf.inventory is None: the_dwarf.command="TAKE" if recording and the_dwarf.command: macro.append(the_dwarf.command) if terrain_d.get(): map_layer.redraw() group.update(delta) group.center(the_dwarf.rect.center) group.draw(screen) if len(sys.argv)==2 and sys.argv[1]=="--big": screen.blit(the_font.render("arrows-move, j/k-switch gnome",1,[255,255,255]),[5,23]) screen.blit(the_font.render("x/s-take/drop, c-use tool",1,[255,255,255]),[5,38]) off=53 else: screen.blit(the_font.render("arrows-move, j/k-switch gnome, x/s-take/drop, c-use tool",1,[255,255,255]),[5,23]) off=38 for i,dwarf in enumerate(dwarves): if dwarf.inventory is not None: screen.blit(the_font.render(dwarf.inventory.name +" "+str(dwarf.inventory.durability) +" "+str(dwarf.food/50) ,1,(255,255,255)),(5,off+i*15)) else: screen.blit(the_font.render("NOTHING" +" "+str(dwarf.food/50) ,1,(255,255,255)),(5,off+i*15)) if recording: screen.blit(rec,(0,0)) if len(sys.argv)==2 and sys.argv[1]=="--big": pygame.transform.scale(screen,(800,600),screen_real) pygame.display.flip()
def main(): os.chdir(os.path.dirname(sys.argv[0])) icon = pygame.image.load("icon.png") pygame.display.set_icon(icon) DISPLAY = init_screen(WIDTH, HEIGHT, 0) ## not resizable in the beginning pygame.mixer.music.load("Overworld.ogg") pygame.mixer.music.play(-1) ash = Ash(30, DISPLAY) startingAnimation(DISPLAY, ash) #DISPLAY = init_screen(WIDTH, HEIGHT) ash.setDisplay(temp_surface) global tmx_data, quad, map_layer, paused, onlyDirs, dir tmx_data = pytmx.load_pygame("level1.tmx") map_data = pyscroll.data.TiledMapData(tmx_data) map_layer = pyscroll.BufferedRenderer(map_data, (WIDTH / 2, HEIGHT / 2), clamp_camera=True) group = pyscroll.PyscrollGroup(map_layer=map_layer) hero = Protagonist("dudes//dude_right0.png") start = tmx_data.get_object_by_name("Start") end = tmx_data.get_object_by_name("End") hero.setPoint(start.x, start.y) group.add(hero) quad = pyscroll.quadtree.FastQuadTree(getAllRects()) Environment.setDimensions(tmx_data.width * 16, tmx_data.height * 16) env = Environment([hero], [ EnvironmentReference.applyGravity, EnvironmentReference.applyDrag, EnvironmentReference.solidGround, EnvironmentReference.keepInWindow, EnvironmentReference.collide ]) envSpring = Environment([hero], [ EnvironmentReference.solidGround, EnvironmentReference.keepInWindow, EnvironmentReference.collide ]) envClimb = Environment([hero], [ EnvironmentReference.keepInWindow, EnvironmentReference.stickToClimbable ]) dir = None pointDir = "right" jump = True num = -1 springLoad = 0 lastSpring = None startTime = None while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) #elif event.type == VIDEORESIZE: # init_screen(event.w, event.h) # map_layer.set_size((event.w / 2, event.h / 2)) elif event.type == KEYDOWN: if event.key in [K_w, K_UP] and jump: jump = False if inAir(hero) and round( math.degrees(hero.velocity.angle) ) > 45 and round( math.degrees(hero.velocity.angle) ) < 135 and hero.velocity.speed > Environment.gravity.speed: hero.addVector(Vector(270, 8)) else: hero.addVector(Vector(270, 6)) hero.update() dir = "up" num = 0 elif event.type == KEYUP: if event.key == K_F12: if not paused: pygame.mixer.music.pause() else: pygame.mixer.music.unpause() paused = not paused if event.key == K_SPACE and springLoad > 0 and dir != None and ( lastSpring == None or lastSpring + timeBetweenSprings <= time.time()): lastSpring = time.time() num = 5 x, y = getDelta() if (x, y) != (0, 0): jump = True hero.setImage("dudes//dude_{}{}.png".format(dir, num)) hero.velocity = Vector(0, 0) for i in range(springLoad * SPRING): hero.updateAbsolute(x, y) group.draw(temp_surface) envSpring.update() ash.update() pygame.transform.scale(temp_surface, DISPLAY.get_size(), DISPLAY) pygame.display.flip() clock.tick(200) springLoad = 0 hero.addVector(Environment.gravity) if event.key in [K_LSHIFT, K_v] and startTime == None: startTime = time.time() ## climbing env, envClimb = envClimb, env jump = False pygame.display.update() keysDown = pygame.key.get_pressed() if keysDown[K_d] or keysDown[K_RIGHT] and "right" in onlyDirs and ( startTime == None or canMoveClimb(hero, "right")): hero.updateAbsolute(DT, 0) dir = "right" pointDir = "right" num = (num + 1) if num + 1 <= 4 else 1 elif keysDown[K_LEFT] or keysDown[K_a] and "left" in onlyDirs and ( startTime == None or canMoveClimb(hero, "left")): hero.updateAbsolute(-DT, 0) dir = "left" pointDir = "left" num = (num + 1) if num + 1 <= 4 else 1 elif (keysDown[K_s] or keysDown[K_DOWN]) and inAir(hero) and "down" in onlyDirs and ( startTime == None or canMoveClimb(hero, "down")): hero.updateAbsolute(0, DT) dir = "down" num = 0 elif (keysDown[K_w] or keysDown[K_UP] ) and "up" in onlyDirs and startTime != None and canMoveClimb( hero, "up"): hero.updateAbsolute(0, -DT) dir = "up" elif jump == True: dir = None num = -1 if keysDown[K_SPACE]: if springLoad < 16 and startTime == None: springLoad += 1 num = 6 if atGround(hero) and not jump: jump = True dir = None num = -1 if startTime != None: pass ## num = 9 if dir in ["right", "left"]: hero.setImage("dudes//dude_{}{}.png".format(dir, num)) elif dir in ["down", "up"] and num in (0, 5): hero.setImage("dudes//dude_{}{}.png".format(dir, num)) elif dir == None and num == -1: hero.setImage("dudes//dude_{}0.png".format(pointDir)) elif dir == None and num == 6: hero.setImage("dudes//dude_{}6.png".format(pointDir)) group.center(hero.rect.center) group.draw(temp_surface) env.update() if springLoad > 0: showLoad(temp_surface, springLoad, hero) if startTime != None and startTime + climbMax <= time.time(): startTime = None env, envClimb = envClimb, env onlyDirs = ["up", "down", "left", "right", None] elif startTime != None: timeToStop = startTime + climbMax - time.time() showClimbMeter(temp_surface, round(timeToStop * (16 // climbMax)), hero) for tile, props in getCollisions(hero).items(): if props != None and "Type" in props.keys(): if props["Type"] == "Kill": if collideKill(hero, tile): gameOverAnimation(DISPLAY, hero, ash) hero.setPoint(start.x, start.y) springLoad = 0 lastSpring = None group.center(hero.rect.center) group.draw(temp_surface) pygame.transform.scale(temp_surface, DISPLAY.get_size(), DISPLAY) pygame.display.flip() while pygame.mixer.music.get_busy() and not paused: pass if not paused: pygame.mixer.music.load("Overworld.ogg") pygame.mixer.music.play(-1) elif props["Type"] == "Sign": intro = tmx_data.get_object_by_name("Intro") special = tmx_data.get_object_by_name("Special") if tile[0] * 16 == intro.x: text(DISPLAY, "Reach the other side", tile) elif tile[0] * 16 == special.x: text(DISPLAY, "Try out SPACE", tile) else: assert False, "There shouldn't be any other Signs" if tile in endTiles(end): winningAnimation(DISPLAY, ash) ash.update() pygame.transform.scale(temp_surface, DISPLAY.get_size(), DISPLAY) pygame.display.flip() clock.tick(FPS)