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
