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)