def _process_tile_layer(map_object: pytiled_parser.objects.TileMap, layer: pytiled_parser.objects.TileLayer, scaling: float = 1, base_directory: str = "") -> SpriteList: sprite_list = SpriteList() map_array = layer.data # Loop through the layer and add in the wall list for row_index, row in enumerate(map_array): for column_index, item in enumerate(row): # Check for empty square if item == 0: continue tile = _get_tile_by_gid(map_object, item) if tile is None: print(f"Warning, couldn't find tile for item {item} in layer " f"'{layer.name}' in file '{map_object.tmx_file}'.") continue my_sprite = _create_sprite_from_tile(map_object, tile, scaling=scaling, base_directory=base_directory) my_sprite.right = column_index * (map_object.tile_size[0] * scaling) my_sprite.top = (map_object.map_size.height - row_index - 1) * (map_object.tile_size[1] * scaling) sprite_list.append(my_sprite) return sprite_list
def _process_tile_layer(sprite_class, map_object, layer, scaling=1, base_directory=""): sprite_list = SpriteList() map_array = layer.layer_data for row_index, row in enumerate(map_array): for column_index, item in enumerate(row): if item == 0: continue tile = _get_tile_by_gid(map_object, item) if tile is None: print(f"Warning, couldn't find tile for item {item} in layer " f"'{layer.name}' in file '{map_object.tmx_file}'.") continue my_sprite = _create_sprite_from_tile(sprite_class, map_object, tile, scaling=scaling, base_directory=base_directory) if my_sprite is None: print( f"Warning: Could not create sprite number {item} in layer '{layer.name}' {tile.image.source}" ) else: my_sprite.center_x = column_index * ( map_object.tile_size[0] * scaling) + my_sprite.width / 2 my_sprite.center_y = (map_object.map_size.height - row_index - 1) \ * (map_object.tile_size[1] * scaling) + my_sprite.height / 2 sprite_list.append(my_sprite) return sprite_list
def generate_sprites(map_object, layer_name, scaling, base_directory=""): sprite_list = SpriteList() if layer_name not in map_object.layers_int_data: print(f"Warning, no layer named '{layer_name}'.") return sprite_list map_array = map_object.layers_int_data[layer_name] # Loop through the layer and add in the wall list for row_index, row in enumerate(map_array): for column_index, item in enumerate(row): if str(item) in map_object.global_tile_set: tile_info = map_object.global_tile_set[str(item)] filename = base_directory + tile_info.source my_sprite = Sprite(filename, scaling) my_sprite.right = column_index * (map_object.tilewidth * scaling) my_sprite.top = (map_object.height - row_index) * (map_object.tileheight * scaling) if tile_info.points is not None: my_sprite.set_points(tile_info.points) sprite_list.append(my_sprite) elif item != 0: print(f"Warning, could not find {item} image to load.") return sprite_list
def init(self, *args, **kwds): self.logger: Logger = getLogger(__name__) self._gameEngine: GameEngine = GameEngine() self._gameState: GameState = GameState() self._gameSettings: GameSettings = GameSettings() self._computer: Computer = Computer() self._intelligence: Intelligence = Intelligence() self._ktm: KlingonTorpedoMediator = KlingonTorpedoMediator() self._ctm: CommanderTorpedoMediator = CommanderTorpedoMediator() self._ptm: EnterpriseTorpedoMediator = EnterpriseTorpedoMediator() self._stm: SuperCommanderTorpedoMediator = SuperCommanderTorpedoMediator( ) self._km: KlingonMediator = KlingonMediator() self._cm: CommanderMediator = CommanderMediator() self._scm: SuperCommanderMediator = SuperCommanderMediator() self._epm: EnterprisePhaserMediator = EnterprisePhaserMediator() self._messageConsole: MessageConsole = MessageConsole() self._soundMachine: SoundMachine = SoundMachine() self._playerList: SpriteList = SpriteList() self._klingonList: SpriteList = SpriteList() self._commanderList: SpriteList = SpriteList() self._superCommanderList: SpriteList = SpriteList()
def process_layer(map_object: pytiled_parser.objects.TileMap, layer_name: str, scaling: float = 1, base_directory: str = "") -> SpriteList: """ This takes a map layer returned by the read_tmx function, and creates Sprites for it. :param map_object: The TileMap read in by read_tmx. :param layer_name: The name of the layer that we are creating sprites for. :param scaling: Scaling the layer up or down. (Note, any number besides 1 can create a tearing effect, if numbers don't evenly divide.) :param base_directory: Base directory of the file, that we start from to load images. :returns: A SpriteList. """ if len(base_directory) > 0 and not base_directory.endswith("/"): base_directory += "/" layer = get_tilemap_layer(map_object, layer_name) if layer is None: print(f"Warning, no layer named '{layer_name}'.") return SpriteList() if isinstance(layer, pytiled_parser.objects.TileLayer): return _process_tile_layer(map_object, layer, scaling, base_directory) elif isinstance(layer, pytiled_parser.objects.ObjectLayer): return _process_object_layer(map_object, layer, scaling, base_directory) print(f"Warning, layer '{layer_name}' has unexpected type. '{type(layer)}'") return SpriteList()
class Item(arcade.Sprite): ''' Item Class ''' def __init__(self, filename, scale, name, description, set_position, CAN_BE_PICKED_UP, level, **kwargs): super().__init__(filename, scale) self.name = name self.description = description self.center_x, self.center_y = set_position self.CAN_BE_PICKED_UP = CAN_BE_PICKED_UP self.IN_INVENTORY = kwargs.get('IN_INVENTORY', None) self.Z_INDEX = 1 self.Z_INDEX = kwargs.get('Z_INDEX', None) self.level = level def examine(self): return self.description def use(self): pass def draw(self, **kwargs): """ Draw the sprite. """ if self._sprite_list is None: from arcade import SpriteList self._sprite_list = SpriteList() self._sprite_list.append(self) self._sprite_list.draw(**kwargs)
def __init__(self): super().__init__() self.logger: Logger = getLogger(TestShooting.MADE_UP_PRETTY_MAIN_NAME) set_background_color(color.WHITE) self.background: Texture = cast(Texture, None) self._enterprise: Enterprise = cast(Enterprise, None) self._galaxy: Galaxy = cast(Galaxy, None) self._quadrant: Quadrant = cast(Quadrant, None) self._quadrantMediator: QuadrantMediator = cast(QuadrantMediator, None) self._statusConsole: StatusConsole = cast(StatusConsole, None) self._messageConsole: MessageConsole = cast(MessageConsole, None) self._gameState: GameState = cast(GameState, None) self._gameSettings: GameSettings = cast(GameSettings, None) self._gameEngine: GameEngine = cast(GameEngine, None) self._intelligence: Intelligence = cast(Intelligence, None) self._computer: Computer = cast(Computer, None) self._sprites: SpriteList = SpriteList() self._staticSprites: SpriteList = SpriteList() self._selectedGamePiece: GamePiece = cast(GamePiece, None)
def __init__(self, gl: GameLogic, zlvl_selection_tool: arcade.SpriteList, zlvl_icons): self.is_active = True self.movement_specified: MoveState = MoveState.WAIT self.action_specified: MoveState = MoveState.WAIT self.camera_pos: Tuple[int, int] = (0, 0) self.selection_tool = SelectionTool() self.zlvl_icons: arcade.SpriteList = zlvl_icons zlvl_selection_tool.append(self.selection_tool) self.gl: GameLogic = gl self.state: HI_State = HI_State.INACTIVE self.move: Optional[AI_Move] = None self.game_status: Optional[AI_GameStatus] = None self.active_selection: List[SelectionIcon] = [] self.active_hexagon: Optional[Hexagon] = None self.candidates: Optional[List[SelectionIcon]] = [] self.cursor: Optional[CustomCursor] = None self.set_cost_panel = None self.cost_panel: Optional[CostPanel] = None res = '../resources/other/hi/' #FIXME let the texture store do this self.textures = { 'hi_build_farm': (arcade.load_texture(res + 'hi_build_farm_np.png'), arcade.load_texture(res + 'hi_build_farm_p.png'), arcade.load_texture(res + 'hi_build_farm_gray.png')), 'hi_build_hut': (arcade.load_texture(res + 'hi_build_hut_np.png'), arcade.load_texture(res + 'hi_build_hut_p.png'), arcade.load_texture(res + 'hi_build_hut_gray.png')), 'hi_build_racks': (arcade.load_texture(res + 'hi_build_racks_np.png'), arcade.load_texture(res + 'hi_build_racks_p.png'), arcade.load_texture(res + 'hi_build_racks_gray.png')), 'hi_move_army': (arcade.load_texture(res + 'hi_move_army_np.png'), arcade.load_texture(res + 'hi_move_army_p.png'), arcade.load_texture(res + 'hi_move_army_gray.png')), 'hi_recruit_merc': (arcade.load_texture(res + 'hi_recruit_merc_np.png'), arcade.load_texture(res + 'hi_recruit_merc_p.png'), arcade.load_texture(res + 'hi_recruit_merc_gray.png')), 'hi_recruit_knight': (arcade.load_texture(res + 'hi_recruit_knight_np.png'), arcade.load_texture(res + 'hi_recruit_knight_p.png'), arcade.load_texture(res + 'hi_recruit_knight_gray.png')), 'hi_scout': (arcade.load_texture(res + 'hi_scout_np.png'), arcade.load_texture(res + 'hi_scout_p.png'), arcade.load_texture(res + 'hi_scout_gray.png')), 'hi_specify': (arcade.load_texture(res + 'hi_specify_1.png'), arcade.load_texture(res + 'hi_specify_2.png'), arcade.load_texture(res + 'hi_specify_2.png')), 'hi_raise_army': (arcade.load_texture(res + 'hi_raise_army_np.png'), arcade.load_texture(res + 'hi_raise_army_p.png'), arcade.load_texture(res + 'hi_raise_army_gray.png')) }
class LoadingScreen(LoadableWindowView): def __init__(self, loaded_view: Optional[LoadableWindowView] = None, loading_text: str = 'Loading', background_name: Optional[str] = None): super().__init__() self.sprite_list = SpriteList() self.loading_text = loading_text self.progress = 0 self.progress_bar = self.create_progress_bar() self.loading_background = Sprite(background_name) if \ background_name is not None else None self.sprite_list.extend( [e for e in (self.progress_bar, self.loading_background) if e] ) self.set_updated_and_drawn_lists() self.loaded_view = loaded_view @staticmethod def create_progress_bar() -> SpriteSolidColor: bar_width = 1 bar_height = int(SCREEN_HEIGHT * 0.025) bar = SpriteSolidColor(bar_width, bar_height, GREEN) bar.center_y = SCREEN_HEIGHT / 2 return bar def on_show_view(self): super().on_show_view() self.window.toggle_mouse_and_keyboard(False) def on_update(self, delta_time: float): super().on_update(delta_time) try: progress = getattr(self.loaded_view, 'loading_progress') * 15 self.update_progress(progress) self.loaded_view.on_update(delta_time) except AttributeError: self.update_progress(delta_time) self.update_progress_bar() def on_draw(self): super().on_draw() self.draw_loading_text() def draw_loading_text(self): text = ' '.join([self.loading_text, str(int(self.progress))]) draw_text(text, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 10, WHITE, 20) def update_progress(self, update: float): self.progress += update if self.progress >= 100: self.window.show_view(self.loaded_view) def update_progress_bar(self): progress = self.progress self.progress_bar.center_x = center = progress * (SCREEN_WIDTH / 200) self.progress_bar.width = 0.01 + center * 2
def draw(self, **kwargs): """ Draw the sprite. """ if self._sprite_list is None: from arcade import SpriteList self._sprite_list = SpriteList() self._sprite_list.append(self) self._sprite_list.draw(**kwargs)
def create_bottom(self, max_width: int, walls: SpriteList) -> SpriteList: quantity = int(max_width / self.texture["bottom"]["width"]) + 1 for s in range(quantity): sprite = ArcadeService.load_sprite(Sprites.bottom, 0.5) sprite.center_x = sprite.width * 0.5 + sprite.width * s sprite.center_y = sprite.height * 0.5 walls.append(sprite) return walls
def __makeKlingonSpriteList(self): if self._quadrant.klingonCount > 0: self._gameState.shipCondition = ShipCondition.Red klingonSprites: SpriteList = SpriteList() for klingon in self._quadrant.klingons: klingonSprites.append(klingon) self._quadrantMediator.klingonList = klingonSprites else: self._quadrantMediator.klingonList = SpriteList()
def __makeSuperCommanderSpriteList(self): if self._quadrant.superCommanderCount > 0: self._gameState.shipCondition = ShipCondition.Red superCommanderSprites: SpriteList = SpriteList() for superCommander in self._quadrant.superCommanders: superCommanderSprites.append(superCommander) self._quadrantMediator.superCommanderList = superCommanderSprites else: self._quadrantMediator.superCommanderList = SpriteList()
def __makeCommanderSpriteList(self): if self._quadrant.commanderCount > 0: self._gameState.shipCondition = ShipCondition.Red commanderSprites: SpriteList = SpriteList() for commander in self._quadrant.commanders: commanderSprites.append(commander) self._quadrantMediator.commanderList = commanderSprites else: self._quadrantMediator.commanderList = SpriteList()
def __makeKlingonSpriteList(self, quadrant: Quadrant): if quadrant.klingonCount > 0: self._gameState.shipCondition = ShipCondition.Red klingonSprites: SpriteList = SpriteList() for klingon in quadrant.klingons: klingonSprites.append(klingon) self.klingonList = klingonSprites else: self.klingonList = SpriteList()
def __init__(self): super().__init__() self.objects: List[Moon] = [] self.obj_sprite: Dict[Moon, arcade.Sprite] = {} self.sprites = SpriteList() self.SCALE = 10 self.UPS = 60 self._last_update = 0
def __init__(self): self.logger: Logger = getLogger(__name__) self._soundMachine: SoundMachine = SoundMachine() super().__init__() self._torpedoes: SpriteList = SpriteList() self._misses: SpriteList = SpriteList() self._explosions: SpriteList = SpriteList() self._torpedoExplosionTextures: TextureList = self._loadPhotonTorpedoExplosions( )
def _process_object_layer(map_object: pytiled_parser.objects.TileMap, layer: pytiled_parser.objects.Layer, scaling: float = 1, base_directory: str = "") -> SpriteList: sprite_list = SpriteList() for cur_object in layer.tiled_objects: if cur_object.gid is None: print( "Warning: Currently only tiles (not objects) are supported in object layers." ) continue tile = _get_tile_by_gid(map_object, cur_object.gid) my_sprite = _create_sprite_from_tile(map_object, tile, scaling=scaling, base_directory=base_directory) my_sprite.right = cur_object.location.x * scaling my_sprite.top = (map_object.map_size.height * map_object.tile_size[1] - cur_object.location.y) * scaling if cur_object.properties is not None and 'change_x' in cur_object.properties: my_sprite.change_x = float(cur_object.properties['change_x']) if cur_object.properties is not None and 'change_y' in cur_object.properties: my_sprite.change_y = float(cur_object.properties['change_y']) if cur_object.properties is not None and 'boundary_bottom' in cur_object.properties: my_sprite.boundary_bottom = float( cur_object.properties['boundary_bottom']) if cur_object.properties is not None and 'boundary_top' in cur_object.properties: my_sprite.boundary_top = float( cur_object.properties['boundary_top']) if cur_object.properties is not None and 'boundary_left' in cur_object.properties: my_sprite.boundary_left = float( cur_object.properties['boundary_left']) if cur_object.properties is not None and 'boundary_right' in cur_object.properties: my_sprite.boundary_right = float( cur_object.properties['boundary_right']) my_sprite.properties.update(cur_object.properties) # sprite.properties sprite_list.append(my_sprite) return sprite_list
class Simulation(arcade.Window): def __init__(self): super().__init__() self.objects: List[Moon] = [] self.obj_sprite: Dict[Moon, arcade.Sprite] = {} self.sprites = SpriteList() self.SCALE = 10 self.UPS = 60 self._last_update = 0 def on_update(self, delta_time: float): self._last_update += delta_time if self._last_update > 1 / self.UPS: self._last_update = 0 # Update sprites and viewport min_x, max_x = 0, 0 min_y, max_y = 0, 0 for obj in self.objects: sprite = self.obj_sprite.get(obj) if sprite is None: sprite = self.new_sprite(obj) self.obj_sprite[obj] = sprite self.sprites.append(sprite) sprite.center_x = obj.x * self.SCALE sprite.center_y = obj.y * self.SCALE min_x = min(sprite.center_x, min_x) max_x = max(sprite.center_x, max_x) min_y = min(sprite.center_y, min_y) max_y = max(sprite.center_y, max_y) margine = 100 self.set_viewport(min_x - margine, max_x + margine, min_y - margine, max_y + margine) def new_sprite(self, _: Moon): sprite = arcade.Sprite('meteorGrey_big1.png', scale=0.3) sprite.angle = randint(0, 360) return sprite def on_draw(self): arcade.start_render() self.sprites.draw()
def __init__(self, world_state: Dict[Vector, int], queue: Queue): super().__init__() self.world_state = world_state self.key_queue = queue self._sprites = SpriteList() self._obj_sprite = dict() self.score = 0 self.SCALE = 64 # shoul_update self.UPS = 60 self._last_update = 0
def __init__(self, loaded_view: Optional[LoadableWindowView] = None, loading_text: str = 'Loading', background_name: Optional[str] = None): super().__init__() self.sprite_list = SpriteList() self.loading_text = loading_text self.progress = 0 self.progress_bar = self.create_progress_bar() self.loading_background = Sprite(background_name) if \ background_name is not None else None self.sprite_list.extend( [e for e in (self.progress_bar, self.loading_background) if e] ) self.set_updated_and_drawn_lists() self.loaded_view = loaded_view
def __init__(self, window=None, attach_callbacks=True, **kwargs): """ Creates a new :py:class:`arcade.gui.UIManager` and registers the corresponding handlers to the current window. The UIManager has to be created, before :py:meth:`arcade.Window.show_view()` has been called. To support multiple views a singleton UIManager should be passed to all views. As an alternative you can remove all registered handlers of a UIManager by calling :py:meth:`arcade.gui.UIManager.unregister_handlers()` within :py:meth:`arcade.View.on_hide_view()`. :param arcade.Window window: Window to register handlers to, defaults to :py:meth:`arcade.get_window()` :param kwargs: catches unsupported named parameters """ super().__init__() # TODO really needed? self.window: Window = window if window else arcade.get_window() self._focused_element: Optional[UIElement] = None self._hovered_element: Optional[UIElement] = None self._ui_elements: SpriteList = SpriteList(use_spatial_hash=True) self._id_cache: Dict[str, UIElement] = {} self.register_event_type('on_ui_event') if attach_callbacks: self.register_handlers()
def __init__(self, width: int, height: int, title: str): super().__init__(width, height, title) set_background_color(color.BLACK) self._sprites: SpriteList = SpriteList() em: EnterpriseTorpedoMediator = EnterpriseTorpedoMediator() km: KlingonTorpedoMediator = KlingonTorpedoMediator() cm: CommanderTorpedoMediator = CommanderTorpedoMediator() sm: SuperCommanderTorpedoMediator = SuperCommanderTorpedoMediator() epm: EnterprisePhaserMediator = EnterprisePhaserMediator() self._enterpriseTorpedoExplosionTextures: TextureList = em.torpedoExplosionTextures self._klingonTorpedoExplosionTextures: TextureList = km.torpedoExplosionTextures self._commanderTorpedoExplosionTextures: TextureList = cm.torpedoExplosionTextures self._superCommanderTorpedoExplosionTextures: TextureList = sm.torpedoExplosionTextures self._phaserFireTextures: TextureList = epm.phaserFireTextures() self._etxPoint: ArcadePoint = cast(ArcadePoint, None) self._ktxPoint: ArcadePoint = cast(ArcadePoint, None) self._ctxPoint: ArcadePoint = cast(ArcadePoint, None) self._stxPoint: ArcadePoint = cast(ArcadePoint, None) self._phaserFirePoint: ArcadePoint = cast(ArcadePoint, None)
def _doWeHaveLineOfSight(self, quadrant: Quadrant, startingPoint: ArcadePoint, endPoint: ArcadePoint) -> LineOfSightResponse: """ Check to see if a planet or a StarBase prevents the Enterprise from shooting at the enemy Args: startingPoint: Returns: `True` if no obstructions, else `False` """ obstacles: SpriteList = SpriteList() if quadrant.hasPlanet is True: obstacles.append(quadrant.planet) if quadrant.hasStarBase is True: obstacles.append(quadrant.starBase) results: LineOfSightResponse = self._hasLineOfSight( startingPoint=startingPoint, endPoint=endPoint, obstacles=obstacles) self.logger.info(f'{results=}') return results
def __init__(self, window: Window, *args, **kwargs): super().__init__() self.window: Window = window self._focused_element: Optional[UIElement] = None self._hovered_element: Optional[UIElement] = None self._ui_elements: SpriteList = SpriteList(use_spatial_hash=True) self._id_cache: Dict[str, UIElement] = {} self.register_event_type('on_ui_event') # self.window.push_handlers(self) # Not as explicit as following self.window.push_handlers( self.on_draw, self.on_mouse_press, self.on_mouse_release, self.on_mouse_scroll, self.on_mouse_motion, self.on_key_press, self.on_key_release, self.on_text, self.on_text_motion, self.on_text_motion_select, )
def __init__(self): super().__init__() self._baseTorpedoMediatorLogger: Logger = getLogger(__name__) self._soundMachine: SoundMachine = SoundMachine() self._devices: Devices = Devices() self._torpedoes: SpriteList = SpriteList() self._explosions: SpriteList = SpriteList() self._torpedoFollowers: SpriteList = SpriteList(is_static=True) self._misses: SpriteList = SpriteList() self._lastTimeCheck: float = self._gameEngine.gameClock / MILLISECONDS self._baseTorpedoMediatorLogger.info(f'{self._lastTimeCheck=}')
def create_pipes(walls: SpriteList, goals: Goals) -> SpriteList: for pipe in goals: sprite = ArcadeService.load_sprite(Sprites.pipe, 1) sprite.height = max(sprite.height, pipe.height_top) top_y = pipe.top + (sprite.height * 0.5) sprite.center_x = pipe.position_x + sprite.width * 0.5 sprite.center_y = top_y sprite.angle = 180 walls.append(sprite) sprite = ArcadeService.load_sprite(Sprites.pipe, 1) sprite.height = max(sprite.height, pipe.height_bottom) bottom_y = pipe.bottom - (sprite.height * 0.5) sprite.center_x = pipe.position_x + sprite.width * 0.5 sprite.center_y = bottom_y walls.append(sprite) return walls
def generate_sprites(map_object: TiledMap, layer_name: str, scaling: float, base_directory="") -> SpriteList: """ generate_sprites has been deprecated. Use arcade.tilemap.process_layer instead. Generate the sprites for a layer in a map. :param TiledMap map_object: Map previously read in from read_tiled_map function :param layer_name: Name of the layer we want to generate sprites from. Case sensitive. :param scaling: Scaling factor. :param base_directory: Directory to read images from. Defaults to current directory. :return: List of sprites :rtype: SpriteList """ sprite_list = SpriteList() if layer_name not in map_object.layers_int_data: print(f"Warning, no layer named '{layer_name}'.") return sprite_list map_array = map_object.layers_int_data[layer_name] # Loop through the layer and add in the wall list for row_index, row in enumerate(map_array): for column_index, item in enumerate(row): if str(item) in map_object.global_tile_set: tile_info = map_object.global_tile_set[str(item)] tmx_file = base_directory + tile_info.source my_sprite = Sprite(tmx_file, scaling) my_sprite.center_x = column_index * ( map_object.tilewidth * scaling) - map_object.tilewidth / 2 * scaling my_sprite.center_y = (map_object.height - row_index) * ( map_object.tileheight * scaling) - map_object.tileheight / 2 * scaling if tile_info.points is not None: my_sprite.set_points(tile_info.points) sprite_list.append(my_sprite) elif item != 0: print(f"Warning, could not find {item} image to load.") return sprite_list
def init_enemies(self): self.enemies_list = SpriteList(is_static=True) def create_enemy(x,y): enemy = self.create_object('other/spikes/spikes-high',(x,y)) self.enemies_list.append(enemy) create_enemy(7,1) create_enemy(45,1) create_enemy(48,1) create_enemy(22,2.9) create_enemy(54,1) create_enemy(57,1) create_enemy(60,1) create_enemy(63,1) create_enemy(77,2.9) create_enemy(80,2.9) create_enemy(83,2.9) for i in range(100): create_enemy(i,-3)
def _process_object_layer(map_object: pytiled_parser.objects.TileMap, layer: pytiled_parser.objects.ObjectLayer, scaling: float = 1, base_directory: str = "") -> SpriteList: sprite_list: SpriteList = SpriteList() for cur_object in layer.tiled_objects: if cur_object.gid is None: print("Warning: Currently only tiles (not objects) are supported in object layers.") continue tile = _get_tile_by_gid(map_object, cur_object.gid) my_sprite = _create_sprite_from_tile(map_object, tile, scaling=scaling, base_directory=base_directory) x = cur_object.location.x * scaling y = (map_object.map_size.height * map_object.tile_size[1] - cur_object.location.y) * scaling my_sprite.width = width = cur_object.size[0] * scaling my_sprite.height = height = cur_object.size[1] * scaling centerX = width / 2 centerY = height / 2 rotation = -math.radians(cur_object.rotation) cosRotation = math.cos(rotation) sinRotation = math.sin(rotation) rotatedCenterX = centerX * cosRotation - centerY * sinRotation rotatedCenterY = centerX * sinRotation + centerY * cosRotation my_sprite.position = (x + rotatedCenterX, y + rotatedCenterY) my_sprite.angle = math.degrees(rotation) if cur_object.properties is not None and 'change_x' in cur_object.properties: my_sprite.change_x = float(cur_object.properties['change_x']) if cur_object.properties is not None and 'change_y' in cur_object.properties: my_sprite.change_y = float(cur_object.properties['change_y']) if cur_object.properties is not None and 'boundary_bottom' in cur_object.properties: my_sprite.boundary_bottom = float(cur_object.properties['boundary_bottom']) if cur_object.properties is not None and 'boundary_top' in cur_object.properties: my_sprite.boundary_top = float(cur_object.properties['boundary_top']) if cur_object.properties is not None and 'boundary_left' in cur_object.properties: my_sprite.boundary_left = float(cur_object.properties['boundary_left']) if cur_object.properties is not None and 'boundary_right' in cur_object.properties: my_sprite.boundary_right = float(cur_object.properties['boundary_right']) if cur_object.properties is not None: my_sprite.properties.update(cur_object.properties) # sprite.properties sprite_list.append(my_sprite) return sprite_list