def test_bad_direction(self): '''Sends an invalid direction as arguments.''' robot_id = "test_bad_direction_18445" robot = Robot(robot_id, "123") world = World() action_manager = ActionManager() database = MemcachedDatabase() world.add_robot(robot, (12, 6)) database.commit() with self.assertRaises(InvalidArgumentsError): action_manager.do_action("123", "move", [robot_id, "U"]) database.rollback() with self.assertRaises(InvalidArgumentsError): action_manager.do_action("123", "move", [robot_id, 988]) database.rollback() with self.assertRaises(InvalidArgumentsError): action_manager.do_action("123", "move", [robot_id, None]) database.rollback() with self.assertRaises(InvalidArgumentsError): action_manager.do_action("123", "move", [robot_id]) database.rollback()
def setUpClass(cls): # Creating a robot that all the tests will use. database = MemcachedDatabase() world = World() robot = Robot(TestGiveBirth.ROBOT_ID, "123") world.add_robot(robot, (0, 14)) database.commit()
def get_static_map(self): message = self.get_byte_message(Action.MAP, {"layer": 0}) self.sock.send(message) code, answer = self.get_response(Response.FULL, 10) if code == Result.OKEY: self.world = World(answer) return code, answer
def test_bad_location(self): '''Tests planting on an invalid location.''' world = World() new_plant = Plant() with self.assertRaises(InvalidLocationError): world.plant(new_plant, (1881, 1998))
def test_water_level(self): '''Tests if water level increases after watering.''' database = MemcachedDatabase() world = World() robot = Robot("198.1287.fkdfjei", "123") robot.set_location((5, 0)) robot.set_has_water(True) plant = Plant() plant.set_water_level(30) world.plant(plant, (5, 0)) database.commit() action = WaterAction() action.do_action(robot, ["198.1287.fkdfjei"]) database.commit() updated_square = world.get_square((5, 0)) plant = updated_square.get_plant() # Checking if honor increased. self.assertEqual(robot.get_honor(), 1) self.assertEqual(plant.get_water_level(), 100) self.assertFalse(robot.get_has_water())
def test_plant(self): '''Tests sensing a plant.''' world = World() database = MemcachedDatabase() new_robot = Robot("poeiekfm98871", "123") plant = Plant() plant.set_age(12) plant.set_water_level(60) world.plant(plant, (11, 4)) database.commit() world.add_robot(new_robot, (11, 4)) database.commit() action_manager = ActionManager() info = action_manager.do_action(new_robot.get_password(), "sense", [new_robot.get_id()]) self.assertEqual( info["11,4"], { "surface_type": MapSquareTypes.SOIL, "robot": True, "plant": { "age": 12, "water_level": 60, "matured": True } })
def configureWorld(self, ): """Configures the world. """ # Create a new world self._world = World(self) # Fill the world with data from the configuration file self._world.readConfigurationFile(self._filename)
def main2(): world_height, world_width = 15, 15 world = World(world_width, world_height) agent = Agent(world) world.place_agent(agent) app = Application(world, agent) app.start()
def setUpClass(cls): # Addin a robot to the world. All the tests would use this robot. robot = Robot(cls.ROBOT_ID, "123") world = World() world.add_robot(robot, cls.LOCATION) database = MemcachedDatabase() database.commit()
def test_non_soil_location(self): '''Tests planting on a non-soil location.''' world = World() new_plant = Plant() with self.assertRaises(CannotPlantHereError): world.plant(new_plant, (2, 16)) with self.assertRaises(CannotPlantHereError): world.plant(new_plant, (3, 16))
def test_world_init_cell_in_correct_state2(): rows = [] rows.append([1, 0, 0, 1]) rows.append([0, 0, 1, 1]) board = [] board.append(rows[0]) board.append(rows[1]) world = World(board) cell = world.cell_at(1, 2) assert cell.alive == True
def create_world(world_id): # world_json = json_message_converter.convert_json_to_ros_message(world_req) # world_data = json.loads(world_json) if world_id.data in worlds: return rospy.loginfo('Creating world: {}'.format(world_id.data)) worlds[world_id.data] = World(world_id=world_id.data, world_init_prop="stub")
def init(self): parser = argparse.ArgumentParser() parser.add_argument('--width', type=int) parser.add_argument('--height', type=int) self.dimensions = parser.parse_args() self.clear_pixel_map() self.world = World(self.dimensions) self.world.create_world()
def __init__(self): pg.init() pg.mouse.set_cursor(*CURSOR) self._camera = Camera() self._hotbar = Hotbar() self._world = World() self._main_player = Player("main_player", spawn_pos=PLAYER_DEFAULT_SPAWN_POS) self._action = GameAction.play
def __init__(self): self._world = World() configs = Configs() self._result = { 'world_size': '{0},{1}'.format(*self._world.get_size()), 'plant_max_age': configs.get_plant_max_age(), 'plant_matured_age': configs.get_plant_matured_age(), 'action_delay': configs.get_robots_actions_delay(), 'maximum_energy': configs.get_robots_maximum_energy(), 'birth_required_honor': configs.get_robots_birth_required_honor() }
def test_duplicate(self): '''Tests planting twice on a location.''' world = World() new_plant = Plant() world.plant(new_plant, (4, 16)) MemcachedDatabase().commit() with self.assertRaises(AlreadyPlantError): world.plant(new_plant, (4, 16))
def __init__(self): log("Building world...") self.world = World() # This warning is bunk, we want the autocomplete log("Initializing server...") self.socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket_server.bind((const.SERVER_HOST, const.SERVER_PORT)) self.socket_server.listen(const.SERVER_NUM_CONNECTIONS) log("Server's listening!")
def test_blocking_object(self): '''Tests moving toward a blocking object.''' robot_id = "test_invalid_location_8765112" robot = Robot(robot_id, "123") world = World() action_manager = ActionManager() database = MemcachedDatabase() world.add_robot(robot, (11, 6)) database.commit() with self.assertRaises(LocationIsBlockedError): action_manager.do_action("123", "move", [robot_id, "W"])
def test_directions(self): '''Tests if moving in different directions works correctly.''' robot_id = "test_directions_154332" robot = Robot(robot_id, "123") world = World() database = MemcachedDatabase() world.add_robot(robot, (10, 2)) database.commit() action_manager = ActionManager() action_manager.do_action("123", "move", [robot_id, "N"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (10, 1)) action_manager.do_action("123", "move", [robot_id, "NE"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (11, 0)) action_manager.do_action("123", "move", [robot_id, "E"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (12, 0)) action_manager.do_action("123", "move", [robot_id, "SE"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (13, 1)) action_manager.do_action("123", "move", [robot_id, "S"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (13, 2)) action_manager.do_action("123", "move", [robot_id, "SW"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (12, 3)) action_manager.do_action("123", "move", [robot_id, "W"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (11, 3)) action_manager.do_action("123", "move", [robot_id, "NW"]) database.commit() robot = database.get_robot(robot_id) self.assertEqual(robot.get_location(), (10, 2))
class Simulator(): def __init__(self, x, y): self.board = board_creator.randomstate(x,y) def get_board_size(self): return [len(self.board), len(self.board[0])] if __name__ == '__main__': board = board_creator.randomstate(40,150) world = World(board) while True: board_creator.render_world(world.world) world.next_day() print('-----------------------------------------------------------------------------------------------------')
def extract(self) -> None: """Extract the worlds data""" tbody = self._extract_tbody(self._text) parser = WorldListParser() parser.feed(tbody) parser.close() worlds_data = parser.get_results() worlds = [] for world_data in worlds_data: world = World(world_data) worlds.append(world) self._worlds = worlds
def generate(self) -> World: _log.info("Starting world generation...") zones = [] zones_left = self.count while zones_left > 0: if not zones: gen_bottom_left = v2( _worldgen_round(-self.min_size.x * 0.75, self.round_to), _worldgen_round(-self.min_size.y * 0.75, self.round_to)) gen_top_right = v2( _worldgen_round(self.min_size.x * 0.75, self.round_to), _worldgen_round(self.min_size.y * 0.75, self.round_to)) generated_zone = Zone("starting-room", gen_bottom_left, gen_top_right) else: gen_width = _worldgen_round( randint(self.min_size.x, self.max_size.x), self.round_to) gen_height = _worldgen_round( randint(self.min_size.y, self.max_size.y), self.round_to) # legacy docs below: pypy doesn't have a 3.6 version, so choices() doesn't exist # choices() allows weighting # by default, k=1, so choices() will only have 1 element (safe to just use [0]) # the weighting I chose to use was just using the amount of open neighbors to the 10th # why to the 10th? I want a significantly less chance of it picking a zone with 3 neighbors as opposed # to one with just 1 neighbor. obviously, I should probably just use squared or something # but I really _really_ don't want 4-way corridors. random_parent_zone = choice(zones) open_directions = random_parent_zone.get_open_directions() if not open_directions: continue random_direction = choice(open_directions) offset_func = choice(_WORLDGEN_OFFSET[random_direction]) bottom_left, top_right = offset_func(random_parent_zone, gen_width, gen_height, 0) generated_zone = Zone("zone-%d" % (self.count - zones_left), bottom_left, top_right) # if we generated an overlap, just discard it and generate another one if _worldgen_has_collision(zones, generated_zone): continue random_parent_zone.neighbors[random_direction] = generated_zone generated_zone.neighbors[ ~random_direction] = random_parent_zone zones.append(generated_zone) zones_left -= 1 _log.info("Finished world generation!") return World(zones)
def test_invalid_square(self): '''Tries to load a file which contains an invalid square number.''' with NewWorld(): map_data = ("00122\n" "11332\n" "12400\n" "00112\n") temp_map_fd, temp_map_file_path = tempfile.mkstemp() os.write(temp_map_fd, map_data.encode('utf-8')) os.close(temp_map_fd) with self.assertRaises(InvalidWorldFileError): world = World() world.load_from_file(temp_map_file_path)
def test_moving_outside(self): '''Tests moving a robot to outside of the world.''' robot_id = "test_moving_outside_981165" robot = Robot(robot_id, "123") world = World() action_manager = ActionManager() database = MemcachedDatabase() world.add_robot(robot, (14, 2)) database.commit() with self.assertRaises(InvalidLocationError): action_manager.do_action("123", "move", [robot_id, "E"]) database.rollback()
def test_out_of_water(self): '''Tests if plant die after running out of water.''' plant = Plant() world = World() database = MemcachedDatabase() world.plant(plant, (4, 8)) database.commit() # Waiting for 11 cycles. time.sleep(11 * 0.03) square = world.get_square((4, 8), for_update=False) self.assertIsNone(square.get_plant())
def test_invalid_length(self): '''Tests with a file that one of it's row's length is invalid.''' with NewWorld(): map_data = ("00122\n" "11332\n" "123000\n" "00112\n") temp_map_fd, temp_map_file_path = tempfile.mkstemp() os.write(temp_map_fd, map_data.encode('utf-8')) os.close(temp_map_fd) with self.assertRaises(InvalidWorldFileError): world = World() world.load_from_file(temp_map_file_path)
def test_locked(self): '''Tests with a locked square.''' database = MemcachedDatabase() world = World() robot = Robot("test_locked_robot_190083", "123") # Setting the energy to zero, so the updater tries to update the square too. robot.set_energy(0) world.add_robot(robot, (5, 9)) database.commit() world.get_square((5, 9), for_update=True) with self.assertRaises(LockAlreadyAquiredError): database.get_robot(robot.get_id(), for_update=True)
def test_out_of_life_robot(self): '''Tests when a robot ran out of life.''' database = MemcachedDatabase() world = World() robot = Robot("test_out_of_life_robot_9022", "123") robot.set_life(0) world.add_robot(robot, (0, 9)) database.commit() received_robot = database.get_robot("test_out_of_life_robot_9022", for_update=False) self.assertFalse(received_robot.get_alive()) square = world.get_square((0, 9)) self.assertIsNone(square.get_robot_id())
def test_out_of_energy_robot(self): '''Tests when a robot ran out of energy.''' database = MemcachedDatabase() world = World() robot = Robot("test_out_of_energy_robot_18773", "123") robot.set_energy(0) world.add_robot(robot, (1, 9)) database.commit() got_robot = database.get_robot("test_out_of_energy_robot_18773", for_update=False) self.assertFalse(got_robot.get_alive()) square = world.get_square((1, 9)) self.assertIsNone(square.get_robot_id())
async def wshandler(request): app = request.app ws = web.WebSocketResponse() await ws.prepare(request) # auth here # print(request.headers) if app['state']['game_is_running'] == False: app['state']['game_is_running'] = True app['world'] = World() asyncio.ensure_future(game_loop(app)) player = Player(ws) player.fov_needs_update = True app['world'].add_player(player) app['players'].append(player) await ws.send_str( json.dumps({ 'type': 'init', 'data': player.get_client_init_data() })) try: async for msg in ws: if msg.type == web.WSMsgType.text: packet = json.loads(msg.data) logger.debug(json.dumps(packet, indent=2)) if packet['type'] == 'actions': player.update(packet['data']) print("Got message %s" % msg.data) # await ws.send_str("Pressed key code: {}".format(msg.data)) elif msg.type == web.WSMsgType.close or \ msg.type == web.WSMsgType.error: print("Closed connection") break else: print(msg) except Exception as e: logger.error(e, exc_info=True) finally: await remove_player(app, player) return ws