def test_at_least_radius_of_biggest_particle(self):
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
new_particle = CDUtilities.add_ball(self.manager.space, 11, 11)
entity.parts.append(new_particle)
output = entity.get_inclusion_radius()
self.assertEqual(output, 40)
def main():
#pylint: disable=no-member
pygame.init()
screen = pygame.display.set_mode((600, 600))
pygame.display.set_caption("Fall")
clock = pygame.time.Clock()
space = pymunk.Space()
space.gravity = (0.0, 0.0)
draw_options = pymunk.pygame_util.DrawOptions(screen)
manager = condep.CDManager.CDManager(screen, space)
star = CDUtilities.create_star(manager, 100, 100)
particle = CDUtilities.create_particle(manager, 600, 600)
balls = star.parts
balls.append(particle.parts[0])
while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit(0)
elif event.type == KEYDOWN and event.key == K_ESCAPE:
sys.exit(0)
balls_to_remove = []
for ball in balls:
grav_force = pymunk.Vec2d()
for other_ball in balls:
grav_force = grav_force + utilities.calc_gravitational_force(
other_ball.body, ball.body)
ball.body.apply_force_at_local_point(grav_force, (0, 0))
for ball in balls_to_remove:
space.remove(ball, ball.body) # 3
balls.remove(ball) # 4
steps_per_frame = 50 #larger value increases accuracy of simulation, but decreases speed
frames_per_tick = 1
for x in range(steps_per_frame):
space.step(1 / (frames_per_tick * steps_per_frame))
screen.fill((255, 255, 255))
space.debug_draw(draw_options)
manager.tick() #processes changes in CDobjects
pygame.display.flip()
clock.tick(
50) # argument is max framerate, which we'll probably never reach!
def test_recognises_absorb_for_simple_entity(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 0, 0)
particle = CDUtilities.create_particle(self.manager, 1, 1)
self.manager.distance_matrices = [[[None, 20], [20, None]]]
# act
events = entity._check_for_injest_or_emit(self.manager, Vec2d(0, 0))
# assert
self.assertEqual(len(events), 1, 'Should return a single event')
event = events[0]
self.assertEqual(event.affected_attribute,
EntityAttributes.inside_subject)
self.assertEqual(event.attribute_outcome,
EntityAttributeOutcomes.inside)
def test_handles_empty_list_without_freaking_out(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
entity.attribute_changes = []
# act
entity._update_changing_attributes()
def test_handles_compound_entities(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
new_particle = CDUtilities.add_ball(self.manager.space, 11, 11)
entity.parts.append(new_particle)
target_event = ActionEvent()
actual_event = ActionEvent()
entity.event_history.append([actual_event])
entity.attribute_changes = [[('event', target_event)]]
# act
entity._update_changing_attributes()
# assert
self.assertEqual(len(entity.attribute_changes), 0)
def _spawn_entity(manager: CDManager, kind: str, offset: int=0, collision: CollisionTypes=None):
'''Adds an entity of the specified kind to the space, with the optional
ability to set position and collision type'''
x = 200 + offset
y = 200 + offset
kind = kind.lower()
factory_dict = {
'star': lambda manager: CDUtilities.create_big_particle(manager, x, y),
'particle': lambda manager: CDUtilities.create_particle(manager, x, y, collision_type=collision),
'radiation': lambda manager: CDUtilities.create_particle(manager, x, y, collision_type=collision),
}
try:
return factory_dict[kind](manager)
except KeyError:
print(f'No definition for {kind}, using generic object for simulation')
return CDUtilities.create_particle(manager, x, y, collision_type=collision)
def test_handles_queued_radius_increase(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
original_radius = entity.parts[0].radius
entity.attribute_changes = [[('radius', original_radius * 2)]]
# act
entity._update_changing_attributes()
# assert
self.assertGreater(entity.parts[0].radius, original_radius,
'Should increase the radius')
def test_recognises_expell_for_compound_entity(self):
entity = CDUtilities.create_star(self.manager, 0, 0)
entity.parts[0].body.position = Vec2d(200, 200)
entity.parts[0].mark = 'Outlier'
self.manager.distance_matrices = [[[None]]]
events = entity._check_for_injest_or_emit(self.manager, Vec2d(0, 0))
self.assertGreater(len(events), 0, 'Should return an event')
event = events[0]
self.assertEqual(event.affected_attribute,
EntityAttributes.inside_subject)
self.assertEqual(event.attribute_outcome,
EntityAttributeOutcomes.outside)
self.assertEqual(event.event_object.mark, 'Outlier')
def test_handles_queued_event_target(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
target_event = ActionEvent()
actual_event = ActionEvent()
entity.event_history.append([actual_event])
entity.attribute_changes = [[('event', target_event)]]
# act
entity._update_changing_attributes()
# assert
self.assertEqual(len(entity.attribute_changes), 0,
'Should have no more queued changes')
def test_removes_fulfilled_group_of_targets(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
original_radius = entity.parts[0].radius
entity.attribute_changes = [[('radius', original_radius)],
[('future_target', 42)]]
# act
entity._update_changing_attributes()
# assert
self.assertEqual(len(entity.attribute_changes), 1,
'Should remove empty group of targets')
self.assertTupleEqual(
entity.attribute_changes[0][0], ('future_target', 42),
'Should future target should have moved into first position')
def test_removes_fulfilled_targets(self):
# arrange
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
original_radius = entity.parts[0].radius
entity.attribute_changes = [[('radius', original_radius),
('position', 999)]]
self.assertEqual(len(entity.attribute_changes[0]), 2,
'Checking arrangement!')
# act
entity._update_changing_attributes()
# assert
self.assertEqual(len(entity.attribute_changes[0]), 1,
'Should be only have one left')
self.assertTupleEqual(entity.attribute_changes[0][0],
('position', 999),
'Should have left unfulfilled target')
def test_correct_for_large_particles(self):
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
body = entity.parts[0].body
self.assertEqual(entity.get_centre_of_gravity(), body.position)
def test_handles_multiple_particles(self):
entity = CDUtilities.create_star(self.manager, 10, 10)
entity.get_inclusion_radius()
def test_handles_single_particle(self):
entity = CDUtilities.create_big_particle(self.manager, 10, 10)
output = entity.get_inclusion_radius()
self.assertEqual(output, 40)