def reflect_from_game_objects(
ball: Ball, game_objects: List[GameObject]) -> List[GameObject]:
"""
Reflect from game objects if ball has hit them.
Get intersections with game objects.
Reflect from one or several game objects.
Return game objects which were hit.
If brick was hit decrease hitpoints.
"""
object_intersection_pairs = _get_object_intersection_pairs(
ball, game_objects)
if len(object_intersection_pairs) == 1:
_reflect_from_single_object(
ball=ball,
game_object=object_intersection_pairs[0][0],
intersection=object_intersection_pairs[0][1],
)
ball.angle = _clamp_angle(ball.angle)
return [object_intersection_pairs[0][0]]
if len(object_intersection_pairs) > 1:
_reflect_from_multiple_objects(
ball=ball, object_intersection_pairs=object_intersection_pairs)
ball.angle = _clamp_angle(ball.angle)
hit_objects: List[GameObject] = []
for object_intersection_pair in object_intersection_pairs:
hit_objects.append(object_intersection_pair[0])
return hit_objects
return []
def test_gravity(self):
obj = Ball(
top_left=Point(8.2, 1.3),
width=3.1,
height=4.2,
velocity=2.4,
angle=Angle(deg2rad(30.0)),
gravity=9.8,
)
assert obj.gravity == 9.8
obj.gravity = 4.5
assert obj.gravity == 4.5
def test_angle(self):
obj = Ball(
top_left=Point(8.2, 1.3),
width=3.1,
height=4.2,
velocity=2.4,
angle=Angle(deg2rad(30.0)),
gravity=9.8,
)
assert obj.angle.value == approx(deg2rad(30.0))
obj.angle = Angle(deg2rad(65))
assert obj.angle.value == approx(deg2rad(65.0))
def test_move(self, active, velocity, degree, gravity, end_point):
obj = Ball(
top_left=Point(0.0, 0.0),
width=3.1,
height=4.2,
velocity=velocity,
angle=Angle(deg2rad(degree)),
gravity=gravity,
)
obj.is_active = active
time_in_ms = 1000
obj.move(time_in_ms)
assert obj.top_left.x == approx(end_point.x)
assert obj.top_left.y == approx(end_point.y)
def test_reflect_vertical(
self,
ball_top_left: Point,
ball_angle: float,
ball_result_top_left: Point,
ball_result_angle: float,
hit_objects_count: int,
):
ball = Ball(
top_left=ball_top_left,
width=2.5,
height=3.0,
velocity=1.0,
angle=Angle(deg2rad(ball_angle)),
)
bricks = [
Brick(top_left=Point(1.0, 3.0), width=4.0, height=4.0),
Brick(top_left=Point(5.0, 3.0), width=4.0, height=4.0),
Brick(top_left=Point(9.0, 3.0), width=4.0, height=4.0),
]
hit_objects = reflect_from_game_objects(ball, bricks)
assert len(hit_objects) == hit_objects_count
assert ball.top_left.x == ball_result_top_left.x
assert ball.top_left.y == ball_result_top_left.y
assert ball.angle.value == approx(deg2rad(ball_result_angle))
def test_reflect_from_three_objects_in_corner(
self,
brick1_top_left: Point,
brick2_top_left: Point,
brick3_top_left: Point,
ball_top_left: Point,
ball_angle: float,
ball_result_top_left: Point,
ball_result_angle: float,
):
ball = Ball(
top_left=ball_top_left,
width=2.0,
height=2.0,
velocity=1.0,
angle=Angle(deg2rad(ball_angle)),
)
bricks = [
Brick(top_left=brick1_top_left, width=3.0, height=3.0),
Brick(top_left=brick2_top_left, width=3.0, height=3.0),
Brick(top_left=brick3_top_left, width=3.0, height=3.0),
]
hit_objects = reflect_from_game_objects(ball, bricks)
assert len(hit_objects) == 3
assert ball.top_left.x == ball_result_top_left.x
assert ball.top_left.y == ball_result_top_left.y
assert ball.angle.value == approx(deg2rad(ball_result_angle))
def test_init_default(self):
obj = Ball()
assert obj.top_left.x == 0.0
assert obj.top_left.y == 0.0
assert obj.width == 0.0
assert obj.height == 0.0
assert obj.velocity == 0.0
assert obj.angle.value == 0.0
assert obj.gravity == 0.0
assert obj.is_active == False
def _make_ball(velocity: float, gravity: float, grid_width: int,
grid_height: int) -> Ball:
point = _ball_init_position(grid_width=grid_width, grid_height=grid_height)
return Ball(
top_left=point,
width=BALL_WIDTH,
height=BALL_HEIGHT,
velocity=velocity,
angle=Angle(BALL_ANGLE),
gravity=gravity,
)
def reflect_from_platform(ball: Ball, platform: Platform) -> bool:
"""
Reflect from platform if ball has hit it.
Get intersections with platform.
If intersections exists reflect from the platform.
Return True to indicate reflection.
"""
intersection = _get_intersection(ball, platform)
if intersection == _Intersection.NONE:
return False
_reflect_from_single_object(ball, platform, intersection)
ball.angle = _clamp_angle(ball.angle)
return True
def test_init(self):
obj = Ball(
top_left=Point(8.2, 1.3),
width=3.1,
height=4.2,
velocity=2.4,
angle=Angle(deg2rad(90.0)),
gravity=9.8,
)
assert obj.top_left.x == 8.2
assert obj.top_left.y == 1.3
assert obj.width == 3.1
assert obj.height == 4.2
assert obj.velocity == 2.4
assert obj.angle.value == approx(deg2rad(90.0))
assert obj.gravity == 9.8
assert obj.is_active == False
def _handle_event_from_level_objects(
self,
event: _Event,
elapsed_time_in_ms: float,
left_wall: Wall,
right_wall: Wall,
ball: Ball,
platform: Platform,
):
if event == self._Event.p:
self._is_paused = not self._is_paused
self._changed_pause_state = True
return
self._changed_pause_state = False
if event == self._Event.quit or event == self._Event.escape:
self._is_quit = True
return
if event == self._Event.p:
self._is_paused = not self._is_paused
return
if self._is_paused:
return
if event == self._Event.space:
if not ball.is_active:
ball.is_active = True
elif event == self._Event.left:
if _intersects_with_left_x(platform, left_wall):
_put_before_intersects_with_left_x(platform, left_wall)
else:
_move_left(platform, elapsed_time_in_ms)
elif event == self._Event.right:
if _intersects_with_right_x(platform, right_wall):
_put_before_intersects_with_right_x(platform, right_wall)
else:
_move_right(platform, elapsed_time_in_ms)
def test_is_active(self):
obj = Ball()
assert obj.is_active == False
obj.is_active = True
assert obj.is_active == True