def test_sparse_array_clear_range():
# Not using parametrize because there are too many values for that.
for mask in range(0x7f):
for begin in range(8):
for size in range(8):
b = core.BitArray(mask)
s = core.SparseArray(b)
s.clear_range(begin, size)
b.clear_range(begin, size)
assert core.BitArray(s) == b
assert s == core.SparseArray(b)
def test_sparse_array_bits_in_common():
"""Tests SparseArray behavior for has_bits_in_common()."""
s = core.SparseArray()
t = core.SparseArray()
s.set_range(2, 4)
t.set_range(5, 4)
assert s.has_bits_in_common(t)
s = core.SparseArray()
t = core.SparseArray()
s.set_range(2, 4)
t.set_range(6, 4)
assert not s.has_bits_in_common(t)
def test_sparse_array_augm_assignment():
"""Tests SparseArray behavior for augmented assignments."""
# test in-place bitshift to left
s = t = core.SparseArray()
t <<= 2
assert s is t
# test in-place bitshift to right
s = t = core.SparseArray()
t >>= 2
assert s is t
# test in-place bitwise AND
s = t = core.SparseArray()
u = core.SparseArray()
t &= u
assert s is t
# test in-place bitwise OR
s = t = core.SparseArray()
u = core.SparseArray()
t |= u
assert s is t
# test in-place bitwise XOR
s = t = core.SparseArray()
u = core.SparseArray()
t ^= u
assert s is t
def test_sparse_array_operations():
"""Tests SparseArray behavior for various operations."""
# test bitshift to left
s = core.SparseArray()
s.set_bit(2)
t = s << 2
assert t.get_bit(4)
assert not t.get_bit(2)
# test bitshift to right
s = core.SparseArray()
s.set_bit(4)
t = s >> 2
assert t.get_bit(2)
assert not t.get_bit(4)
# test bitwise AND
s = core.SparseArray()
t = core.SparseArray()
s.set_bit(2)
s.set_bit(3)
t.set_bit(1)
t.set_bit(3)
u = s & t
assert not u.get_bit(0)
assert not u.get_bit(1)
assert not u.get_bit(2)
assert u.get_bit(3)
# test bitwise OR
s = core.SparseArray()
t = core.SparseArray()
s.set_bit(2)
s.set_bit(3)
t.set_bit(1)
t.set_bit(3)
u = s | t
assert not u.get_bit(0)
assert u.get_bit(1)
assert u.get_bit(2)
assert u.get_bit(3)
# test bitwise XOR
s = core.SparseArray()
t = core.SparseArray()
s.set_bit(2)
s.set_bit(3)
t.set_bit(1)
t.set_bit(3)
u = s ^ t
assert not u.get_bit(0)
assert u.get_bit(1)
assert u.get_bit(2)
assert not u.get_bit(3)
def test_sparse_array_set_bit_to():
"""Tests SparseArray behavior for set_bit_to()."""
s = core.SparseArray()
s.set_bit_to(5, True)
assert s.get_bit(5)
s = core.SparseArray.all_on()
s.set_bit_to(5, False)
assert not s.get_bit(5)
def test_sparse_array_nonzero():
sa = core.SparseArray()
assert not sa
sa.set_bit(0)
assert sa
sa = core.SparseArray.all_on()
assert sa
sa.clear_range(0, 100)
assert sa
def test_sparse_array_set_clear_ranges():
"""Tests SparseArray behavior for setting and clearing ranges."""
# test clear_range with single overlapping on-range
# (clear_range extends beyond highest on-bit)
s = core.SparseArray()
s.set_range(2, 3)
s.clear_range(3, 3)
assert s.get_bit(2)
assert not s.get_bit(3)
# same as above, using set_range_to
s = core.SparseArray()
s.set_range_to(True, 2, 3)
s.set_range_to(False, 3, 3)
assert s.get_bit(2)
assert not s.get_bit(3)
# test clear_range using off-range which overlaps two on-ranges
# (lowest off-bit in lowest on-range, highest off-bit in highest on-range)
s = core.SparseArray()
s.set_range(2, 3)
s.set_range(7, 3)
s.clear_range(3, 6)
assert s.get_bit(2)
assert not s.get_bit(3)
assert not s.get_bit(8)
assert s.get_bit(9)
# same as above, using set_range_to
s = core.SparseArray()
s.set_range_to(True, 2, 3)
s.set_range_to(True, 7, 3)
s.set_range_to(False, 3, 6)
assert s.get_bit(2)
assert not s.get_bit(3)
assert not s.get_bit(8)
assert s.get_bit(9)
def test_sparse_array_pickle():
sa = core.SparseArray()
assert sa == pickle.loads(pickle.dumps(sa, -1))
sa = core.SparseArray()
sa.invert_in_place()
assert sa == pickle.loads(pickle.dumps(sa, -1))
sa = core.SparseArray()
sa.set_range(0, 2)
sa.set_range(4, 4)
assert sa == pickle.loads(pickle.dumps(sa, -1))
sa = core.SparseArray()
sa.invert_in_place()
sa.clear_range(2, 4)
assert sa == pickle.loads(pickle.dumps(sa, -1))
sa = core.SparseArray()
sa.invert_in_place()
sa.clear_range(0, 2)
sa.clear_range(4, 4)
assert sa == pickle.loads(pickle.dumps(sa, -1))
def test_sparse_array_getstate():
sa = core.SparseArray()
assert sa.__getstate__() == ()
sa = core.SparseArray()
sa.invert_in_place()
assert sa.__getstate__() == (0, )
sa = core.SparseArray()
sa.set_range(0, 2)
sa.set_range(4, 4)
assert sa.__getstate__() == (0, 2, 4, 8)
sa = core.SparseArray()
sa.invert_in_place()
sa.clear_range(2, 4)
assert sa.__getstate__() == (0, 2, 6)
sa = core.SparseArray()
sa.invert_in_place()
sa.clear_range(0, 2)
sa.clear_range(4, 4)
assert sa.__getstate__() == (2, 4, 8)
def __init__(self,
render=None,
sprite_map='',
sprite_layout=(8, 8),
loop=True,
pool_size=1024,
check_bounds=False,
scale=0.02):
self.render = render or base.render
self.check_bounds = check_bounds
self.scale = scale
tex = base.loader.load_texture(sprite_map)
tex.set_minfilter(core.SamplerState.FT_nearest)
tex.set_magfilter(core.SamplerState.FT_nearest)
tex.set_wrap_u(core.SamplerState.WM_repeat if loop else core.
SamplerState.WM_clamp)
tex.set_wrap_v(core.SamplerState.WM_repeat)
self.geom_node = core.GeomNode('fireworks')
path = self.render.attach_new_node(self.geom_node)
path.set_render_mode_thickness(32)
path.set_texture(tex)
path.set_tex_gen(core.TextureStage.get_default(),
core.TexGenAttrib.M_point_sprite)
path.set_antialias(core.AntialiasAttrib.M_point)
path.set_depth_test(True)
path.set_depth_write(True)
path.set_z(1.0)
path.set_transparency(core.TransparencyAttrib.M_binary)
path.set_shader(
core.Shader.load(core.Shader.SL_GLSL, 'assets/shaders/bullet.vert',
'assets/shaders/bullet.frag'))
path.set_shader_input('sprite_layout', sprite_layout)
self.sprite_layout = sprite_layout
self.root = path
self._generate_pool(pool_size)
self.patterns = []
self.pool_usage = core.SparseArray()
self.clock = 0
self.colliders = []
self.accept('window-event', self._update_size)
self._update_size(base.win)
def test_sparse_array_clear():
"""Tests SparseArray behavior for clear()."""
s = core.SparseArray.all_on()
s.clear()
assert s.is_zero()
assert not s.is_inverse()
assert s.get_num_subranges() == 0
assert s.get_num_on_bits() == 0
assert s.get_num_bits() == 0
s = core.SparseArray()
s.set_range(5, 10)
s.clear()
assert s.is_zero()
assert not s.is_inverse()
assert s.get_num_subranges() == 0
assert s.get_num_on_bits() == 0
assert s.get_num_bits() == 0
def update(self, dt):
if dt == 0:
return
geom = self.geom_node.modify_geom(0)
vdata = geom.modify_vertex_data()
rewriter = core.GeomVertexRewriter(vdata, 'vertex')
for pattern in self.patterns[:]:
point_range = pattern.range
if self.clock >= pattern.life_expectancy:
#TODO: delete bullets
vdata.transform_vertices(
core.Mat4.translate_mat((0, 0, -10000)), point_range)
self.patterns.remove(pattern)
self.pool_usage &= ~point_range
#print("Freeing", point_range)
continue
vdata.transform_vertices(pattern.update_transform(dt), point_range)
# Delete vertices out of bounds.
delete_points = core.SparseArray()
if self.colliders or self.check_bounds:
for sri in range(point_range.get_num_subranges()):
begin = point_range.get_subrange_begin(sri)
end = point_range.get_subrange_end(sri)
for i in range(begin, end):
rewriter.set_row(i)
pos = rewriter.get_data2()
if self.check_bounds:
if pos.y > base.cam.get_y(
) + 150 + base.player.cam_tilt * 32:
delete_points.set_bit(i)
continue
left, right = base.trackgen.query(pos.y)
if pos.x < left or pos.x > right:
delete_points.set_bit(i)
continue
for node, radius_sq, callback in self.colliders:
collider_pos = node.get_pos()
if (collider_pos.xy -
pos).length_squared() < radius_sq:
# Read out sprite type to pass to collide callback, then call it
reader = core.GeomVertexReader(vdata, 'offset')
reader.set_row(i)
type = int(reader.get_data2()[1])
taskMgr.add(callback(type))
delete_points.set_bit(i)
if not delete_points.is_zero():
vdata.transform_vertices(
core.Mat4.translate_mat((0, 0, -10000)), delete_points)
inv_delete_points = ~delete_points
point_range &= inv_delete_points
self.pool_usage &= inv_delete_points
#print("Freeing", delete_points)
if point_range.is_zero():
self.patterns.remove(pattern)
self.clock += dt
