def compute_rectangles(self, texture, game_object, camera): flags = sdl2.stdinc.Uint32() access = ctypes.c_int() img_w = ctypes.c_int() img_h = ctypes.c_int() sdl_call( SDL_QueryTexture, texture, ctypes.byref(flags), ctypes.byref(access), ctypes.byref(img_w), ctypes.byref(img_h), _check_error=lambda rv: rv < 0 ) rect = getattr(game_object, 'rect', None) if rect: src_rect = SDL_Rect(*rect) win_w = rect[2] * game_object.size win_h = rect[3] * game_object.size else: src_rect = SDL_Rect(x=0, y=0, w=img_w, h=img_h) if hasattr(game_object, 'width'): obj_w = game_object.width obj_h = game_object.height else: obj_w, obj_h = game_object.size win_w, win_h = self.target_resolution(img_w.value, img_h.value, obj_w, obj_h, camera.pixel_ratio) center = camera.translate_point_to_screen(game_object.position) dest_rect = SDL_Rect( x=int(center.x - win_w / 2), y=int(center.y - win_h / 2), w=int(win_w), h=int(win_h), ) return src_rect, dest_rect, ctypes.c_double(-game_object.rotation)
def draw(self, renderer: SDL_Renderer): if self._show: x = 0 + self._width * self._frame src_rect = SDL_Rect(x, 0, self._width, self._height) dst_rect = SDL_Rect(self._x, self._y, self._width, self._height) SDL_RenderCopy(renderer, self._texture, byref(src_rect), byref(dst_rect))
def render(self, sprites, x=None, y=None): """Overrides the render method of sdl2.ext.TextureSpriteRenderSystem to use "SDL_RenderCopyEx" instead of "SDL_RenderCopy" to allow sprite rotation: http://wiki.libsdl.org/SDL_RenderCopyEx """ r = SDL_Rect(0, 0, 0, 0) if isiterable(sprites): rcopy = SDL_RenderCopyEx renderer = self.sdlrenderer x = x or 0 y = y or 0 for sp in sprites: r.x = x + sp.x r.y = y + sp.y r.w, r.h = sp.size if rcopy(renderer, sp.texture, None, r, sp.angle, None, SDL_FLIP_NONE) == -1: raise SDLError() else: r.x = sprites.x r.y = sprites.y r.w, r.h = sprites.size if x is not None and y is not None: r.x = x r.y = y SDL_RenderCopyEx(self.sdlrenderer, sprites.texture, None, r, sprites.angle, None, SDL_FLIP_NONE) SDL_RenderPresent(self.sdlrenderer)
def draw(self, graphics): destRect = SDL_Rect() for tileX in range(0, game.SCREEN_WIDTH, BACKGROUND_SIZE): for tileY in range(0, game.SCREEN_HEIGHT, BACKGROUND_SIZE): destRect.x = units.tileToPixel(tileX) destRect.y = units.tileToPixel(tileY) destRect.w = destRect.h = units.tileToPixel(BACKGROUND_SIZE) graphics.blitSurface(self.surfaceId, None, destRect)
def addAnimation(self, frames, x, y, name, width, height, offset): rects = [] for i in range(0, frames): rects.append(SDL_Rect((i + x) * width, y, width, height)) self._animations[name] = rects self._offsets[name] = offset
def update_tile_layer(self, layer): tw = self.tmx_data.tilewidth th = self.tmx_data.tileheight pos = self.position background = layer.properties['background'] tile_position = [0, 0] # iterate over the tiles in the layer if background == "true": for x, y, data in layer.tiles(): tile_set = data[0] tile_crop = data[1] tile_position[0] = int(((x - y) * tw / 2) + pos[0] + (self.size[0] / 2) - (tw / 2)) tile_position[1] = int(((x + y) * th / 2) + pos[1]) tile = subsurface(self.tile_sets[tile_set], tile_crop) rect = SDL_Rect(tile_position[0], tile_position[1]) SDL_BlitSurface(tile, None, self.bg_surface, rect) """
def process(self, world, componentsets): for playerdata, frames, motion_type, facing, sprite in componentsets: if not playerdata.life: return self.frame_timer.update() self.facing = facing.get() self.motion_type = motion_type.get() if (self.facing != self.last_facing) or (self.motion_type != self.last_motion_type): frames.set(0) if frames.get() == self.sprite_sheet.get_sprite_sheet_width(self.motion_type) / 128: frames.set(0) self.last_facing = self.facing self.last_motion_type = self.motion_type self.surface = self.sprite_sheet.get_surface(frames.get(), motion_type.get(), facing.get()) self.sprite_surface = sprite.surface rect = SDL_Rect(0, 0) SDL_FillRect(self.sprite_surface, None, 0x000000) SDL_BlitSurface(self.surface, None, self.sprite_surface, rect) if self.frame_timer.check(): self.frame_timer.reset() self.frame_timer.activate() frames.bump()
def update_tile_layer(self, layer): tw = self.tmx_data.tilewidth th = self.tmx_data.tileheight position = self.position tile_position = [0, 0] if "background" in layer.properties: background = convert_to_bool(layer.properties['background']) if background: for x, y, data in layer.tiles(): tile_set = data[0] tile_crop = data[1] tile_position[0] = int(((x - y) * tw / 2) + position[0] + (self.size[0] / 2) - (tw / 2)) tile_position[1] = int(((x + y) * th / 2) + position[1]) tile = subsurface(self.tile_sets[tile_set], tile_crop) rect = SDL_Rect(tile_position[0], tile_position[1]) SDL_BlitSurface(tile, None, self.surfaces["background"], rect) elif not background: for x, y, data in layer.tiles(): tile_set = data[0] tile_crop = data[1] tile_position[0] = int(((x - y) * tw / 2) + position[0] + (self.size[0] / 2)) tile_position[1] = int(((x + y) * th / 2) + position[1] - 72) if tile_position[1] < (WindowSize.HEIGHT / 2): tile = subsurface(self.tile_sets[tile_set], tile_crop) rect = SDL_Rect(tile_position[0], tile_position[1]) SDL_BlitSurface(tile, None, self.surfaces["behind"], rect) else: pass tile = subsurface(self.tile_sets[tile_set], tile_crop) rect = SDL_Rect(tile_position[0], tile_position[1]) SDL_BlitSurface(tile, None, self.surfaces["front"], rect)
def create_surface(self, lines, font_size): max_chars = 8 tile_size = 16 offset = tile_size * 4 width = font_size * max_chars height = font_size * lines surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width + offset, height + offset, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000) cols = int(width / tile_size) + 3 rows = int(height / tile_size) + 3 sprite_crop = [0, 0, tile_size, tile_size] for i in range(cols + 1): for j in range(rows + 1): if (i == 0) and (j == 0): sprite_crop[0] = 0 sprite_crop[1] = 0 elif (i < cols) and (j == 0): sprite_crop[0] = 16 sprite_crop[1] = 0 elif (i == cols) and (j == 0): sprite_crop[0] = 32 sprite_crop[1] = 0 elif (i == cols) and (j < rows): sprite_crop[0] = 32 sprite_crop[1] = 16 elif (i == 0) and (j < rows): sprite_crop[0] = 0 sprite_crop[1] = 16 elif (i == 0) and (j == rows): sprite_crop[0] = 0 sprite_crop[1] = 32 elif (i < cols) and (j == rows): sprite_crop[0] = 16 sprite_crop[1] = 32 elif (i == cols) and (j == rows): sprite_crop[0] = 32 sprite_crop[1] = 32 else: sprite_crop[0] = 16 sprite_crop[1] = 16 rect = SDL_Rect((16 * i), (16 * j)) tile = subsurface(self.border_sprite_sheet, sprite_crop) SDL_BlitSurface(tile, None, surface, rect) return surface
def compute_rectangles(self, texture, game_object, camera): flags = sdl2.stdinc.Uint32() access = ctypes.c_int() img_w = ctypes.c_int() img_h = ctypes.c_int() sdl_call(SDL_QueryTexture, texture, ctypes.byref(flags), ctypes.byref(access), ctypes.byref(img_w), ctypes.byref(img_h), _check_error=lambda rv: rv < 0) src_rect = SDL_Rect(x=0, y=0, w=img_w, h=img_h) if hasattr(game_object, 'width'): obj_w = game_object.width obj_h = game_object.height else: obj_w, obj_h = game_object.size win_w, win_h = self.target_resolution(img_w.value, img_h.value, obj_w, obj_h, camera.pixel_ratio) try: center = camera.translate_point_to_screen(game_object.position) except TypeError as error: raise TypeError( f"""{type(game_object).__name__}.position was set to a tuple: (number, number) Expected a vector: Vector(number, number) """) from error dest_rect = SDL_Rect( x=int(center.x - win_w / 2), y=int(center.y - win_h / 2), w=win_w, h=win_h, ) return src_rect, dest_rect, ctypes.c_double(-game_object.rotation)
def draw(): # clear the surface SDL_RenderClear(renderer.sdlrenderer) # start rendering to the temporary texture # which will contain Link with a shadow SDL_SetRenderTarget(renderer.sdlrenderer, temp_tex) # with a transparent background SDL_SetRenderDrawColor(renderer.sdlrenderer, 0, 0, 0, 0) SDL_RenderClear(renderer.sdlrenderer) # blit overlay to temp texture link_target = SDL_Rect(link_x, link_x, 16, 16) overlay_target = SDL_Rect(flame_x + link_x, flame_y + link_x, 16, 16) SDL_RenderCopy(renderer.sdlrenderer, images["overlay"], overlay_target, link_target) # blit Link to temp texture, # using his own alpha but subtracting colour from the overlay link_target = SDL_Rect(link_x, link_x, 16, 16) SDL_SetTextureBlendMode(images["link-right"], blendmode) SDL_RenderCopy(renderer.sdlrenderer, images["link-right"], None, link_target) # render to the game map SDL_SetRenderTarget(renderer.sdlrenderer, game_tex) # with a gloomy red backdrop SDL_SetRenderDrawColor(renderer.sdlrenderer, 30, 20, 25, 255) SDL_RenderClear(renderer.sdlrenderer) # draw the bonfire target = SDL_Rect(flame_x, flame_y, flame_w, flame_h) SDL_RenderCopy(renderer.sdlrenderer, images["flame"], None, target) # draw the game map to the screen, scaled up SDL_SetTextureBlendMode(temp_tex, SDL_BLENDMODE_BLEND) SDL_RenderCopy(renderer.sdlrenderer, temp_tex, None, None) # blit surface onto screen, scaled up SDL_SetRenderTarget(renderer.sdlrenderer, None) SDL_RenderCopy(renderer.sdlrenderer, game_tex, None, None) SDL_RenderPresent(renderer.sdlrenderer) window.refresh()
def __init__(self, name, width, height, count): super(SpriteSheet, self).__init__() self.name = name self.frame = 0 self.motion_types = MotionType().get_all() self.motion_type = 0 self.facing = 0 self.sprite = None self.sprite_surface = None self.sprite_size = width, height self.sprites_path = {} self.images = {} self.surfaces = {} self.surfaces_size = {} self.surfaces_with = [] self.surfaces_height = 0 for k, v in self.motion_types.items(): LOG.debug(f"filename {self.name}_{k}.png") path = RESOURCES.get_path(f"{self.name}_{k}.png") mt = self.motion_types[k] LOG.debug(f"motion_type: {mt}") # for k, v in self.sprites_path.items(): self.images[mt] = load_image(path) self.surfaces_size[mt] = self.images[mt].w, self.images[mt].h self.surfaces_with = self.images[mt].w self.surfaces_height = self.images[mt].h LOG.debug(f"WIDHT {self.surfaces_with}") LOG.debug(f"HEIGHT {self.surfaces_height}") new_surface = SDL_CreateRGBSurface(SDL_SWSURFACE, self.surfaces_with, self.surfaces_height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000) i = 0 for filename, surface in self.images.items(): vertical_offset = i * self.images[filename].h rect = SDL_Rect(0, vertical_offset, self.images[filename].w, self.images[filename].h) SDL_BlitSurface(surface, None, new_surface, rect) i += 1 self.surfaces[mt] = new_surface LOG.debug(f"SURFACE {self.surfaces}")
def to_sdl_rect(rl): """Convert `rectlike` to the SDL_Rect `rect`. Args: rl (tuple|Rect): a rectlike object to be converted, may be a Rect or a (x, y, w, h) tuple. Returns: SDL_Rect """ rl = Rect(rl) return SDL_Rect(rl.x, rl.y, rl.w, rl.h)
def process(self, world, components): # Processing code that will render all existing CParticle # components that currently exist in the world. We have a 1:1 # mapping between the created particle entities and associated # particle components; that said, we render all created # particles here. # We deal with quite a set of items, so we create some shortcuts # to save Python the time to look things up. # # The SDL_Rect is used for the blit operation below and is used # as destination position for rendering the particle. r = SDL_Rect() # The SDL2 blit function to use. This will take an image # (SDL_Texture) as source and copies it on the target. dorender = SDL_RenderCopy # And some more shortcuts. sdlrenderer = self.renderer.renderer images = self.images # Before rendering all particles, make sure the old ones are # removed from the window by filling it with a black color. self.renderer.clear(0x0) # Render all particles. for particle in components: # Set the correct destination position for the particle r.x = int(particle.x) r.y = int(particle.y) # Select the correct image for the particle. img = images[particle.type] r.w, r.h = img.size # Render (or blit) the particle by using the designated image. dorender(sdlrenderer, img.texture, None, r) self.renderer.present()
def __init__(self, name): super(SpriteSheet, self).__init__() self.name = name self.frame = 0 self.motion_types = MotionType().get_all() self.motion_type = 0 self.facing = 0 self.sprite = None self.sprite_surface = None self.sprite_size = 128, 128 self.sprites_path = {} for k, v in self.motion_types.items(): self.sprites_path[v] = RESOURCES.get_path("{0}_{1}.png".format( self.name, k)) self.surfaces = {} self.surfaces_size = {} self.surfaces_with = [] self.surfaces_height = 0 for k, v in self.sprites_path.items(): self.surfaces[k] = load_image(v) self.surfaces_size[k] = self.surfaces[k].w, self.surfaces[k].h self.surfaces_with.append(self.surfaces[k].w) self.surfaces_height += self.surfaces[k].h self.surface_height = self.surfaces[k].h self.surfaces_with = max(self.surfaces_with) self.surface = SDL_CreateRGBSurface(SDL_SWSURFACE, self.surfaces_with, self.surfaces_height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000) i = 0 for filename, surface in self.surfaces.items(): vertical_offset = i * self.surfaces[filename].h rect = SDL_Rect(0, vertical_offset, self.surfaces[filename].w, self.surfaces[filename].h) SDL_BlitSurface(surface, None, self.surface, rect) i += 1
def drawAnimation(self, x, y): if self._visible: dest_rect = SDL_Rect() src_rect = None dest_rect.x = int(x + self._offsets[self._current_animation].x) dest_rect.y = int(y + self._offsets[self._current_animation].y) dest_rect.w = int(self._src_rect.w * game_globals.SPRITE_SCALE) dest_rect.h = int(self._src_rect.h * game_globals.SPRITE_SCALE) src_rect = self._animations[self._current_animation][ self._frame_index] self._graphics.blitSurface(self._sprite_sheet, src_rect, dest_rect)
def _draw_arr(self, arr): if arr.size == 0: return self.last_data = arr arr = np.flip(self._normalize_arr(arr), -1) color_to_rects = {} for i, row in enumerate(arr): for j, val in enumerate(row): color = self.colors[int(val * self.num_colors)] px, py = int(i * self.scaling), int(j * self.scaling) rects = color_to_rects.setdefault(color, []) rects.append( SDL_Rect(self.offset_x + px, self.offset_y + py, int((i + 1) * self.scaling) - px - self.grid_px, int((j + 1) * self.scaling) - py - self.grid_px)) bg_color = 0 if self.grid_px else 40 _clear_screen(self.surface, (bg_color, bg_color, bg_color)) for color, rects in color_to_rects.items(): _draw_rects(self.surface, rects, color)
def process(self, world, componentsets): for horsedata, frames, motion_type, facing, sprite in componentsets: self.facing = facing.get() self.motion_type = motion_type.get() count = 16 if self.motion_type == 0: count = 2 elif self.motion_type == 1: count = 16 if (self.facing != self.last_facing) or (self.motion_type != self.last_motion_type): frames.set(0) width = self.sprite_sheet.get_sprite_sheet_width(motion_type.get()) if frames.get() == width / count: frames.set(0) self.surface = self.sprite_sheet.get_surface( frames.get(), motion_type.get(), facing.get()) self.sprite_surface = sprite.surface h, w = self.sprite_sheet.get_sprite_size() rect = SDL_Rect(0, 0, w, h) SDL_FillRect(self.sprite_surface, None, 0x000000) SDL_BlitSurface(self.surface, None, self.sprite_surface, rect) self.last_facing = self.facing self.last_motion_type = self.motion_type if frames.get() > count: frames.set(0) else: frames.bump()
def __init__(self, x: int, y: int, w: int, h: int, color: SDL_Color): self._rect = SDL_Rect(x, y, w, h) self._color = color