def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = (255, 255, 255)
self.single_play_button = Button(
Rect(100, 100, 750, 100),
(absolute_position[0], absolute_position[1]),
"Создать новую сессию",
)
self.network_button = Button(
Rect(100, 300, 750, 100),
(absolute_position[0], absolute_position[1]),
"Присоединиться",
)
self.exit_button = Button(
Rect(100, 600, 750, 100),
(absolute_position[0], absolute_position[1]),
"Назад",
)
self.buttons.append(self.single_play_button)
self.buttons.append(self.exit_button)
self.buttons.append(self.network_button)
def try_place_unit(
self, unit: Unit, x: int, y: int, non_intersect_mode: bool = False
):
unit_rect = Rect(x, y, unit.collision.width, unit.collision.height)
map_rect = Rect(0, 0, self.width, self.height)
if (
not map_rect.collidepoint(x, y)
or not map_rect.collidepoint(
x + unit.collision.width - 1, y + unit.collision.height - 1
)
or len(self.get_intersected_units(unit_rect)) > 0
) and not non_intersect_mode:
return False
unit.collision.set_x(x).set_y(y)
self.units.append(unit)
if unit.update_mode == UpdateMode.IntersectOnly:
self.units_for_intersect_buffer.append(unit)
elif unit.update_mode == UpdateMode.StepOnly:
self.units_for_step_buffer.append(unit)
elif unit.update_mode == UpdateMode.StepIntersect:
self.units_for_intersect_buffer.append(unit)
self.units_for_step_buffer.append(unit)
return True
def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = GraphicUtils.WHITE_COLOR
self.text = Text(
Rect(100, 300, 200, 25),
(absolute_position[0], absolute_position[1]),
)
self.restart_button = Button(
Rect(100, 100, 750, 100),
(absolute_position[0], absolute_position[1]),
"Перезапустить",
)
self.exit_button = Button(
Rect(100, 600, 750, 100),
(absolute_position[0], absolute_position[1]),
"В главное меню",
)
self.buttons.append(self.restart_button)
self.buttons.append(self.exit_button)
self.text_size = 10
self.text_color = GraphicUtils.RED_BLUE_COLOR
def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = (255, 255, 255)
self.single_play_button = Button(
Rect(100, 100, 750, 100),
(absolute_position[0], absolute_position[1]),
"Одиночная игра",
)
self.network_button = Button(
Rect(100, 300, 750, 100),
(absolute_position[0], absolute_position[1]),
"Сетевая игра",
)
self.exit_button = Button(
Rect(100, 600, 750, 100),
(absolute_position[0], absolute_position[1]),
"Выход",
)
self.buttons.append(self.single_play_button)
self.buttons.append(self.exit_button)
def __init__(self):
self.collision = Rect()
self.max_speed = 0
self.health_points = 1
self.current_direction = Direction.Up
self.current_move_direction = Direction.Null
self.velocity = (0, 0)
self.actions = list()
self.type = UnitType.Null
self.update_mode = UpdateMode.StepIntersect
def test_on_explosion(self):
self.field = GameField()
wall = BreakableWall()
wall.collision = Rect(0, 0, LITTLE_WALL_LENGTH * 5,
LITTLE_WALL_LENGTH * 7)
self.field_rectangle = Rect(0, 0, self.field.width, self.field.height)
self.field.try_place_unit(wall, 0, 0)
wall.on_explosion(self.field, Rect(0, 0, 20, 20))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)),
5 * 7 - 4,
)
def test_step(self):
field = GameField()
field_rectangle = Rect(0, 0, field.width, field.height)
spawner = TankBotSpawner()
field.try_place_unit(spawner, 1, 1)
spawner.no_tank_tick_pointer = spawner.no_tank_tick_count
spawner.step(field)
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
spawner.step(field)
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
spawner.no_tank_tick_pointer = spawner.no_tank_tick_count
spawner.step(field)
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
spawner.no_tank_tick_pointer = 0
field.try_remove_unit(spawner.current_tank)
field.update()
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
spawner.no_tank_tick_pointer = spawner.no_tank_tick_count
spawner.is_tank_alive = False
spawner.step(field)
spawner.no_tank_tick_pointer = spawner.no_tank_tick_count
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
spawner.step(field)
self.assertEqual(len(field.get_intersected_units(field_rectangle)), 0)
def __init__(
self,
transform=(0, 0, 1, 1),
texture_name=None,
draw_rect=Rect(0, 0, 0, 0),
texture_rect=None,
texture_rotate=None,
fill_color=None,
outline_color=None,
outline_size=None,
text=None,
text_color=(0, 0, 0),
text_size=36,
image_transform=(1, 1),
render_priority=0,
):
self.transform = transform
self.texture_name = texture_name
self.draw_rect = draw_rect
self.texture_rect = texture_rect
self.texture_rotate = texture_rotate
self.fill_color = fill_color
self.outline_color = outline_color
self.outline_size = outline_size
self.text = text
self.text_size = text_size
self.text_color = text_color
self.image_transform = image_transform
self.render_priority = render_priority
def __init__(
self,
tank_to_go=DEFAULT_TANK_SPAWNER_TANK_TO_GO,
next_tank_pointer=None,
priority_direction=None,
):
super().__init__()
self.collision = Rect(-1, -1, DEFAULT_TANK_SPAWNER_SIZE[0],
DEFAULT_TANK_SPAWNER_SIZE[1])
self.type = UnitType.BotSpawner
self.is_tank_alive = False
self.current_tank = None
self.no_tank_tick_count = DEFAULT_TANK_SPAWNER_COOL_DOWN
self.no_tank_tick_pointer = 0
self.tank_to_go = tank_to_go
self.next_tank_pointer = next_tank_pointer
self.tanks_to_go = list()
self.priority_direction = priority_direction
self.update_mode = UpdateMode.StepOnly
self.directions = [
Direction.Down,
Direction.Up,
Direction.Right,
Direction.Left,
]
def get_render_info(self, transform: Tuple,
buffer_to_render: BufferToRender) -> list:
result = list()
self.hp = "HP: " + str(buffer_to_render.health_points)
self.kills = "Kills: " + str(buffer_to_render.points[0])
self.speed = "Speed: " + str(buffer_to_render.speed)
self.cool_dawn = "CD: {} | {}".format(buffer_to_render.cool_dawn[0],
buffer_to_render.cool_dawn[1])
if buffer_to_render.bonus_cool_dawn[2] is not None:
self.bonus_cool_dawn = "{} | {}".format(
buffer_to_render.bonus_cool_dawn[0],
buffer_to_render.bonus_cool_dawn[1],
)
result.append(
DrawInformation.get_info_by(
buffer_to_render.bonus_cool_dawn[2],
Rect(
transform[0] + 10,
transform[1] + 100,
transform[2],
transform[3],
),
Direction.Null,
))
result.append(get_draw_info(transform, self.bonus_cool_dawn, 160))
result.append(get_draw_info(transform, self.hp, 10))
result.append(get_draw_info(transform, self.kills, 30))
result.append(get_draw_info(transform, self.speed, 50))
result.append(get_draw_info(transform, self.cool_dawn, 70))
return result
def __init__(self):
super().__init__()
self.type = UnitType.TankRed
self.max_speed = ARMORED_BOT_SPEED
self.collision = Rect(w=ARMORED_TANK_SIZE[0], h=ARMORED_TANK_SIZE[1])
self.shot_await_tick_count = ARMORED_TANK_COOL_DOWN
self.health_points = ARMORED_TANK_HEALTH_POINTS
def explode(
self,
source_explosion: Bullet,
radius: int,
source_rect: Rect,
collide_units: list = None,
):
explosion_rect = Rect(
int(source_rect.x + source_rect.width / 2 - radius / 2),
int(source_rect.y + source_rect.height / 2 - radius / 2),
radius,
radius,
)
if collide_units is None:
for unit in self.get_intersected_units(explosion_rect):
unit.on_explosion(self, explosion_rect)
self.try_set_score(unit, source_explosion.owner)
else:
for unit in self.get_intersected_units(explosion_rect):
if unit not in collide_units:
unit.on_explosion(self, explosion_rect)
else:
unit.on_shot(self, explosion_rect)
self.try_set_score(unit, source_explosion.owner)
def __init__(self, rect, absolute_position):
super().__init__(rect, absolute_position)
self.inside_game_board = InsideGameBoard(
Rect(self.collision.w, 0, 150, self.collision.h),
(self.collision.w, 0),
)
def __init__(self, width=BIG_WALL_LENGTH, height=BIG_WALL_LENGTH):
super().__init__()
self.collision = Rect(w=width, h=height)
self.type = UnitType.IronWall
self.health_points = IRON_HEALTH_POINTS
self.update_mode = UpdateMode.IntersectOnly
def test_try_place_unit(self):
self.field = GameField()
self.field_rectangle = Rect(0, 0, self.field.width, self.field.height)
self.assertTrue(self.field.try_place_unit(get_default_unit(), 1, 1))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 1
)
self.assertFalse(self.field.try_place_unit(get_default_unit(), 1, 1))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 1
)
self.assertTrue(self.field.try_place_unit(get_default_unit(), 4, 4))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 2
)
self.assertFalse(self.field.try_place_unit(get_default_unit(), -1, -1))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 2
)
self.assertFalse(
self.field.try_place_unit(get_default_unit(), 2, 56465435)
)
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 2
)
def shot(self, field):
if self.shot_await_tick_pointer > 0:
return
self.shot_await_tick_pointer = 1
bullet = Bullet(self)
bullet.current_direction = self.current_direction
bullet.set_velocity(bullet.current_direction)
self.location_to_bullet = self.get_spawn_location(
self.current_direction, bullet.collision
)
if not field.try_place_unit(
bullet, self.location_to_bullet[0], self.location_to_bullet[1]
):
explosion_rect = Rect(
self.location_to_bullet[0],
self.location_to_bullet[1],
bullet.collision.width,
bullet.collision.height,
)
units = field.get_intersected_units(explosion_rect)
if len(units) == 0:
self.shot_await_tick_pointer = 0
for unit in units:
unit.on_shot(field, explosion_rect)
field.try_set_score(unit, self)
def __init__(self):
super().__init__()
self.type = UnitType.TankOrange
self.max_speed = RAPID_FIRE_BOT_SPEED
self.collision = Rect(w=RAPID_FIRE_TANK_SIZE[0],
h=RAPID_FIRE_TANK_SIZE[1])
self.shot_await_tick_count = RAPID_FIRE_TANK_COOL_DOWN
self.health_points = RAPID_FIRE_TANK_HEALTH_POINTS
def __init__(self):
super().__init__()
self.bonuses = list()
self.next_bonuses = None
self.type = UnitType.BonusSpawner
self.cool_down = BONUS_COOL_DOWN
self.tick_pointer = 0
self.collision = Rect(w=LITTLE_WALL_LENGTH, h=LITTLE_WALL_LENGTH)
def test_move_step(self):
self.field = GameField()
wall = BreakableWall()
wall.collision = Rect(
0, 0, LITTLE_WALL_LENGTH * 5, LITTLE_WALL_LENGTH * 7
)
self.field_rectangle = Rect(0, 0, self.field.width, self.field.height)
self.field.try_place_unit(wall, 0, 0)
bullet = Bullet(Tank())
bullet.current_direction = Direction.Left
self.field.try_place_unit(bullet, LITTLE_WALL_LENGTH * 5 + 1, 1)
bullet.move_step(self.field)
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)),
5 * 7 - 2,
)
def __init__(self):
super().__init__()
self.type = UnitType.TankGreenThree
self.max_speed = HEAL_BOT_SPEED
self.collision = Rect(w=HEAL_TANK_SIZE[0], h=HEAL_TANK_SIZE[1])
self.shot_await_tick_count = HEAL_TANK_COOL_DOWN
self.max_health_points = self.health_points = HEAL_TANK_HEALTH_POINTS
self.heal_cool_dawn = HEAL_TANK_HEAL_COOL_DOWN
self.heal_cool_dawn_pointer = 0
def test_move_step(self):
field = GameField()
tank = TankBot()
tank.max_speed = 2
tank.set_velocity(Direction.Up)
self.assertTrue(field.try_place_unit(tank, 0, 0))
tank.move_step(field)
self.assertEqual(tank.collision,
Rect(0, 0, tank.collision.w, tank.collision.h))
tank.set_velocity(Direction.Down)
tank.move_step(field)
self.assertNotEqual(tank.collision,
Rect(0, 0, tank.collision.w, tank.collision.h))
def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = GraphicUtils.WHITE_COLOR
self.join_button = Button(
Rect(100, 300, 750, 100),
(absolute_position[0], absolute_position[1]),
"Присоединиться",
)
self.exit_button = Button(
Rect(100, 600, 750, 100),
(absolute_position[0], absolute_position[1]),
"Назад",
)
self.buttons.append(self.join_button)
self.buttons.append(self.exit_button)
def __init__(self, owner: Unit):
super().__init__()
self.collision = Rect(w=DEFAULT_BULLET_SIZE[0],
h=DEFAULT_BULLET_SIZE[1])
self.max_speed = DEFAULT_BULLET_SPEED
self.current_direction = Direction.Up
self.owner = owner
self.explosion_radius = DEFAULT_EXPLOSION_LENGTH
self.type = UnitType.Bullet
self.update_mode = UpdateMode.StepOnly
def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = GraphicUtils.WHITE_COLOR
self.new_game_button = Button(
Rect(100, 100, 750, 100),
(absolute_position[0], absolute_position[1]),
"Новая игра",
)
self.exit_button = Button(
Rect(100, 300, 750, 100),
(absolute_position[0], absolute_position[1]),
"Назад",
)
self.buttons.append(self.new_game_button)
self.buttons.append(self.exit_button)
def __init__(self):
super().__init__()
self.collision = Rect(w=DEFAULT_TANK_SIZE[0], h=DEFAULT_TANK_SIZE[1])
self.max_speed = DEFAULT_TANK_SPEED
self.current_direction = Direction.Up
self.current_bonus = None
self.type = UnitType.TankGreenOne
self.location_to_bullet = None
self.shot_await_tick_count = DEFAULT_TANK_COOL_DOWN
self.shot_await_tick_pointer = 0
def test_get_render_info(self):
wall = BreakableWall()
wall.collision = Rect(0, 0, LITTLE_WALL_LENGTH * 5,
LITTLE_WALL_LENGTH * 7)
info = wall.get_render_info()
self.assertEqual(len(info), 5 * 7)
self.assertEqual(info[0][0], UnitType.BrickWall)
self.assertEqual(info[0][1].w, LITTLE_WALL_LENGTH)
self.assertEqual(info[0][1].h, LITTLE_WALL_LENGTH)
self.assertEqual(info[0][2], Direction.Up)
def test_try_remove_unit(self):
self.field = GameField()
self.field_rectangle = Rect(0, 0, self.field.width, self.field.height)
unit = get_default_unit()
self.field.try_place_unit(unit, 1, 1)
self.assertTrue(self.field.try_remove_unit(unit))
self.field.update()
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 0
)
def on_explosion(self, field, explosion_rect: Rect):
self.health_points -= 1
if self.health_points <= 0:
field.try_remove_unit(self)
for x in range(self.collision.width // LITTLE_WALL_LENGTH):
for y in range(self.collision.height // LITTLE_WALL_LENGTH):
if not explosion_rect.colliderect(
Rect(
self.collision.x + x * LITTLE_WALL_LENGTH,
self.collision.y + y * LITTLE_WALL_LENGTH,
LITTLE_WALL_LENGTH,
LITTLE_WALL_LENGTH,
)):
field.try_place_unit(
BreakableWall(
LITTLE_WALL_LENGTH,
LITTLE_WALL_LENGTH,
),
self.collision.x + x * LITTLE_WALL_LENGTH,
self.collision.y + y * LITTLE_WALL_LENGTH,
)
def __init__(self, rect: Rect, absolute_position: Tuple):
super().__init__(rect, absolute_position)
self.buttons = list()
self.back_color = GraphicUtils.WHITE_COLOR
self.continue_button = Button(
Rect(100, 100, 750, 100),
(absolute_position[0], absolute_position[1]),
"Продолжить",
)
self.exit_button = Button(
Rect(100, 600, 750, 100),
(absolute_position[0], absolute_position[1]),
"В главное меню",
)
self.buttons.append(self.continue_button)
self.buttons.append(self.exit_button)
self.text_size = 36
self.text_color = GraphicUtils.RED_BLUE_COLOR
def test_explode(self):
self.field = GameField()
self.field_rectangle = Rect(0, 0, self.field.width, self.field.height)
self.field.try_place_unit(BreakableWall(16, 16), 1, 1)
self.field.try_place_unit(BreakableWall(16, 16), 3, 1)
self.field.try_place_unit(BreakableWall(16, 16), 6, 1)
self.field.try_place_unit(BreakableWall(16, 16), 77, 1)
self.field.try_place_unit(BreakableWall(16, 16), 300, 1)
self.field.try_place_unit(BreakableWall(16, 16), 26, 1)
self.field.explode(Bullet(Tank()), 200, Rect(0, 0, 6, 6))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 1
)
self.field = GameField()
self.field.try_place_unit(BreakableWall(32, 32), 20, 20)
self.field.explode(Bullet(Tank()), 10, Rect(20, 20, 6, 6))
self.assertEqual(
len(self.field.get_intersected_units(self.field_rectangle)), 3
)
