def test_init_one_by_one(self):
f = Field(4, 4)
rect = Rectangle(f, f)
for c in rect.corners():
self.assertEqual(c.x, f.x)
self.assertEqual(c.y, f.y)
self.assertEqual(c.rectangle, rect)
def __init__(self, main, resolution=1, parent=None):
if isinstance(main, Rectangle):
if main.height() == main.width() and is_power2(main.height()):
self.main = main
self.parent = parent
self.resolution = resolution
# Subindexes
if resolution > 1:
self.top_left = Area(
Rectangle(self.main.top_left,
self.main.middle().top_left), resolution - 1,
self)
self.top_right = Area(
Rectangle(self.main.middle().top_right,
self.main.top_right), resolution - 1, self)
self.bottom_left = Area(
Rectangle(self.main.bottom_left,
self.main.middle().bottom_left),
resolution - 1, self)
self.bottom_right = Area(
Rectangle(self.main.bottom_right,
self.main.middle().bottom_right),
resolution - 1, self)
self.children = [
self.top_left, self.top_right, self.bottom_left,
self.bottom_right
]
self.rectangles = []
def test_dimensions(self):
first = Field(0, 0)
second = Field(9, 9)
rect = Rectangle(first, second)
self.assertEqual(rect.height(), 10)
self.assertEqual(rect.width(), 10)
def test_remove3(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 3)
r = Rectangle(Field(8, 10), Field(10, 11))
self.assertFalse(r in a.top_right.bottom_left.rectangles)
a += r
self.assertTrue(r in a.top_right.bottom_left.rectangles)
a -= r
self.assertFalse(r in a.top_right.bottom_left.rectangles)
def test_remove(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1)
r = Rectangle(Field(0, 0), Field(4, 4))
self.assertFalse(r in a.rectangles)
a += r
self.assertTrue(r in a.rectangles)
a -= r
self.assertFalse(r in a.rectangles)
def test_remove2(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
r = Rectangle(Field(0, 0), Field(6, 6))
self.assertFalse(r in a.bottom_left.rectangles)
a += r
self.assertTrue(r in a.bottom_left.rectangles)
a -= r
self.assertFalse(r in a.bottom_left.rectangles)
def test_init_subindexes(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 2)
self.assertTrue(
a.bottom_left.main == Rectangle(Field(0, 0), Field(3, 3)))
self.assertTrue(
a.bottom_right.main == Rectangle(Field(4, 0), Field(7, 3)))
self.assertTrue(a.top_left.main == Rectangle(Field(0, 4), Field(3, 7)))
self.assertTrue(
a.top_right.main == Rectangle(Field(4, 4), Field(7, 7)))
def test_init_area(self):
a = Area(Rectangle(Field(0, 0), Field(31, 31)), 2)
rect = Rectangle(Field(5, 5), Field(10, 10))
a += rect
for c in rect.corners():
self.assertEqual(c.rectangle.area, a)
def test_all_rectangles(self):
a = Area(Rectangle(Field(0, 0), Field(127, 127)), 4)
original = set()
for i in range(0, 100):
rect = Rectangle(Field(i, i), Field(i, i))
original.add(rect)
a += rect
result = a.all_rectangles()
self.assertEqual(original, result)
def test_and_none(self):
big1 = Field(5, 5)
big2 = Field(10, 10)
small1 = Field(1, 1)
small2 = Field(4, 4)
big = Rectangle(big1, big2)
small = Rectangle(small1, small2)
self.assertEqual(None, big & small)
def area():
a = Area.of_size(16)
rectangles = [
Rectangle(Field(3, 3), Field(12, 3), type=FieldType.inaccessible),
Rectangle(Field(3, 12), Field(12, 12), type=FieldType.inaccessible),
Rectangle(Field(7, 6), Field(8, 9), type=FieldType.inaccessible),
]
a += rectangles
return a
def test_init_subsubindexes(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 3)
self.assertTrue(a.bottom_left.bottom_left.main == Rectangle(
Field(0, 0), Field(1, 1)))
self.assertTrue(a.bottom_left.bottom_right.main == Rectangle(
Field(2, 0), Field(3, 1)))
self.assertTrue(
a.bottom_left.top_left.main == Rectangle(Field(0, 2), Field(1, 3)))
self.assertTrue(a.bottom_left.top_right.main == Rectangle(
Field(2, 2), Field(3, 3)))
def test_corner_shell(self):
test_cases = {
Rectangle(Field(0, 0), Field(5, 5)):
Rectangle(Point(-0.5, -0.5), Point(5.5, 5.5)),
Rectangle(Field(2, 2), Field(4, 4)):
Rectangle(Point(1.5, 1.5), Point(4.5, 4.5))
}
for case, expected in test_cases.items():
self.assertEqual(case.corner_shell(), expected)
def test_str(self):
first = Field(0, 0)
second = Field(17, 10)
expected = "(0,10) ... (17,10)\n" \
"... ... ...\n" \
"(0,0) ... (17,0)"
rect = Rectangle(first, second)
self.assertEqual(rect.__str__(), expected)
def area():
a = Area.of_size(8)
rectangles = [
Rectangle(Field(0, 0), Field(0, 5), type=FieldType.inaccessible),
Rectangle(Field(3, 0), Field(3, 5), type=FieldType.inaccessible),
Rectangle(Field(4, 5), Field(6, 5), type=FieldType.inaccessible),
Rectangle(Field(6, 3), Field(7, 3), type=FieldType.inaccessible)
]
a += rectangles
return a
def test_add_multiple_list(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3)),
Rectangle(Field(2, 5), Field(3, 5)),
Rectangle(Field(5, 2), Field(6, 3)),
Rectangle(Field(5, 5), Field(6, 6))
]
a += rectangles
# Check
self.assertEqual(set(rectangles), a.all_rectangles())
def test_and_contains(self):
big1 = Field(0, 0)
big2 = Field(10, 10)
small1 = Field(4, 4)
small2 = Field(8, 8)
big = Rectangle(big1, big2)
small = Rectangle(small1, small2)
self.assertEqual(small, big & small)
self.assertEqual(small & big, big & small)
def area():
a = Area.of_size(8)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(5, 5), Field(6, 6), type=FieldType.inaccessible)
]
a += rectangles
return a
def test_all_rectangles_complex(self):
a = Area(Rectangle(Field(0, 0), Field(511, 511)), 4)
original = set()
for i in range(1, 20):
for j in range(1, 20):
rect = (Rectangle(Field(i * 6, j * 6),
Field(i * 6 + 2, j * 6 + 2)))
original.add(rect)
a += rect
result = a.all_rectangles()
self.assertEqual(original, result)
def test_add_multiple(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
r = Rectangle(Field(6, 6), Field(10, 10))
self.assertFalse(r in a.bottom_left.rectangles)
self.assertFalse(r in a.bottom_right.rectangles)
self.assertFalse(r in a.top_left.rectangles)
self.assertFalse(r in a.top_right.rectangles)
a += r
self.assertTrue(r in a.bottom_left.rectangles)
self.assertTrue(r in a.bottom_right.rectangles)
self.assertTrue(r in a.top_left.rectangles)
self.assertTrue(r in a.top_right.rectangles)
def test_and_2to0_intersection_vertical_right(self):
first_s = Field(0, 10)
first_e = Field(10, 20)
second_s = Field(4, 5)
second_e = Field(8, 15)
result = Rectangle(Field(4, 10), Field(8, 15))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertTrue(result == first & second)
def test_and_1to1_intersection(self):
first_s = Field(0, 0)
first_e = Field(9, 11)
second_s = Field(4, 3)
second_e = Field(12, 12)
result = Rectangle(Field(4, 3), Field(9, 11))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertEqual(result, first & second)
def test_root(self):
a = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8)
other = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8)
for child in a.children:
while child.is_subindexed():
child = child.bottom_left
self.assertEquals(child.get_root(), a)
# Abusive
self.assertNotEqual(child.get_root(), child)
self.assertNotEqual(child.get_root(), child.parent)
self.assertNotEqual(child.get_root(), other)
def test_conversion2(self):
r = Rectangle(Field(1, 1), Field(5, 5))
results = {
"(1,1)": (0.5, 0.5),
"(1,5)": (0.5, 5.5),
"(5,1)": (5.5, 0.5),
"(5,5)": (5.5, 5.5)
}
for c in r.corners():
r = results[c.__str__()]
self.assertEqual(Point(r[0], r[1]), Point.corner_to_point(c))
def test_and_2to0_intersection_horizontal_right(self):
first_s = Field(10, 0)
first_e = Field(20, 10)
second_s = Field(8, 4)
second_e = Field(16, 9)
result = Rectangle(Field(10, 4), Field(16, 9))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertTrue(result == first & second)
def gen_area(self):
# DO NOT CHANGE!!!
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(6, 5), Field(6, 5), type=FieldType.inaccessible)
]
a += rectangles
return a
def test_add_coinciding(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
base = Rectangle(Field(6, 6), Field(10, 10))
r1 = Rectangle(Field(6, 6), Field(10, 10))
r2 = Rectangle(Field(4, 4), Field(8, 8))
r3 = Rectangle(Field(10, 10), Field(13, 13))
rs = [r1, r2, r3]
a += base
for r in rs:
with self.assertRaises(Exception):
a += r
def test_init_area_big(self):
a = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 5)
rect1 = Rectangle(Field(5, 5), Field(10, 10))
rect2 = Rectangle(Field(200, 500), Field(1001, 700))
rect3 = Rectangle(Field(201, 201), Field(201, 201))
rectangles = {rect1, rect2, rect3}
for r in rectangles:
a += r
for c in r.corners():
self.assertEqual(c.rectangle.area, a)
def gen_area(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(5, 5), Field(6, 6), type=FieldType.inaccessible)
]
a.main.size = MagicMock(return_value=64)
a.all_rectangles = MagicMock(return_value=set(rectangles))
a += rectangles # TODO: Mocking should work without this instruction
return a
def test_init(self):
f1 = Field(0, 0)
f2 = Field(10, 0)
f3 = Field(10, 10)
f4 = Field(0, 10)
rectangle = Rectangle(f1, f3)
real = [f1, f2, f3, f4]
testing = rectangle.corners()
for i in range(0, 4):
self.assertTrue(real[i] == testing[i])
def add_rectagle(x1, y1, x2, y2, label):
x1 = float(x1)
y1 = float(y1)
x2 = float(x2)
y2 = float(y2)
rect = Rectangle(
(x1, y1),
(x2, y2),
{label: 1}
)
if len(rectangles) > 0:
closest = min(rectangles, key=rect.distance)
dist = rect.distance(closest)
else:
dist = float('inf')
if dist > 0.0005: # TODO: tune this value
rectangles.append(rect)
else:
closest.labels[label] += 1
return jsonify()
def main():
global font
global message
pygame.init()
pygame.display.set_caption("Lunar Lander Re-Created By Matthew Jones And Philip Jones")
screen = pygame.display.set_mode((800,600))
font = pygame.font.SysFont('Calibri', 25, True, False)
lander = Lander()
lander_group = Group()
lander_group.add(lander)
burn = Burn(lander)
burn_group = Group()
burn_group.add(burn)
fuel_bar_front = Rectangle(blue)
fuel_bar_front_group = Group()
fuel_bar_front_group.add(fuel_bar_front)
fuel_bar_back = Rectangle(white)
fuel_bar_back_group = Group()
fuel_bar_back_group.add(fuel_bar_back)
planet = Planet()
planet_group = Group()
planet_group.add(planet)
done = False
pygame.display.update()
flicker = True
music = False
first_frame = True
landed_ok = None
while not done:
thrust = False
left = False
right = False
pygame.event.pump()
keys=pygame.key.get_pressed()
if keys[K_ESCAPE]:
done = True
if landed_ok is None:
if keys[K_SPACE] or keys[K_UP]:
thrust = True
if keys[K_LEFT]:
left = True
if keys[K_RIGHT]:
right = True
landed = False
if first_frame:
first_frame = False
else:
offset_x, offset_y = (planet.rect.left - lander.rect.left), (planet.rect.top - lander.rect.top)
landed = lander.mask.overlap(planet.mask, (offset_x, offset_y)) != None
status = lander.calculate_vertical_speed(thrust, landed)
if landed and landed_ok is None:
landed_ok = status
if landed_ok:
landed_message()
else:
crashed_message()
if not landed and lander.height < 200:
if lander.delta_vert < -2:
message = "Almost there! TOO FAST!"
else:
message = "Almost there! Slow down for a soft landing"
lander.calc_horizontal(left, right)
screen.fill(background_colour)
lander.render()
lander_group.draw(screen)
if not landed and thrust and lander.is_fuel_remaining():
flicker = not flicker
image_number = 1 if flicker else 0
burn.render(image_number)
burn_group.draw(screen)
if not music:
play_sound('../sounds/rocket_sound.mp3', True)
music = True
elif music and not landed:
music = False
pygame.mixer.music.stop()
#draw fuel bar :)
percent_fuel = float(lander.fuel) / float(Lander.max_fuel) * 100.0
fuel_bar_back.render(10, 10, 104, 12)
fuel_bar_back_group.draw(screen)
fuel_bar_front.render(12, 12, percent_fuel, 8)
fuel_bar_front_group.draw(screen)
planet.render()
planet_group.draw(screen)
display_message(screen)
pygame.display.update()
time.sleep(0.015)
