def test_Applicator_process(self):
world = World()
class ErrornousApplicator(Applicator):
def __init__(self):
super(ErrornousApplicator, self).__init__()
self.componenttypes = (Position, Movement)
eapplicator = ErrornousApplicator()
world.add_system(eapplicator)
for x in range(10):
MovingEntity(world)
self.assertTrue(eapplicator in world.systems)
self.assertRaises(NotImplementedError, world.process)
world2 = World()
mapplicator = MovementApplicator()
world2.add_system(mapplicator)
for x in range(10):
MovingEntity(world2, vx=1, vy=1)
self.assertTrue(mapplicator in world2.systems)
world2.process()
for c in world2.components[Position].values():
self.assertEqual(c.x, 1)
self.assertEqual(c.y, 1)
world2.process()
for c in world2.components[Position].values():
self.assertEqual(c.x, 2)
self.assertEqual(c.y, 2)
def test_Applicator_process(self):
world = World()
class ErrornousApplicator(Applicator):
def __init__(self):
super(ErrornousApplicator, self).__init__()
self.componenttypes = (Position, Movement)
eapplicator = ErrornousApplicator()
world.add_system(eapplicator)
for x in range(10):
MovingEntity(world)
assert eapplicator in world.systems
with pytest.raises(NotImplementedError):
world.process()
world2 = World()
mapplicator = MovementApplicator()
world2.add_system(mapplicator)
for x in range(10):
MovingEntity(world2, vx=1, vy=1)
assert mapplicator in world2.systems
world2.process()
for c in world2.components[Position].values():
assert c.x == 1
assert c.y == 1
world2.process()
for c in world2.components[Position].values():
assert c.x == 2
assert c.y == 2
def test_System_process(self):
world = World()
class ErrornousSystem(System):
def __init__(self):
super(ErrornousSystem, self).__init__()
self.componenttypes = (Position, )
esystem = ErrornousSystem()
world.add_system(esystem)
for x in range(10):
PositionEntity(world)
assert esystem in world.systems
with pytest.raises(NotImplementedError):
world.process()
world2 = World()
psystem = PositionSystem()
world2.add_system(psystem)
for x in range(10):
PositionEntity(world2)
assert psystem in world2.systems
world2.process()
for c in world2.components[Position].values():
assert c.x == 1
assert c.y == 1
world2.process()
for c in world2.components[Position].values():
assert c.x == 2
assert c.y == 2
def test_System_process(self):
world = World()
class ErrornousSystem(System):
def __init__(self):
super(ErrornousSystem, self).__init__()
self.componenttypes = (Position,)
esystem = ErrornousSystem()
world.add_system(esystem)
for x in range(10):
PositionEntity(world)
self.assertTrue(esystem in world.systems)
self.assertRaises(NotImplementedError, world.process)
world2 = World()
psystem = PositionSystem()
world2.add_system(psystem)
for x in range(10):
PositionEntity(world2)
self.assertTrue(psystem in world2.systems)
world2.process()
for c in world2.components[Position].values():
self.assertEqual(c.x, 1)
self.assertEqual(c.y, 1)
world2.process()
for c in world2.components[Position].values():
self.assertEqual(c.x, 2)
self.assertEqual(c.y, 2)
def test_Entity(self):
world = World()
world.add_system(PositionSystem())
e = Entity(world)
e2 = Entity(world)
assert isinstance(e, Entity)
assert isinstance(e2, Entity)
assert e != e2
p = PositionEntity(world)
assert isinstance(p, PositionEntity)
assert isinstance(p, Entity)
def test_Entity(self):
world = World()
world.add_system(PositionSystem())
e = Entity(world)
e2 = Entity(world)
self.assertIsInstance(e, Entity)
self.assertIsInstance(e2, Entity)
self.assertNotEqual(e, e2)
p = PositionEntity(world)
self.assertIsInstance(p, PositionEntity)
self.assertIsInstance(p, Entity)
def test_Applicator(self):
world = World()
class ErrornousApplicator(Applicator):
def __init__(self):
super(ErrornousApplicator, self).__init__()
eapplicator = ErrornousApplicator()
# No component types defined.
self.assertRaises(ValueError, world.add_system, eapplicator)
self.assertEqual(len(world.systems), 0)
mapplicator = MovementApplicator()
world.add_system(mapplicator)
self.assertTrue(mapplicator in world.systems)
def run():
sdl2ext.init()
window = sdl2ext.Window("The Pong Game", size=(800, 600))
window.show()
if "-hardware" in sys.argv:
print("Using hardware acceleration")
renderer = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
else:
print("Using software rendering")
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
# Create the paddles - we want white ones. To keep it easy enough for us,
# we create a set of surfaces that can be used for Texture- and
# Software-based sprites.
sp_paddle1 = factory.from_color(WHITE, size=(20, 100))
sp_paddle2 = factory.from_color(WHITE, size=(20, 100))
sp_ball = factory.from_color(WHITE, size=(20, 20))
world = World()
movement = MovementSystem(0, 0, 800, 600)
collision = CollisionSystem(0, 0, 800, 600)
aicontroller = TrackingAIController(0, 600)
if factory.sprite_type == sdl2ext.SOFTWARE:
spriterenderer = SoftwareRenderer(window)
else:
spriterenderer = TextureRenderer(renderer)
world.add_system(aicontroller)
world.add_system(movement)
world.add_system(collision)
world.add_system(spriterenderer)
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250, True)
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
collision.ball = ball
aicontroller.ball = ball
running = True
while running:
for event in sdl2ext.get_events():
if event.type == sdlevents.SDL_QUIT:
running = False
break
if event.type == sdlevents.SDL_KEYDOWN:
if event.key.keysym.sym == sdlkc.SDLK_UP:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdlkc.SDLK_DOWN:
player1.velocity.vy = PADDLE_SPEED
elif event.type == sdlevents.SDL_KEYUP:
if event.key.keysym.sym in (sdlkc.SDLK_UP, sdlkc.SDLK_DOWN):
player1.velocity.vy = 0
sdltimer.SDL_Delay(10)
world.process()
def test_Applicator(self):
world = World()
class ErrornousApplicator(Applicator):
def __init__(self):
super(ErrornousApplicator, self).__init__()
eapplicator = ErrornousApplicator()
# No component types defined.
with pytest.raises(ValueError):
world.add_system(eapplicator)
assert len(world.systems) == 0
mapplicator = MovementApplicator()
world.add_system(mapplicator)
assert mapplicator in world.systems
def test_System(self):
world = World()
self.assertRaises(ValueError, world.add_system, None)
self.assertRaises(ValueError, world.add_system, 1234)
self.assertRaises(ValueError, world.add_system, "Test")
class ErrornousSystem(System):
def __init__(self):
super(ErrornousSystem, self).__init__()
esystem = ErrornousSystem()
# No component types defined.
self.assertRaises(ValueError, world.add_system, esystem)
self.assertEqual(len(world.systems), 0)
psystem = PositionSystem()
world.add_system(psystem)
self.assertTrue(psystem in world.systems)
def test_System(self):
world = World()
with pytest.raises(ValueError):
world.add_system(None)
with pytest.raises(ValueError):
world.add_system(1234)
with pytest.raises(ValueError):
world.add_system("Test")
class ErrornousSystem(System):
def __init__(self):
super(ErrornousSystem, self).__init__()
esystem = ErrornousSystem()
# No component types defined.
with pytest.raises(ValueError):
world.add_system(esystem)
assert len(world.systems) == 0
psystem = PositionSystem()
world.add_system(psystem)
assert psystem in world.systems
def test_World_add_remove_system(self):
world = World()
assert isinstance(world, World)
class SimpleSystem(object):
def __init__(self):
self.componenttypes = (Position, )
def process(self, world, components):
pass
for method in (world.add_system, world.remove_system):
for val in (None, "Test", Position, Entity(world)):
with pytest.raises(ValueError):
method(val)
psystem = SimpleSystem()
world.add_system(psystem)
assert len(world.systems) != 0
assert psystem in world.systems
world.remove_system(psystem)
assert len(world.systems) == 0
assert psystem not in world.systems
psystem = PositionSystem()
world.add_system(psystem)
assert len(world.systems) != 0
assert psystem in world.systems
entity = PositionEntity(world)
assert isinstance(entity.position, Position)
world.remove_system(psystem)
assert len(world.systems) == 0
assert psystem not in world.systems
# The data must stay intact in the world, even if the processing
# system has been removed.
assert isinstance(entity.position, Position)