def test_messages_encoding_decoding_padding(): messages = [] messages.append({ "from": 123, "from_location": np.array([1.0, 2.0, 0.0]), "message": 0.5 }) messages.append({ "from": 125, "from_location": np.array([991.0, -22.0, 0.0]), "message": "malus" }) messages.append({ "from": 128, "from_location": np.array([-1.0, -200000000.0, 0.0]), "message": 0.67 }) required_number = 5 encoded = encode_messages(messages=messages, required_number_of_messages=required_number) decoded = decode_messages(encoded_messages=encoded) assert (len(decoded) == len(messages)) for i in range(len(messages)): message = messages[i] decoded_message = decoded[i] for key in message: assert_approx_equal(message[key], decoded_message[key])
def test_monkey_flees_wolf(): my_world = World(agent_health_decline=0.0, malus_propability=0.0) my_world.add(new_monkey(), position=np.array([7.0, 0.0, 0.0])) my_world.add(new_wolf(), position=np.array([0.0, 0.0, 0.0])) for i in range(100): my_world.run(time_delta=0.1) assert (len(my_world.things) == 0) assert (len(my_world.agents) == 2) assert_approx_equal(my_world.agents[0].health, my_world.agents[0].default_health) assert_approx_equal(my_world.agents[1].health, my_world.agents[1].default_health)
def test_message_encoding(): message = { "from": 123, "from_location": np.array([1.0, 2.0, 0.0]), "message": 0.4 } encoded = _encode_message(message=message) assert (encoded.shape[0] == _length_of_message) assert_approx_equal(encoded[0], message["from"]) assert_approx_equal(encoded[1], message["from_location"][0]) assert_approx_equal(encoded[2], message["from_location"][1]) assert_approx_equal(encoded[3], message["message"])
def test_real_message_scenario(): my_world = World(agent_health_decline=0.0, malus_propability=0.0) my_world.add(new_monkey(), position=np.array([1.0, 0.0, 0.0])) my_world.add(new_monkey(), position=np.array([2.0, 2.0, 0.0])) for i in range(1): my_world.run(time_delta=0.1) messages1 = my_world.agents[0].messages assert (len(messages1) > 0) required_number = 5 encoded = encode_messages(messages=messages1, required_number_of_messages=required_number) decoded = decode_messages(encoded_messages=encoded) assert (len(decoded) == len(messages1)) for i in range(len(messages1)): message = messages1[i] decoded_message = decoded[i] for key in message: assert_approx_equal(message[key], decoded_message[key])
def test_messages_encoding_padding(): messages = [] messages.append({ "from": 123, "from_location": np.array([1.0, 2.0, 0.0]), "message": "0.6" }) messages.append({ "from": 125, "from_location": np.array([991.0, -22.0, 0.0]), "message": "malus" }) messages.append({ "from": 128, "from_location": np.array([-1.0, -200000000.0, 0.0]), "message": "fubar" }) required_number = 5 encoded = encode_messages(messages=messages, required_number_of_messages=required_number) assert (encoded.shape[0] == _length_of_message * required_number) assert_approx_equal(encoded[0], messages[0]["from"]) assert_approx_equal(encoded[1], messages[0]["from_location"][0]) assert_approx_equal(encoded[2], messages[0]["from_location"][1]) assert_approx_equal(encoded[3], float(messages[0]["message"])) assert_approx_equal(encoded[4], messages[1]["from"]) assert_approx_equal(encoded[5], messages[1]["from_location"][0]) assert_approx_equal(encoded[6], messages[1]["from_location"][1]) assert_approx_equal(encoded[7], _message_encoding_malus) assert_approx_equal(encoded[8], messages[2]["from"]) assert_approx_equal(encoded[9], messages[2]["from_location"][0]) assert_approx_equal(encoded[10], messages[2]["from_location"][1]) assert_approx_equal(encoded[11], _message_encoding_default) # assert(encoded[0] == messages[0]["from"]) # assert(encoded[1] == messages[0]["from_location"][0]) # assert(encoded[2] == messages[0]["from_location"][1]) # assert(encoded[3] == float(messages[0]["message"])) # assert(encoded[4] == messages[1]["from"]) # assert(encoded[5] == messages[1]["from_location"][0]) # assert(encoded[6] == messages[1]["from_location"][1]) # assert(encoded[7] == _message_encoding_malus) # assert(encoded[8] == messages[2]["from"]) # assert(encoded[9] == messages[2]["from_location"][0]) # assert(encoded[10] == messages[2]["from_location"][1]) # assert(encoded[11] == _message_encoding_default) assert (np.sum(encoded[12:]) == 0.0)
def test_messages_encoding(): messages = [] messages.append({ "from": 123, "from_location": np.array([1.0, 2.0, 0.0]), "message": 0.4 }) messages.append({ "from": 125, "from_location": np.array([991.0, -22.0, 0.0]), "message": "malus" }) messages.append({ "from": 128, "from_location": np.array([-1.0, -200000000.0, 0.0]), "message": "lol" }) encoded = encode_messages(messages=messages) assert (encoded.shape[0] == _length_of_message * len(messages)) assert_approx_equal(encoded[0], messages[0]["from"]) assert_approx_equal(encoded[1], messages[0]["from_location"][0]) assert_approx_equal(encoded[2], messages[0]["from_location"][1]) assert_approx_equal(encoded[3], messages[0]["message"]) assert_approx_equal(encoded[4], messages[1]["from"]) assert_approx_equal(encoded[5], messages[1]["from_location"][0]) assert_approx_equal(encoded[6], messages[1]["from_location"][1]) assert_approx_equal(encoded[7], _message_encoding_malus) assert_approx_equal(encoded[8], messages[2]["from"]) assert_approx_equal(encoded[9], messages[2]["from_location"][0]) assert_approx_equal(encoded[10], messages[2]["from_location"][1]) assert_approx_equal(encoded[11], _message_encoding_default)
def test_wolf_encoding_with_accel_action(): agent = new_wolf() agent.last_action = action_accelerate(direction=random_position()) perception = [agent] encoded_perception = encode_perception(perception=perception) expected_length = _encoding_length( properties_to_encode=properties_to_encode) assert (encoded_perception.shape[0] == expected_length) assert_approx_equal(encoded_perception[0], agent.health) assert_approx_equal(encoded_perception[1], agent.malus) assert_approx_equal(encoded_perception[2], agent.max_speed) assert_approx_equal(encoded_perception[3], agent.position[0]) assert_approx_equal(encoded_perception[4], agent.position[1]) assert_approx_equal(encoded_perception[5], agent.strength) assert_approx_equal(encoded_perception[6], _encode_type_properties(agent.type_properties)) assert_approx_equal(encoded_perception[8], agent.velocity[0]) assert_approx_equal(encoded_perception[9], agent.velocity[1]) assert_approx_equal(encoded_perception[10], agent.action_cooldown) assert_approx_equal(encoded_perception[12], 1.0) assert_approx_equal(encoded_perception[15], 1.0)
def test_grass_encoding(): thing = new_grass() perception = [thing] encoded_perception = encode_perception(perception=perception) expected_length = _encoding_length( properties_to_encode=properties_to_encode) assert (encoded_perception.shape[0] == expected_length) assert_approx_equal(encoded_perception[0], thing.health) assert_approx_equal(encoded_perception[1], thing.malus) assert_approx_equal(encoded_perception[2], thing.max_speed) assert_approx_equal(encoded_perception[3], thing.position[0]) assert_approx_equal(encoded_perception[4], thing.position[1]) assert_approx_equal(encoded_perception[5], thing.strength) assert_approx_equal(encoded_perception[6], _encode_type_properties(thing.type_properties)) assert_approx_equal(encoded_perception[8], thing.velocity[0]) assert_approx_equal(encoded_perception[9], thing.velocity[1]) assert_approx_equal(np.sum(encoded_perception[10:]), 0.0)
def test_agent_perception_encode_decode(): agent = new_sheep() perception = [agent] encoded_perception = encode_perception(perception=perception, expected_number_perceptions=5) decoded_perception = decode_perception( encoded_perception=encoded_perception) assert (len(decoded_perception) == len(perception)) assert (len(decoded_perception) == 1) decoded_agent = decoded_perception[0] assert_approx_equal(agent.health, decoded_agent.health) assert_approx_equal(agent.malus, decoded_agent.malus) assert_approx_equal(agent.max_speed, decoded_agent.max_speed) assert_approx_equal(agent.position, decoded_agent.position) assert_approx_equal(agent.strength, decoded_agent.strength) assert_approx_equal(agent.type_properties, decoded_agent.type_properties) assert_approx_equal(agent.velocity, decoded_agent.velocity) assert_approx_equal(agent.action_cooldown, decoded_agent.action_cooldown) assert_approx_equal(agent.last_action, decoded_agent.last_action) assert_approx_equal(agent.last_cause, decoded_agent.last_cause)
def test_thing_perception_encode_decode(): thing = new_stone() perception = [thing] encoded_perception = encode_perception(perception=perception, expected_number_perceptions=5) decoded_perception = decode_perception( encoded_perception=encoded_perception) assert (len(decoded_perception) == len(perception)) assert (len(decoded_perception) == 1) decoded_thing = decoded_perception[0] assert_approx_equal(thing.health, decoded_thing.health) assert_approx_equal(thing.malus, decoded_thing.malus) assert_approx_equal(thing.max_speed, decoded_thing.max_speed) assert_approx_equal(thing.position, decoded_thing.position) assert_approx_equal(thing.strength, decoded_thing.strength) assert_approx_equal(thing.type_properties, decoded_thing.type_properties) assert_approx_equal(thing.velocity, decoded_thing.velocity)
def test_monkey_encoding_padding(): agent = new_monkey() perception = [agent] encoded_perception = encode_perception(perception=perception, expected_number_perceptions=5) expected_length = _encoding_length( properties_to_encode=properties_to_encode) assert (encoded_perception.shape[0] == 5 * expected_length) assert_approx_equal(encoded_perception[0], agent.health) assert_approx_equal(encoded_perception[1], agent.malus) assert_approx_equal(encoded_perception[2], agent.max_speed) assert_approx_equal(encoded_perception[3], agent.position[0]) assert_approx_equal(encoded_perception[4], agent.position[1]) assert_approx_equal(encoded_perception[5], agent.strength) assert_approx_equal(encoded_perception[6], _encode_type_properties(agent.type_properties)) assert_approx_equal(encoded_perception[8], agent.velocity[0]) assert_approx_equal(encoded_perception[9], agent.velocity[1]) assert_approx_equal(encoded_perception[10], agent.action_cooldown) assert_approx_equal(np.sum(encoded_perception[12:]), 0.0)
def test_monkey_encoding_with_malus_action(): agent = new_ape() agent.last_action = action_remove_malus() perception = [agent] encoded_perception = encode_perception(perception=perception) expected_length = _encoding_length( properties_to_encode=properties_to_encode) assert (encoded_perception.shape[0] == expected_length) assert_approx_equal(encoded_perception[0], agent.health) assert_approx_equal(encoded_perception[1], agent.malus) assert_approx_equal(encoded_perception[2], agent.max_speed) assert_approx_equal(encoded_perception[3], agent.position[0]) assert_approx_equal(encoded_perception[4], agent.position[1]) assert_approx_equal(encoded_perception[5], agent.strength) assert_approx_equal(encoded_perception[6], _encode_type_properties(agent.type_properties)) assert_approx_equal(encoded_perception[8], agent.velocity[0]) assert_approx_equal(encoded_perception[9], agent.velocity[1]) assert_approx_equal(encoded_perception[10], agent.action_cooldown) # assert(encoded_perception[0] == agent.health) # assert(encoded_perception[1] == agent.malus) # assert(encoded_perception[2] == agent.max_speed) # assert(encoded_perception[3] == agent.position[0]) # assert(encoded_perception[4] == agent.position[1]) # assert(encoded_perception[5] == agent.strength) # assert(encoded_perception[6] == _encode_type_properties(agent.type_properties)) # assert(encoded_perception[8] == agent.velocity[0]) # assert(encoded_perception[9] == agent.velocity[1]) # assert(encoded_perception[10] == agent.action_cooldown) assert (np.sum(encoded_perception[12:]) > 0.0)