class GeometricShape:
def __init__(self, *sides):
self.sides = sides
self.shape = None
self._init()
def _init(self):
self.n = len(self.sides)
assert (self.n < 4), 'No support for sides > 3'
if self.n == 3:
self.shape = Triangle(*self.sides)
elif self.n == 2:
self.shape = Rectangle(*self.sides)
def name(self):
self._assert_shape()
return self.shape.name()
def perimeter(self):
self._assert_shape()
return self.shape.perimeter()
def area(self):
self._assert_shape()
return self.shape.area()
def _assert_shape(self):
assert (self.shape is not None), 'Not a valid geometric shape'
def testValidConstruction(self):
p1 = Point(1, 3)
p2 = Point(5, 3)
p3 = Point(5, 1)
p4 = Point(1, 1)
r1 = Rectangle(p1, p2, p3, p4)
self.assertEqual(p1, r1.point1)
self.assertEqual(p2, r1.point2)
self.assertEqual(p3, r1.point3)
self.assertEqual(p4, r1.point4)
l1 = Line(-3, 1, 1, 1)
l2 = Line(1, 1, 1, -5)
l3 = Line(1, -5, -3, -5)
l4 = Line(-3, -5, -3, 1)
r2 = Rectangle(l1, l2, l3, l4)
self.assertEqual(l1, r2.line1)
self.assertEqual(l2, r2.line2)
self.assertEqual(l3, r2.line3)
self.assertEqual(l4, r2.line4)
r3 = Rectangle(-.8, .4, 0, 2, .8, 1.6, 0, 0)
self.assertEqual(-.8, r3.point1.x)
self.assertEqual(.4, r3.point1.y)
self.assertEqual(0, r3.point2.x)
self.assertEqual(2, r3.point2.y)
self.assertEqual(.8, r3.point3.x)
self.assertEqual(1.6, r3.point3.y)
self.assertEqual(0, r3.point4.x)
self.assertEqual(0, r3.point4.y)
def _init(self):
self.n = len(self.sides)
assert (self.n < 4), 'No support for sides > 3'
if self.n == 3:
self.shape = Triangle(*self.sides)
elif self.n == 2:
self.shape = Rectangle(*self.sides)
class TestRectangle:
_instance_count = 0
def setup_class(self):
self.rectangle = Rectangle(5, 4)
def test_name(self):
rectangle = Rectangle(1, 1)
assert rectangle.name == 'Прямоугольник_2'
def test_area(self):
assert self.rectangle.area == 5 * 4
def test_angles(self):
assert self.rectangle.angles == 4
def test_perimeter(self):
assert self.rectangle.perimeter == 2 * (5 + 4)
def test_add_square(self):
circle = Rectangle(1, 1)
assert self.rectangle.add_square(circle) == 20 + 1
def test_add_square_neg(self):
not_shape = 'not_shape'
with pytest.raises(NotShapeException):
assert self.rectangle.add_square(not_shape) == 20
def line_to_shape(self, line: str) -> Optional[Shape]:
if Ellipse.is_valid_description(line):
return Ellipse.parse_from_line(line)
if Rectangle.is_valid_description(line):
return Rectangle.parse_from_line(line)
return None
def __init__(self, src: str, background: tuple = None, speed: Union[int, float] = 1, damage: Union[int, float] = 1,
acceleration: Union[int, float] = 0, animated: bool = False, animation_rows: int = None,
animation_columns: int = None,
animation_item_width: int = None, animation_item_height: int = None, animation_period: float = 0.1,
animation_main_frame: int = 0, *args, **kwargs) -> None:
"""
:param src: File of the image to load
:param background: A tuple representing RGBA values for the background
:param speed: Speed at which the projectile will move
:param damage: Damage the projectile will deal
:param acceleration: Acceleration in m/s^2
:param animated: Flag saying if the projectile uses an animation
:param animation_rows: The number of rows in the animation sequence source
:param animation_columns: The number of columns in the animation sequence source
:param animation_item_width: The width of each frame of the animation in the source
:param animation_item_height: The height of each frame in the source
:param animation_period: Time to show each frame
:param animation_main_frame: The frame in which the hitbox bounds will be calculated
:param args:
:param kwargs:
"""
if animated:
image = load(src)
image_seq = ImageGrid(image, rows=animation_rows, columns=animation_columns,
item_width=animation_item_width, item_height=animation_item_height)
image_texture = TextureGrid(image_seq)
img = Animation.from_image_sequence(image_texture[0:], period=animation_period, loop=True)
# self.src =
image_array = cv.imread(src)
x1 = animation_item_width * animation_main_frame
x2 = x1 + animation_item_width
self.np = image_array[:, x1:x2] # The numpy array used for the collision test will be the slice
else:
img = load(src)
self.np = cv.imread(src) # The whole image will be read
self.src = img
self.background = background
self.speed = speed
self.acceleration = acceleration
self.damage = damage
super().__init__(img, *args, **kwargs)
self.radians = 0
# self.anchor
if animated:
for frame in self.image.frames:
frame.image.anchor_x = image.width / animation_columns / 2
frame.image.anchor_y = image.height / animation_rows / 2
else:
self.image.anchor_x = self.image.width / 2
self.image.anchor_y = self.image.height / 2
self.init_time = time.time()
self.update(x=self.x, y=self.y)
self.refresh_threshold()
if self.background:
self.rectangle = Rectangle(x=self.get_left_bound(), y=self.get_bot_bound(), width=self.width,
height=self.height, color=self.background)
class RectangleTest(TestCase):
"""
Defines a test case for the Rectangle class.
"""
def setUp(self):
"""
Create a few test objects.
"""
self.len7wid3 = Rectangle(7, 3)
self.len1wid6 = Rectangle(1, 6)
self.len5wid5 = Rectangle(5, 5)
def test_area(self):
"""
Compare the test rectangle area computations to the actual values.
"""
self.assertEqual(self.len7wid3.area(), 21)
self.assertEqual(self.len1wid6.area(), 6)
self.assertEqual(self.len5wid5.area(), 25)
def test_perimeter(self):
"""
Compare the test rectangle perimeter computations to the actual values.
"""
self.assertEqual(self.len7wid3.perimeter(), 20)
self.assertEqual(self.len1wid6.perimeter(), 14)
self.assertEqual(self.len5wid5.perimeter(), 20)
def test_is_square(self):
"""
Confirm or deny if the rectangle is a square.
"""
self.assertFalse(self.len7wid3.is_square())
self.assertFalse(self.len1wid6.is_square())
self.assertTrue(self.len5wid5.is_square())
def testValidateRectangle(self):
r1 = ShapeFactory.build("rectangle", Point(1, 1), Point(4, 1),
Point(4, 3), Point(1, 3))
Rectangle.validateRectangle(r1, "Rectangle unexpectedly invalid")
self.assertRaises(
ShapeException, Rectangle.validateRectangle,
"(1, 1, 4, 1, 4, 3, 1, 3)",
"String \'(1, 1, 4, 1, 4, 3, 4, 3)\' is not a valid rectangle")
self.assertRaises(ShapeException, Rectangle.validateRectangle,
Point(1, 1), "Point is not a valid rectangle")
def testComputeWidth(self):
r1 = Rectangle(0, 1, 1, 1, 1, 0, 0, 0)
self.assertAlmostEqual(1, r1.computeWidth(), places=4)
r2 = Rectangle(-2, 2, 3, 2, 3, 0, -2, 0)
self.assertAlmostEqual(5, r2.computeWidth(), places=4)
r3 = Rectangle(-.8, .4, 0, 2, .8, 1.6, 0, 0)
self.assertAlmostEqual(1.7889, r3.computeWidth(), places=4)
def testComputeHeight(self):
r1 = Rectangle(0, 1, 1, 1, 1, 0, 0, 0)
self.assertAlmostEqual(1, r1.computeHeight(), places=4)
r2 = Rectangle(-2, 2, 3, 2, 3, 0, -2, 0)
self.assertAlmostEqual(2, r2.computeHeight(), places=4)
r3 = Rectangle(-.8, .4, 0, 2, .8, 1.6, 0, 0)
self.assertAlmostEqual(.8944, r3.computeHeight(), places=4)
def testMove(self):
r1 = Rectangle(-.8, .4, 0, 2, .8, 1.6, 0, 0)
r1.move(3, 4)
self.assertAlmostEqual(2.2, r1.point1.x)
self.assertAlmostEqual(4.4, r1.point1.y)
self.assertAlmostEqual(3, r1.point2.x)
self.assertAlmostEqual(6, r1.point2.y)
self.assertAlmostEqual(3.8, r1.point3.x)
self.assertAlmostEqual(5.6, r1.point3.y)
self.assertAlmostEqual(3, r1.point4.x)
self.assertAlmostEqual(4, r1.point4.y)
r1.move(-.234, -1.987)
self.assertAlmostEqual(1.966, r1.point1.x)
self.assertAlmostEqual(2.413, r1.point1.y)
self.assertAlmostEqual(2.766, r1.point2.x)
self.assertAlmostEqual(4.013, r1.point2.y)
self.assertAlmostEqual(3.566, r1.point3.x)
self.assertAlmostEqual(3.613, r1.point3.y)
self.assertAlmostEqual(2.766, r1.point4.x)
self.assertAlmostEqual(2.013, r1.point4.y)
r1.move(.234, 1.987)
self.assertAlmostEqual(2.2, r1.point1.x)
self.assertAlmostEqual(4.4, r1.point1.y)
self.assertAlmostEqual(3, r1.point2.x)
self.assertAlmostEqual(6, r1.point2.y)
self.assertAlmostEqual(3.8, r1.point3.x)
self.assertAlmostEqual(5.6, r1.point3.y)
self.assertAlmostEqual(3, r1.point4.x)
self.assertAlmostEqual(4, r1.point4.y)
def get_rectangles(filename):
"""
Read in from the JSON file supplied and create
a list of rectangles based on the input data.
This function is a generator.
"""
with open(filename, 'r') as handle:
try:
data = json.load(handle)
except json.decoder.JSONDecodeError as error:
print(error)
raise
# Manually iterate over the JSON dictionaries in the list
# of rectangles. Create a new Rectangle object for each one
# and add it to the list.
rectangle_objects = []
for rect in data['rectangle_list']:
length = rect['length']
width = rect['width']
new_rectangle = Rectangle(length, width)
rectangle_objects.append(new_rectangle)
# Return the list of Rectangle objects
return rectangle_objects
def __init__(self,
width: int,
height: int = 0,
multiline: bool = False,
dpi: object = None,
batch: Batch = None,
group: Group = None,
wrap_lines: bool = True,
x: int = 0,
y: int = 0,
underlined: bool = True,
caret_color: tuple = (0, 0, 0),
numbers_only: bool = False,
font_name=None,
font_size=None,
font_color=(255, 255, 255, 2555),
max_chars=0) -> None:
self.document = FormattedDocument()
self.layout = IncrementalTextLayout(self.document, width, height,
multiline, dpi, batch, group,
wrap_lines)
self.numbers_only = numbers_only
self.style['color'] = font_color
self.max_chars = max_chars
if font_name:
self.style['font_name'] = font_name
if font_size:
self.style['font_size'] = font_size
self.reset_style()
if not height:
# If the dev didn't specify a height, make the height equal to the height of the font
font = pyglet.font.load(
font_name or self.document.get_style('font'), font_size
or self.document.get_style('font_size'))
self.height = font.ascent - font.descent
self._hover_cursor = self.get_window().CURSOR_TEXT
super().__init__(self.layout, color=caret_color)
# TODO: Allow the dev to specify how x and y are treated
self.x = x - self.width // 2
self.y = y - self.height // 2
if underlined:
self.underline = Rectangle(
x=self.x,
y=self.y,
width=self.width,
height=1,
)
def testValidateRectangle(self):
r1 = Rectangle(1, 1, 4, 1, 4, 3, 1, 3)
Validator.validateRectangle(r1, "Rectangle unexpectedly invalid")
self.assertRaises(
ShapeException, Validator.validateRectangle,
"(1, 1, 4, 1, 4, 3, 1, 3)",
"String \'(1, 1, 4, 1, 4, 3, 4, 3)\' is not a valid rectangle")
self.assertRaises(ShapeException, Validator.validateRectangle,
Point(1, 1), "Point is not a valid rectangle")
def setUp(self):
"""
Create a few test objects.
"""
self.len7wid3 = Rectangle(7, 3)
self.len1wid6 = Rectangle(1, 6)
self.len5wid5 = Rectangle(5, 5)
def testInvalidConstruction(self):
p1 = Point(1, 3)
p2 = Point(5, 3)
p3 = Point(5, 1)
p4 = Point(1, 1)
r1 = Rectangle(p1, p2, p3, p4)
self.assertRaises(ShapeException, Square, p1, p2, p3, p4)
l1 = Line(-3, 1, 1, 1)
l2 = Line(1, 1, 1, -3)
l3 = Line(1, -3, -3, -3)
l4 = Line(-3, -3, -3, 2)
self.assertRaises(ShapeException, Square, l1, l2, l3, l4)
self.assertRaises(ShapeException, Square, -1, 0, 0, 2, 1, 0, 0, -2)
def build_figure(figure):
if figure["type"] == "point":
return Point.build(figure)
if figure["type"] == "circle":
return Circle.build(figure)
if figure["type"] == "polygon":
return Polygon.build(figure)
if figure["type"] == "rectangle":
return Rectangle.build(figure)
if figure["type"] == "square":
return Square.build(figure)
raise ValueError("incorrect type")
def add_shape(self, x: int, y: int) -> Shape:
width = self.width_box.get()
color = self.color_btn["bg"]
background = self.background_btn["bg"]
shape_type = self.type_box.get()
if shape_type == "Ellipse":
r1 = 10
r2 = 10
return Ellipse(x - r1, y - r2, r1, r2, width, color, background)
if shape_type == "Rectangle":
w = 20
h = 20
return Rectangle(x - w, y - h, w, h, width, color, background)
def paint(canvas):
text = read_file()
for line in text:
if "rcl" in line or "va" in line:
prop = line.split(", ")
Oval(canvas, prop[1], prop[2], prop[3], prop[4], prop[5], prop[6],
prop[7])
elif "ua" in line or "rect" in line:
prop = line.split(", ")
Rectangle(canvas, prop[1], prop[2], prop[3], prop[4], prop[5],
prop[6], prop[7])
elif "tri" in line:
prop = line.split(", ")
Triangle(canvas, prop[1], prop[2], prop[3], prop[4], prop[5],
prop[6], prop[7], prop[8], prop[9])
elif "in" in line:
prop = line.split(", ")
Line(canvas, prop[1], prop[2], prop[3], prop[4], prop[5], prop[6])
elif "arc" in line:
prop = line.split(", ")
Arc(canvas, prop[1], prop[2], prop[3], prop[4], prop[5], prop[6],
prop[7], prop[8], prop[9])
from shapes.ellipse import Ellipse
from shapes.circle import Circle
from shapes.rectangle import Rectangle
from shapes.square import Square
from shape_list.shape_list import ShapeList
from color.color import Color
shape_list = ShapeList()
try:
shape_list.append(1)
except TypeError:
print('Only shape append support')
shape_list.append(Circle(5, Color.BLUE))
shape_list.append(Rectangle(2, 3, Color.RED))
shape_list.append(Square(5, Color.BLUE))
shape_list.append(Ellipse(2, 3, Color.GREEN))
print(shape_list)
print(shape_list.sorted_shapes_areas(Color.BLUE))
print(Ellipse(4, 5, Color.BLUE).__hash__())
print(Ellipse(4, 5, Color.RED).__hash__())
print(Ellipse(5, 4, Color.BLUE).__hash__())
a = Circle(4, Color.BLUE)
d = Circle(4, Color.BLUE)
b = Circle(4, Color.RED)
c = Ellipse(4, 5, Color.BLUE)
print(a == c) #False
print(a == b) #False
print(a == d) #True
def testRectangle3by2(self):
self.assertEqual('***\n***\n', str(Rectangle(3, 2)))
class GameInterface(Interface):
attack: AttackPattern = None
aii: ArrayInterfaceImage = None
background_sprite: Sprite = None
batch: Batch = None
border: Rectangle = None
enemy: Enemy = None
image = None
facecam: Facecam = None
face_cascade = None
foreground_sprite: Sprite = None
fps_display: FPSDisplay = None
keys = key.KeyStateHandler()
player: Player = None
projectiles: List[Projectile] = []
powerup: Powerup = None
scheduled_functions = tuple()
def __init__(self):
super().__init__()
window = system.get_window()
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
base_path = os.path.join('images', 'space_background_pack', 'layers')
self.background = load(os.path.join(base_path, 'parallax-space-background.png'))
self.background_sprite = Sprite(self.background)
big_planet = load(os.path.join(base_path, 'parallax-space-big-planet.png'))
self.big_planet_sprite = Sprite(big_planet)
far_planet = load(os.path.join(base_path, 'parallax-space-far-planets.png'))
self.far_planet_sprite = Sprite(far_planet)
ring_planet = load(os.path.join(base_path, 'parallax-space-ring-planet.png'))
self.ring_planet_sprite = Sprite(ring_planet)
self.ring_planet_sprite.x = 100
self.ring_planet_sprite.y = 100
stars = load(os.path.join(base_path, 'parallax-space-stars.png'))
self.stars_sprite = Sprite(stars)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.check_direction, 1 / 120),
(self.generate_powerup, 20)
)
if config.get_config('control') == 1:
self.face_cascade = cv.CascadeClassifier(
'venv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
self.facecam = Facecam(face_cascade=self.face_cascade).start()
self.aii = ArrayInterfaceImage(self.facecam.read(), 'BGR')
self.image = self.aii.texture
@self.facecam.event('on_face_move')
def follow_face(x, y, width, height):
# Need to flip things first to work
x = self.image.width - x
y = self.image.height - y
new_x = self.border.x + x - width // 2
new_y = self.border.y + y - height // 2
self.player.move(new_x, new_y)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.generate_powerup, 20),
)
window.push_handlers(self.facecam)
self.player = Player(src='images/ufo.png')
self.border = Rectangle(
width=(500 if not self.image else self.image.width) + 10,
height=(500 if not self.image else self.image.height) + 10,
color=(0, 0, 0, 127)
)
self.player.scale = 1.2
self.batch = Batch()
self.projectiles: List[Projectile] = []
window.push_handlers(self.keys)
def pause_game(symbol, modifiers):
if symbol == key.ESCAPE:
self.enemy.running = not self.enemy.running
self.enemy.attack_pattern.running = not self.enemy.attack_pattern.running
self.player.running = not self.player.running
window.on_key_press = pause_game
for func, interval in self.scheduled_functions:
clock.schedule_interval(func, interval)
self.fps_display = FPSDisplay(window)
self.generate_enemy(0)
self.resize()
def generate_enemy(self, dt):
enemy_index = config.get_config('enemy')
if enemy_index > len(enemies) - 1:
return system.get_window().load_interface(WinInterface())
window = system.get_window()
self.enemy = enemies[enemy_index](self.batch, speed=100)
self.enemy.move(window.width * 0.8, window.height / 2)
self.enemy.next_x, self.enemy.next_y = self.enemy.x, self.enemy.y
def on_die():
config.set_config('enemy', config.get_config('enemy') + 1)
clock.schedule_once(self.generate_enemy, 2)
self.enemy.on_die = on_die
def resize(self):
window = system.get_window()
scale = window.width / self.background.width
self.background_sprite.scale = scale
self.big_planet_sprite.scale = scale / 2
self.far_planet_sprite.scale = scale / 2
self.ring_planet_sprite.scale = scale / 2
self.stars_sprite.scale = scale
self.big_planet_sprite.x = window.width / 2
self.big_planet_sprite.y = window.height / 2
self.far_planet_sprite.x = window.width - self.far_planet_sprite.width
self.far_planet_sprite.y = window.height - self.far_planet_sprite.height
if self.image:
self.image.x = (window.width - self.image.width) / 2
self.image.y = (window.height - self.image.height) / 2
self.border.x = window.width / 2 * 0.3
self.border.y = (window.height - self.border.height) / 2
self.generate_powerup(0)
self.player.move(x=window.width / 2 * 0.3, y=window.height / 2)
def on_draw(self):
self.animate_background()
self.background_sprite.draw()
self.big_planet_sprite.draw()
self.far_planet_sprite.draw()
self.ring_planet_sprite.draw()
self.stars_sprite.draw()
self.border.draw()
if self.facecam:
img = self.facecam.read()
img = cv.flip(img, -1)
self.image.blit(self.border.x, self.border.y, 0)
self.aii.view_new_array(img)
# self.fps_display.draw()
self.player.draw()
self.batch.draw()
# self.attack.draw()
if self.enemy:
self.enemy.draw()
if self.powerup:
self.powerup.forward()
self.powerup.draw()
if self.player.check_for_collision(self.powerup):
self.powerup.on_collide(self.player)
self.powerup.delete()
self.powerup = None
def animate_background(self):
big_planet_sprite_depth = 3
far_planet_sprite_depth = 10
ring_planet_sprite_depth = 5
stars_sprite_depth = 8
window = system.get_window()
self.big_planet_sprite.x = self.big_planet_sprite.x - 1 * (1 / big_planet_sprite_depth)
if self.big_planet_sprite.x + self.big_planet_sprite.width <= 0:
self.big_planet_sprite.x = window.width
self.far_planet_sprite.x = self.far_planet_sprite.x - 1 * (1 / far_planet_sprite_depth)
if self.far_planet_sprite.x + self.far_planet_sprite.width <= 0:
self.far_planet_sprite.x = window.width
self.ring_planet_sprite.x = self.ring_planet_sprite.x - 1 * (1 / ring_planet_sprite_depth)
if self.ring_planet_sprite.x + self.ring_planet_sprite.width <= 0:
self.ring_planet_sprite.x = window.width
self.stars_sprite.x = self.stars_sprite.x - 1 * (1 / stars_sprite_depth)
if self.stars_sprite.x + self.stars_sprite.width <= 0:
self.stars_sprite.x = window.width
def generate_powerup(self, dt):
window = system.get_window()
# roll = random.randint(1, 10)
roll = 1
if roll <= 3: # 30% chance of getting a powerup
powerup = random.choice(powerups)(batch=self.batch)
x = random.randint(int(self.border.x), int(self.border.x + self.border.width))
powerup.move(x=x, y=window.height)
@powerup.movement
def movement():
powerup.move(powerup.x, powerup.y - powerup.calculate_speed())
self.powerup = powerup
def randomize_projectiles(self, dt):
if self.enemy:
self.enemy.attack_pattern.generate()
def check_direction(self, dt):
unit = 500 * dt
if self.keys[key.DOWN]:
if self.player.get_bot_bound() - unit >= self.border.y:
self.player.move(self.player.x, self.player.y - unit)
elif self.keys[key.UP]:
if self.player.get_bot_bound() + self.player.height + unit <= self.border.y + self.border.height:
self.player.move(self.player.x, self.player.y + unit)
# self.player.y += unit
if self.keys[key.LEFT]:
if self.player.get_left_bound() - unit >= self.border.x:
self.player.move(self.player.x - unit, self.player.y)
elif self.keys[key.RIGHT]:
if self.player.get_left_bound() + self.player.width + unit <= self.border.x + self.border.width:
self.player.move(self.player.x + unit, self.player.y)
# if self.keys[key.ESCAPE]:
# fg_ratio = 0.4
# bg_ratio = 0.1
# self.foreground_sprite.x = (window.width * (1 + fg_ratio)) / 2 - self.player.x * fg_ratio
# self.foreground_sprite.y = (window.height * (1 + fg_ratio)) / 2 - self.player.y * fg_ratio
# self.background_sprite.x = (window.width * (1 + bg_ratio)) / 2 - self.player.x * bg_ratio
# self.background_sprite.y = (window.height * (1 + bg_ratio)) / 2 - self.player.y * bg_ratio
def clean(self):
self.enemy.clean()
if self.facecam:
self.facecam.clean()
print(f'Deleting {self}')
super().clean()
def test_rectangle():
"""
Defines tests on some specific rectangle objects.
"""
len7wid3 = Rectangle(7, 3)
len1wid6 = Rectangle(1, 6)
len5wid5 = Rectangle(5, 5)
# Test areas, perimeters, and whether they are squares
assert len7wid3.area() == 21
assert len1wid6.area() == 6
assert len5wid5.area() == 25
assert len7wid3.perimeter() == 20
assert len1wid6.perimeter() == 14
assert len5wid5.perimeter() == 20
assert not len7wid3.is_square()
assert not len1wid6.is_square()
assert len5wid5.is_square()
def test_error_if_not_figure():
rectangle = Rectangle(5, 2)
with pytest.raises(Exception):
rectangle.add_area(object())
def test_rectangle(self):
r = Rectangle(2, 4)
self.assertEqual(r.perimeter(), 12)
self.assertEqual(r.area(), 8)
self.assertFalse(r.is_square())
def test_rectangle_angles_equals_four():
rectangle = Rectangle(10, 6)
assert rectangle.get_angles() == 4
def test_rectangle_is_instance_figure():
assert isinstance(Rectangle(5, 2), BaseShape)
def test_name_rectangle():
rectangle = Rectangle(5, 2)
assert rectangle.get_name() == "Rectangle"
def __init__(self):
super().__init__()
window = system.get_window()
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
base_path = os.path.join('images', 'space_background_pack', 'layers')
self.background = load(os.path.join(base_path, 'parallax-space-background.png'))
self.background_sprite = Sprite(self.background)
big_planet = load(os.path.join(base_path, 'parallax-space-big-planet.png'))
self.big_planet_sprite = Sprite(big_planet)
far_planet = load(os.path.join(base_path, 'parallax-space-far-planets.png'))
self.far_planet_sprite = Sprite(far_planet)
ring_planet = load(os.path.join(base_path, 'parallax-space-ring-planet.png'))
self.ring_planet_sprite = Sprite(ring_planet)
self.ring_planet_sprite.x = 100
self.ring_planet_sprite.y = 100
stars = load(os.path.join(base_path, 'parallax-space-stars.png'))
self.stars_sprite = Sprite(stars)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.check_direction, 1 / 120),
(self.generate_powerup, 20)
)
if config.get_config('control') == 1:
self.face_cascade = cv.CascadeClassifier(
'venv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
self.facecam = Facecam(face_cascade=self.face_cascade).start()
self.aii = ArrayInterfaceImage(self.facecam.read(), 'BGR')
self.image = self.aii.texture
@self.facecam.event('on_face_move')
def follow_face(x, y, width, height):
# Need to flip things first to work
x = self.image.width - x
y = self.image.height - y
new_x = self.border.x + x - width // 2
new_y = self.border.y + y - height // 2
self.player.move(new_x, new_y)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.generate_powerup, 20),
)
window.push_handlers(self.facecam)
self.player = Player(src='images/ufo.png')
self.border = Rectangle(
width=(500 if not self.image else self.image.width) + 10,
height=(500 if not self.image else self.image.height) + 10,
color=(0, 0, 0, 127)
)
self.player.scale = 1.2
self.batch = Batch()
self.projectiles: List[Projectile] = []
window.push_handlers(self.keys)
def pause_game(symbol, modifiers):
if symbol == key.ESCAPE:
self.enemy.running = not self.enemy.running
self.enemy.attack_pattern.running = not self.enemy.attack_pattern.running
self.player.running = not self.player.running
window.on_key_press = pause_game
for func, interval in self.scheduled_functions:
clock.schedule_interval(func, interval)
self.fps_display = FPSDisplay(window)
self.generate_enemy(0)
self.resize()
def test_rectangles_equals_area_after_add_area():
rectangle_1 = Rectangle(5, 2)
triangle_2 = Triangle(6, 3)
assert rectangle_1.add_area(triangle_2) == triangle_2.add_area(rectangle_1)
