def get_tile_images_by_rect(self, rect):
""" Speed up data access
More efficient because data is accessed and cached locally
"""
def rev(seq, start, stop):
if start < 0:
start = 0
return enumerate(seq[start:stop + 1], start)
x1, y1, x2, y2 = rect_to_bb(rect)
images = self.tmx.images
layers = self.tmx.layers
at = self._animated_tile
tracked_gids = self._tracked_gids
anim_map = self._animation_map
track = bool(self._animation_queue)
for l in self.tmx.visible_tile_layers:
for y, row in rev(layers[l].data, y1, y2):
for x, gid in [i for i in rev(row, x1, x2) if i[1]]:
# since the tile has been queried, assume it wants to be checked
# for animations sometime in the future
if track and gid in tracked_gids:
anim_map[gid].positions.add((x, y, l))
try:
# animated, so return the correct frame
yield x, y, l, at[(x, y, l)]
except KeyError:
# not animated, so return surface from data, if any
yield x, y, l, images[gid]
def get_tile_images_by_rect(self, rect):
""" Given a 2d area, return generator of tile images inside
Given the coordinates, yield the following tuple for each tile:
X, Y, Layer Number, pygame Surface
This method also defines render order by re arranging the
positions of each tile as it is yielded to the renderer.
There is an optimization that you can make for your data:
If you can provide access to tile information in a batch,
then pyscroll can access data faster and render quicker.
To implement this optimization, override this method.
Not like python 'Range': should include the end index!
:param rect: a rect-like object that defines tiles to draw
:return: generator
"""
x1, y1, x2, y2 = rect_to_bb(rect)
for layer in self.visible_tile_layers:
for y, x in product(range(y1, y2 + 1),
range(x1, x2 + 1)):
tile = self.get_tile_image(x, y, layer)
if tile:
yield x, y, layer, tile
def get_tile_images_by_rect(self, rect):
""" Given a 2d area, return generator of tile images inside
Given the coordinates, yield the following tuple for each tile:
X, Y, Layer Number, pygame Surface, GID
This method also defines render order by re arranging the
positions of each tile as it is yielded to the renderer.
This is an optimization that you can make for your data.
If you can provide access to tile information in a batch,
then pyscroll can access data faster and render quicker.
To implement an optimization, override this method.
Not like python 'Range': should include the end index!
GID's are required for animated tiles only. This value, if not
used by your game engine, can be 0 or None.
< The GID requirement will change in the future >
:param rect: a rect-like object that defines tiles to draw
:return:
"""
x1, y1, x2, y2 = rect_to_bb(rect)
for layer in self.visible_tile_layers:
for y, x in product(range(y1, y2 + 1), range(x1, x2 + 1)):
tile = self.get_tile_image((x, y, layer))
if tile:
yield x, y, layer, tile, 0
def get_tile_images_by_rect(self, rect):
""" Speed up data access
More efficient because data is accessed and cached locally
"""
def rev(seq, start, stop):
return enumerate(seq[start:stop + 1], start)
x1, y1, x2, y2 = rect_to_bb(rect)
images = self.tmx.images
for layer in self.visible_tile_layers:
data = self.tmx.layers[layer].data
for y, row in rev(data, y1, y2):
for x, gid in rev(row, x1, x2):
if gid:
yield x, y, layer, images[gid], gid
def get_tile_images_by_rect(self, rect):
""" Speed up data access
More efficient because data is accessed and cached locally
"""
def rev(seq, start, stop):
if start < 0:
start = 0
return enumerate(seq[start:stop + 1], start)
x1, y1, x2, y2 = rect_to_bb(rect)
images = self.tmx.images
layers = self.tmx.layers
for layer in self.visible_tile_layers:
for y, row in rev(layers[layer].data, y1, y2):
for x, gid in [i for i in rev(row, x1, x2) if i[1]]:
yield x, y, layer, images[gid], gid
