def test_alt_move_up(self):
self.gamefield.bomberman.position = c.Position(1, 3)
self.gamefield.bomberman.move_right()
self.gamefield.make_moves()
self.gamefield.bomberman.stop_moving_right()
self.gamefield.bomberman.move_up()
self.movable_move(0, c.Position(1, 3))
def test_alt_move_left(self):
self.gamefield.bomberman.position = c.Position(3, 1)
self.gamefield.bomberman.move_down()
self.gamefield.make_moves()
self.gamefield.bomberman.stop_moving_down()
self.gamefield.bomberman.move_left()
self.movable_move(0, c.Position(3, 1))
def bonus_explosion(self, bonus_type):
self.gamefield.bomberman.place_bomb(self.gamefield)
self.gamefield.gamefield[1][2] = bonus_type(c.Position(2, 1))
self.gamefield.bomberman.position = c.Position(1, 3)
cell = self.gamefield.gamefield[1][1]
while isinstance(cell, b.Bomb) and cell.timer != 0:
self.gamefield.make_moves()
cell = self.gamefield.gamefield[1][1]
self.gamefield.make_moves()
self.assertIsInstance(self.gamefield.gamefield[1][2], ex.Explosion)
def __init__(self, pos, max_speed, tick_time, acceleration=0, price=1):
self.x_direct = None
self.y_direct = None
self.x_move_funcs = [(math.floor, math.floor), (math.ceil, math.floor),
(math.floor, math.ceil), (math.ceil, math.ceil)]
self.y_move_funcs = [(math.floor, math.floor), (math.floor, math.ceil),
(math.ceil, math.floor), (math.ceil, math.ceil)]
self.x_mv_vls = (0, self.x_move_funcs)
self.y_mv_vls = (1, self.y_move_funcs)
self._position = pos
self.rounded_pos = c.Position(round(self._position.x),
round(self._position.y))
self.max_speed = max_speed
self.tick_time = tick_time
self.x_speed = 0
self.y_speed = 0
self.lifes = 1
self.damage_standart_cd = 2
self.damage_cd = 0
self.dead = False
self.max_speed = round(max_speed, 2)
if acceleration == 0:
self.acceleration = self.max_speed / 2
else:
self.acceleration = acceleration
self.points = 0
self.price = price
def test_bomb(self):
self.gamefield.bomberman.ex_type = exive.ExplosionType.T4
self.gamefield.bomberman.position = c.Position(4, 2)
self.gamefield.bomberman.place_bomb(self.gamefield)
self.gamefield.bomberman.position = c.Position(1, 1)
cell = self.gamefield.gamefield[2][4]
while cell.timer != 0 and isinstance(cell, b.Bomb):
self.gamefield.make_moves()
cell = self.gamefield.gamefield[2][4]
self.gamefield.make_moves()
self.assertIsInstance(self.gamefield.gamefield[1][4], ex.Explosion)
self.assertIsInstance(self.gamefield.gamefield[2][4], ex.Explosion)
self.assertIsInstance(self.gamefield.gamefield[2][3], ex.Explosion)
self.assertIsInstance(self.gamefield.gamefield[3][4], ex.Explosion)
self.assertIsInstance(self.gamefield.gamefield[4][4], ex.Explosion)
self.assertIsInstance(self.gamefield.gamefield[5][4], ex.Explosion)
self.assertIsInstance(self.gamefield.movable[0], db.Dying_bomberman)
def create_gamefield(file_path):
with open(file_path) as f:
str_field = f.read().split('\n')
f.close()
game_info = str_field.pop(0).split()
width = int(game_info[0]) + 2
bonuses_count = int(game_info[1])
mutable_walls = []
movable = []
gamefield = []
Gamefield_creator.create_wall_line(gamefield, width)
for i in range(len(str_field)):
string = str_field[i]
string = string[0:width]
field_line = []
field_line.append(wi.Wall_Immutable(c.Position(0, i + 1)))
for j in range(len(string)):
game_object = cells.get(string[j])
if not game_object:
raise InvalidFileException
position = c.Position(j + 1, i + 1)
if issubclass(game_object, m.Movable):
field_line.append(ec.Empty(position))
movable.append((game_object, position))
else:
if game_object is wm.Wall_Mutable:
field_line.append(game_object(
position, ex.ExplosionType(int(string[j]))))
else:
field_line.append(game_object(position))
if isinstance(field_line[- 1], wm.Wall_Mutable):
mutable_walls.append(field_line[len(field_line) - 1])
while len(field_line) < width - 1:
field_line.append(ec.Empty(c.Position(len(field_line), i + 1)))
field_line.append(wi.Wall_Immutable(
c.Position(len(field_line), i + 1)))
gamefield.append(field_line)
Gamefield_creator.create_wall_line(gamefield, width)
gamefield[1][1] = ec.Empty(c.Position(1, 1))
Gamefield_creator.randomize_bonuses(mutable_walls, bonuses_count)
return gamefield, movable
def action(self, gamefield, tick_time):
if self.damage_cd != 0:
self.damage_cd -= tick_time
psbl_x_spd = 0 if not self.x_direct else self.try_move(
gamefield, self.x_direct, self.x_speed)
if psbl_x_spd == 0 and self.x_direct and not self.y_direct:
values = [[self.top_y, self.left_x], [self.bot_y, self.left_x]]
psbl_y_spd = self.alt_move(self.x_direct, self.y, gamefield,
values, self.y_mv_vls, self.y_speed)
else:
psbl_y_spd = 0 if psbl_x_spd != 0 else self.try_move(
gamefield, self.y_direct, self.y_speed)
if psbl_y_spd == 0 and psbl_x_spd == 0 and self.y_direct:
values = [[self.top_y, self.left_x],
[self.top_y, self.right_x]]
psbl_x_spd = self.alt_move(self.y_direct, self.x, gamefield,
values, self.x_mv_vls, self.x_speed)
self.x_speed = psbl_x_spd
self.y_speed = psbl_y_spd
self.rounded_pos = c.Position(round(self._position.x),
round(self._position.y))
gamefield[self.rounded_pos.y][self.rounded_pos.x].contact(self)
self._position = c.Position(round(self.x + self.x_speed, 2),
round(self.y + self.y_speed, 2))
def positive_move(self, pos, gamefield, searched_item, funcs, speed):
speed = speed if speed >= 0 else 0
psbl_spd = speed + self.acceleration
psbl_spd = psbl_spd if psbl_spd <= self.max_speed else self.max_speed
next_pos = [pos.x, pos.y]
next_pos[searched_item] += psbl_spd
pos = c.Position(next_pos[0], next_pos[1])
y1 = funcs[2][0](pos.y)
x1 = funcs[2][1](pos.x)
y2 = funcs[3][0](pos.y)
x2 = funcs[3][1](pos.x)
if not (gamefield[y1][x1].is_passable(self)
and gamefield[y2][x2].is_passable(self)):
pos = self._position.position
psbl_spd = math.ceil(pos[searched_item]) - pos[searched_item]
return psbl_spd
def negative_move(self, pos, gamefield, searched_item, funcs, speed):
speed = speed if speed <= 0 else 0
possible_speed = speed - self.acceleration
possible_speed = possible_speed if possible_speed >= - \
self.max_speed else - self.max_speed
next_pos = [pos.x, pos.y]
next_pos[searched_item] += possible_speed
pos = c.Position(next_pos[0], next_pos[1])
y1 = funcs[0][0](pos.y)
x1 = funcs[0][1](pos.x)
y2 = funcs[1][0](pos.y)
x2 = funcs[1][1](pos.x)
if not (gamefield[y1][x1].is_passable(self)
and gamefield[y2][x2].is_passable(self)):
pos = self.position.position
possible_speed = math.floor(
pos[searched_item]) - pos[searched_item]
return possible_speed
def test_position(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(c.Position(22.3, 34.5), movable.position)
movable.position = c.Position(12.3, 14.5)
self.assertEqual(c.Position(12.3, 14.5), movable.position)
self.assertEqual(c.Position(12, 14), movable.rounded_pos)
def test_right_x(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(23, movable.right_x)
def test_wall_mutable_image_name_exists(self):
self.image_name_exists(
wm.Wall_Mutable(c.Position(1, 1),
exive.ExplosionType.T1).image_name)
def test_points(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(movable.points, 0)
movable.add_points(5)
self.assertEqual(movable.points, 5)
def test_movable_down_move(self):
self.gamefield.bomberman.move_down()
self.movable_move(
0, c.Position(1, 1 + self.gamefield.bomberman.acceleration))
def test_bomb_bonus_picking(self):
self.gamefield.gamefield[1][1] = bb.Bomb_bonus(c.Position(1, 1))
self.gamefield.make_moves()
self.assertEqual(self.gamefield.bomberman.bombs_count, 2)
def test_explosion_image_name_exists(self):
self.image_name_exists(ex.Explosion(c.Position(1, 1)).image_name)
def test_movable_right_move(self):
self.gamefield.bomberman.move_right()
self.movable_move(
0, c.Position(1 + self.gamefield.bomberman.acceleration, 1))
def test_bomb_bonus_image_name_exists(self):
self.image_name_exists(bb.Bomb_bonus(c.Position(1, 1)).image_name)
def position(self, position):
self._position = position
self.rounded_pos = c.Position(round(self._position.x),
round(self._position.y))
def create_wall_line(gamefield, width):
field_line = []
for i in range(width):
field_line.append(wi.Wall_Immutable(c.Position(i, len(gamefield))))
gamefield.append(field_line)
def test_speed_bonus_picking(self):
self.gamefield.gamefield[1][1] = sb.Speed_bonus(c.Position(1, 1))
self.gamefield.make_moves()
self.assertEqual(self.gamefield.bomberman.max_speed, 0.12 * 1.15)
def test_range_bonus_picking(self):
self.gamefield.gamefield[1][1] = rb.Range_bonus(c.Position(1, 1))
self.gamefield.make_moves()
self.assertEqual(self.gamefield.bomberman.bomb_range, 2)
def test_top_y(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(34, movable.top_y)
def test_range_bonus_image_name_exists(self):
self.image_name_exists(rb.Range_bonus(c.Position(1, 1)).image_name)
def test_bot_y(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(35, movable.bot_y)
def test_speed_bonus_image_name_exists(self):
self.image_name_exists(sb.Speed_bonus(c.Position(1, 1)).image_name)
def test_movable_up_move(self):
self.gamefield.bomberman.move_up()
self.movable_move(0, c.Position(1, 1))
def test_wall_immutable_image_name_exists(self):
self.image_name_exists(wi.Wall_Immutable(c.Position(1, 1)).image_name)
def test_rounded_pos(self):
movable = m.Movable(c.Position(22.3, 34.5), 0.1, 0.03)
self.assertEqual(movable.rounded_pos.x, round(movable.x))
self.assertEqual(movable.rounded_pos.y, round(movable.y))
def test_alt_move_down(self):
self.gamefield.bomberman.move_right()
self.gamefield.make_moves()
self.gamefield.bomberman.stop_moving_right()
self.gamefield.bomberman.move_down()
self.movable_move(0, c.Position(1, 1))
