def reset(self, lives: int, settings: dict, score: int):
self._settings = settings
self._arena = Arena((ARENA_W, ARENA_H))
self._arena.add_to_score(score)
Mountain(self._arena, (MOUNTAIN_X, MOUNTAIN_Y))
Hill(self._arena, (HILL_X, HILL_Y), self._settings['level'])
self._ground = Ground(self._arena, (GROUND_X, GROUND_Y), self._settings['difficulty'])
self._start_time = time()
self.bg_list = [Mountain, Hill, Ground]
self._time_to_generate_alien = time()
self._hero = []
self._hero.append(Rover(self._arena, (ROVER_X, ROVER_Y), 1))
if self._settings['mode'] == 'co-op':
self._hero.append(Rover(self._arena, (ROVER_2_X, ROVER_2_Y), 2))
self._start = time()
self._playtime = 80
self.hero_lives = lives
self._aliens = []
self._obstacles = []
self._type_obstacles = [Rock, Hole]
self._rand_x_bomb = 0
self._time_to_generate_bomber = time()
self._bomb_ready = False
self._second = time()
if self._settings['difficulty'] == 'Easy':
self.OBS_RANGE = 400
elif self._settings['difficulty'] == 'Normal':
self.OBS_RANGE = 300
else:
self.OBS_RANGE = 200
def test_rover_position_greater_than_plateau_should_raise_exception(self):
rover = Rover(coord=(4, 0, 'E'))
plateau = Plateau(upper_right=(3, 3), rovers=[rover])
self.assertRaises(ValueError, plateau.rover_explore)
rover = Rover(coord=(3, -1, 'E'))
plateau = Plateau(upper_right=(3, 3), rovers=[rover])
self.assertRaises(ValueError, plateau.rover_explore)
def setUp(self):
self.rover = Rover(coord=(2, 2, 'W'))
self.rover1 = Rover(coord=(1, 2, 'N'), instructions='LMLMLMLMM')
self.rover2 = Rover(coord=(3, 3, 'E'), instructions='MMRMMRMRRM')
self.expected_output_rover1 = '1 3 N'
self.expected_output_rover2 = '5 1 E'
self.expected_output = '{}\n{}\n'.format(self.expected_output_rover1,
self.expected_output_rover2)
def main():
plateau = Plateau(5, 5)
rover = Rover(1, 2, "N", plateau)
rover.run("LMLMLMLMM")
print(rover.position)
rover = Rover(3, 3, "E", plateau)
rover.run("MMRMMRMRRM")
print(rover.position)
def test_move_world():
rovers = [
Rover(Position(x=1, y=2, heading='N'), Plateau(max_x=5, max_y=5)),
Rover(Position(x=3, y=3, heading='E'), Plateau(max_x=5, max_y=5))
]
world = World(Plateau(5, 5))
world.rovers = rovers
world.instructions = ["LMLMLMLMM", "MMRMMRMRRM"]
world.follow_instructions()
assert world.rovers[0].position == Position(1, 3, 'N')
assert world.rovers[1].position == Position(5, 1, 'E')
def __init__(self):
# Rover instances
self.curiosity = Rover('curiosity')
self.opportunity = Rover('opportunity')
self.spirit = Rover('spirit')
# Flags
self.main_flag = True
self.rover_flag = True
self.choice = 0
def test_place_rover(self):
mars = Mars("5 5")
rover = Rover("1 1 N")
mars.place_rover(rover)
self.assertEqual([rover], mars.get_rovers())
rover2 = Rover("6 1 N")
mars.place_rover(rover2)
self.assertEqual([rover], mars.get_rovers())
def test_get_rover_on_position(self):
planet = Planet(5, 5)
rover = Rover(2, 1, 'N', planet)
planet.add_rover(rover)
planet.update_grid()
self.assertIsInstance(planet.get_rover_on_position(2, 1), Rover)
self.assertEqual(planet.get_rover_on_position(2, 1), rover)
rover2 = Rover(3, 5, 'S', planet)
planet.add_rover(rover2)
planet.update_grid()
self.assertEqual(planet.get_rover_on_position(3, 5), rover2)
def main(arguments: argparse.Namespace):
# Set Logging Level
logging.Logger.setLevel(system_helpers.logger,
arguments.logLevel) # DoltPy's Log Level
logger.setLevel(arguments.logLevel) # This Script's Log Level
rover: Rover = Rover(threadID=1,
name="Rover",
requested_wait_time=arguments.wait * 60,
reply=arguments.reply,
threadLock=threadLock)
archiver: Archiver = Archiver(threadID=2,
name="Archiver",
requested_wait_time=arguments.wait * 60,
commit=arguments.commit,
threadLock=threadLock)
server: WebServer = WebServer(
threadID=3, name="Analysis Server"
) # https://www.tutorialspoint.com/python3/python_multithreading.htm
# Start Archiver
if arguments.archive:
archiver.start()
# Start Rover
if arguments.rover:
rover.start()
# Start Webserver
if arguments.server:
server.start()
def test_rover_multiple_commands_ending_position():
rover = Rover()
rover.commands('mf', 'mf', 'rr', 'mb', 'rr', 'mf', 'rl')
assert rover.x == -1
assert rover.y == 1
assert rover.orientation == 'e'
print(rover)
def test_add_rover(self):
planet = Planet(2, 2)
rover = Rover(1, 2, 'N', planet)
self.assertEqual(len(planet.rovers), 0)
planet.add_rover(rover)
self.assertEqual(len(planet.rovers), 1)
def test_rover_move_when_it_can_not(self):
rover = Rover(0, 0, 'S', self.plateau)
rover.move()
self.assertEqual(rover.x, 0)
self.assertEqual(rover.y, 0)
self.assertEqual(rover.orientation, ORIENTATION_MAP['S'])
def test_rover_can_go_forward_twice_going_north():
rov = Rover(
pos=Vector(x=0, y=0), planet_size=Vector(x=10, y=10), dir=Direction.NORTH
)
rov.forward()
rov.forward()
assert rov.pos == Vector(x=0, y=2)
def test_rover_init(self):
r = Rover('Rover20', (0, 0), 'W')
self.assertEqual(r.x, 0, "init: x value wrong")
self.assertEqual(r.y, 0, "init: y value wrong")
self.assertEqual(r.name, 'Rover20', "init: name value wrong")
self.assertEqual(r.facing_diection, 'W',
"init: facing_diection value wrong")
def test_given_start_position_33_and_4x4_map(self, _, direction, command,
expectedX, expectedY):
map = PlanetMap(4, 4)
rover = Rover(map, 3, 3, direction)
rover.move([command])
self.assertEqual(rover.get_x(), expectedX)
self.assertEqual(rover.get_y(), expectedY)
def test_if_rover_was_correctly_moved_south(Rover, Plateau):
plat = Plateau(5, 5)
rover = Rover(1, 3, 'S', plat)
rover.change_position('M')
assert rover.position_y == 2
rover.change_position('M')
assert rover.position_y == 1
def test_if_rover_was_correctly_moved_east(Rover, Plateau):
plat = Plateau(5, 5)
rover = Rover(3, 3, 'E', plat)
rover.change_position('M')
assert rover.position_x == 4
rover.change_position('M')
assert rover.position_x == 5
def test_if_rover_was_correctly_moved_north(Rover, Plateau):
plat = Plateau(5, 5)
rover = Rover(1, 2, 'N', plat)
rover.change_position('M')
assert rover.position_y == 3
rover.change_position('M')
assert rover.position_y == 4
def test_if_face_was_correctly_changed_to_left(Rover, Plateau):
plat = Plateau(5, 5)
rover = Rover(1, 2, 'N', plat)
rover.change_position('L')
assert rover.face_direction == 'W'
rover.change_position('L')
assert rover.face_direction == 'S'
def test_rover_invalid_command_doesnt_move():
x, y, direction = 4, 2, "EAST"
rover = Rover(position=(x, y, direction))
with pytest.raises(ValueError):
rover.send_command("FTF")
assert rover.position == (x, y, direction)
def test_receives_position_direction_and_map(self):
map = PlanetMap(10, 10)
rover = Rover(map, 0, 0, Direction.NORTH)
self.assertIsNotNone(rover)
self.assertEqual(rover.get_x(), 0)
self.assertEqual(rover.get_y(), 0)
self.assertEqual(rover.get_direction().value, 'N')
def test_interview(current_position, instructions, new_position):
rover = Rover(current_position, Grid(5, 5))
for instruction in list(instructions):
print(rover)
if instruction == 'L' and rover.direction == 'N':
rover = rover.process_command(north_left_turn)
elif instruction == 'R' and rover.direction == 'N':
rover = rover.process_command(north_right_turn)
elif instruction == 'L' and rover.direction == 'E':
rover = rover.process_command(east_left_turn)
elif instruction == 'R' and rover.direction == 'E':
rover = rover.process_command(east_right_turn)
elif instruction == 'L' and rover.direction == 'S':
rover = rover.process_command(south_left_turn)
elif instruction == 'R' and rover.direction == 'S':
rover = rover.process_command(south_right_turn)
elif instruction == 'L' and rover.direction == 'W':
rover = rover.process_command(west_left_turn)
elif instruction == 'R' and rover.direction == 'W':
rover = rover.process_command(west_right_turn)
elif instruction == 'M' and rover.direction == 'N':
rover = rover.process_command(move_north)
elif instruction == 'M' and rover.direction == 'E':
rover = rover.process_command(move_east)
elif instruction == 'M' and rover.direction == 'S':
rover = rover.process_command(move_south)
elif instruction == 'M' and rover.direction == 'W':
rover = rover.process_command(move_west)
assert str(rover) == new_position
assert repr(rover) == f'Rover: <{new_position}>'
def test_rotation(self, _, originalDirection, command, expectedDirection):
map = PlanetMap(10, 10)
rover = Rover(map, 0, 0, originalDirection)
rover.move([command])
self.assertEqual(rover.get_y(), 0)
self.assertEqual(rover.get_x(), 0)
self.assertEqual(rover.get_direction(), expectedDirection)
def create(self, plateauSize, roverPosition, roverDirection):
# Cria o plateau e o rover, e retorna o rover criado
plateau = Plateau(plateauSize[0], plateauSize[1])
rover = Rover(roverPosition[0], roverPosition[1], roverDirection,
plateau)
return rover
def test_get_instruction_error():
"""Tests calling inputting invalid coordinates to get_location()
"""
instr_strings =["l", "m", "r", "La", "L M", "M R", " LM ", "aM", "q R"]
plateau = MartianPlateau("1000 1000")
rvr = Rover("100 100 N", plateau)
for instr in instr_strings:
try:
rvr = Rover("100 100 N", plateau)
rvr.instruct(instr)
except ImproperInstruction:
assert True
else:
print instr
assert False
def test_upper_bounds(self):
rover = Rover("2 2 N", "2 2")
rover.send_instructions("M")
self.assertEqual((2, 2), rover.get_position())
rover.send_instructions("RM")
self.assertEqual((2, 2), rover.get_position())
def land_rover(self, x, y, heading, name):
"""
Land rover on a position on plateau.
Conditions:
1) The rover can not land out of plateau grid.
2) The rover can not land on a position that
there is other rover positioned (collision).
:param x: (int) x axis coordinate on plateau grid
:param y: (int) y axis coordinate on plateau grid
:param name: (str) rover identifier name ex: rover1
:return:
"""
rover = Rover()
try:
if self.plateau:
rover.land(x_pos=x, y_pos=y, heading=heading)
self.plateau.set_pos_matrix(x, y)
self.dict_rover[name] = rover
else:
raise ValueError('Plateau is required before landing')
except (CollisionException, ValueError) as ex:
rover.x_pos = None
rover.y_pos = None
raise ex
def process_rovers(self, instructions: list) -> list:
"""
Read file and load the instructions
"""
rovers = []
line_number = 1
boundaries = instructions[0].split(' ')
#interate through all rover instructions and apply it to the coordinates
while line_number < len(instructions):
start_point = instructions[line_number].split(' ')
instruction = instructions[line_number + 1].rstrip()
line_number += 2
rover = Rover(int(boundaries[0].rstrip()),
int(boundaries[1].rstrip()),
int(start_point[0].rstrip()),
int(start_point[1].rstrip()),
start_point[2].rstrip())
rover.move_to_target(instruction)
rovers.append(rover.to_dict())
return rovers
def __init__(self, input_txt_path):
with open(input_txt_path) as f:
lines = f.read().splitlines()
if not len(lines) or (len(lines) - 1) % 2 != 0:
raise ValueError('No input data')
if (re.sub(PLATEAU_LIMITS, '', lines[0])):
raise ValueError('Plateau limits data is not correct')
self.pl_limits = {
'x': int(lines[0].split(' ')[0]),
'y': int(lines[0].split(' ')[1])
}
self.rovers = list()
i = 1
while (i < len(lines)):
if re.sub(POSITION_PATTERN, '', lines[i]):
raise ValueError('Rover position data is not correct')
if re.sub(COMMANDS_PATTERN, '', lines[i + 1]):
raise ValueError('Rover commands data is not correct')
pos_ar = lines[i].split(' ')
init_pos = (pos_ar[0], pos_ar[1], pos_ar[2])
r = Rover(init_pos, lines[i + 1], self)
self.attach_rover(r)
i += 2
def test_rover_explore_with_only_move(self):
land = LandGrid(5, 5)
rover = Rover(land)
expected_position = '1 4 N'
rover.explore(1, 2, 'N', 'MM')
ending_position = rover.get_rover_position()
self.assertEqual(ending_position, expected_position)
