Esempio n. 1
0
    def test_whenHashingMonsterWithSamePosition_thenHashesAreTheSame(self):
        monster_1 = NormalMonster(Position(X_1, Y_1), SOME_ENERGY,
                                  RANGE_OF_MOTION, MONSTER_NAME)
        monster_2 = NormalMonster(Position(X_1, Y_1), SOME_ENERGY,
                                  RANGE_OF_MOTION, MONSTER_NAME)

        self.assertEqual(hash(monster_1), hash(monster_2))
Esempio n. 2
0
def run_simulation(socket: SocketIO):
    random.seed(time())
    monsters = generate_world_elements(
        lambda position_energy: NormalMonster(*position_energy, 1,
                                              "SlowMonster"),
        randint(5, 15),
    )
    fast_monsters = generate_world_elements(
        lambda position_energy: NormalMonster(*position_energy, 2,
                                              "FastMonster"),
        randint(5, 15),
    )
    for monster in fast_monsters:
        monsters.add(monster)

    foods = generate_world_elements(
        lambda position_energy: Food(*position_energy), randint(90, 100))
    world = World(monsters, foods, world_map_constructor(socket))
    for turn in range(500):
        if turn % 50 == 0:
            foods = generate_world_elements(
                lambda position_energy: Food(*position_energy),
                randint(20, 30))
            for food in foods:
                world.foods.add(food)
        world.play_one_day()
        world.display()
        sleep(0.5)
Esempio n. 3
0
    def test_givenMonsterWantsToMoveIntoAnOccupiedPosition_whenPlayingTurn_thenMonsterDoesntMove(
            self):
        monster = NormalMonster(SOME_POSITION, SOME_ENERGY, RANGE_OF_MOTION,
                                MONSTER_NAME)
        self.monsters_mock.move.side_effect = PositionAlreadyOccupied

        monster.play_turn(self.monsters_mock, WorldElements(set()))

        self.monsters_mock.move.assert_called_once()
Esempio n. 4
0
    def test_givenMonsterDoesntHaveEnoughEnergyToMove_whenPlayingTurn_thenMonsterDies(
            self):
        monster = NormalMonster(SOME_POSITION, SOME_ENERGY, RANGE_OF_MOTION,
                                MONSTER_NAME)
        self.monsters_mock.move.side_effect = NotEnoughEnergyToMove

        monster.play_turn(self.monsters_mock, WorldElements(set()))

        self.monsters_mock.remove.assert_called_once_with(monster)
Esempio n. 5
0
    def test_givenNoFoodsSurroundingMonster_whenPlayingTurn_thenMonsterMovesAnyWhere(
            self):
        monster = NormalMonster(SOME_POSITION, SOME_ENERGY, RANGE_OF_MOTION,
                                MONSTER_NAME)

        monster.play_turn(self.monsters_mock, WorldElements(set()))

        self.monsters_mock.move.assert_called_once_with(
            monster, Not(Position(0, 0)), SOME_ENERGY)
Esempio n. 6
0
    def test_givenFoodSurroundingMonster_whenPlayingTurn_thenMonsterMoveTowardFood(
            self):
        food = Food(SOME_POSITION + DELTA_POSITION_WITHIN_RANGE, SOME_ENERGY)
        monster = NormalMonster(SOME_POSITION, SOME_ENERGY, RANGE_OF_MOTION,
                                MONSTER_NAME)

        monster.play_turn(self.monsters_mock, WorldElements({food}))

        expected_movement = food.delta_position_from(monster.position)
        self.monsters_mock.move.assert_called_once_with(
            monster, expected_movement, SOME_ENERGY)
Esempio n. 7
0
    def test_givenDeltaPosition_whenMovingMonster_thenMonsterIsMovedByDeltaPosition(
            self):
        initial_position = Position(X_1, Y_1)
        delta_position = Position(X_2, Y_2)

        moved_monster = NormalMonster(initial_position, SOME_ENERGY,
                                      RANGE_OF_MOTION,
                                      MONSTER_NAME).move_by(delta_position)

        expected_monster = NormalMonster(Position(X_1 + X_2,
                                                  Y_1 + Y_2), SOME_ENERGY,
                                         RANGE_OF_MOTION, MONSTER_NAME)
        self.assertEqual(hash(expected_monster), hash(moved_monster))
Esempio n. 8
0
    def test_givenMonsterDoesntHaveChanceToReproduce_whenPlayingTurn_thenMonsterDoesntReproduces(
            self, generate_fraction):
        generate_fraction.return_value = 2 * SOME_REPRODUCTION_PROBABILITY
        enough_energy_to_reproduce = Energy(10 - 1)
        monster = NormalMonster(
            SOME_POSITION,
            enough_energy_to_reproduce,
            RANGE_OF_MOTION,
            MONSTER_NAME,
            SOME_REPRODUCTION_PROBABILITY,
        )

        monster.play_turn(self.monsters_mock, WorldElements(set()))

        self.monsters_mock.add.assert_not_called()
Esempio n. 9
0
    def test_givenNoFoodsAtMonsterPosition_whenPlayingTurn_thenMonsterDoesnGainEnergy(
            self, generate_fraction):
        generate_fraction.return_value = 2 * SOME_REPRODUCTION_PROBABILITY
        food = Food(SOME_POSITION + SOME_POSITION, SOME_ENERGY)
        monster_energy = Energy(SOME_ENERGY_VALUE)
        monster = NormalMonster(
            SOME_POSITION,
            monster_energy,
            RANGE_OF_MOTION,
            MONSTER_NAME,
            SOME_REPRODUCTION_PROBABILITY,
        )

        monster.play_turn(self.monsters_mock, WorldElements({food}))

        expected_energy = Energy(SOME_ENERGY_VALUE)
        self.assertEqual(expected_energy, monster_energy)
Esempio n. 10
0
    def test_whenMovingElement_thenElementIsmovedToNewPosition(self):
        energy = create_autospec(Energy)
        world_elements = WorldElements({A_MONSTER})

        world_elements.move(A_MONSTER, A_DELTA_POSITION, energy)

        expected_element = NormalMonster(A_POSITION + A_DELTA_POSITION,
                                         SOME_ENERGY, RANGE_OF_MOTION,
                                         MONSTER_NAME)
        self.assertIn(expected_element, world_elements)
Esempio n. 11
0
    def test_givenElementNotInRange_whenGettingSurroundingElements_thenElementNotInIterable(
            self):
        range_of_motion = 2
        a_monster_in_range = NormalMonster(
            A_POSITION + Position(range_of_motion + 1, 0),
            SOME_ENERGY,
            range_of_motion,
            MONSTER_NAME,
        )
        world_elements = WorldElements({a_monster_in_range})

        surrouding_elements = world_elements.elements_surrounding(
            A_POSITION, range_of_motion)

        self.assertNotIn(a_monster_in_range, surrouding_elements)
Esempio n. 12
0
STEP = 1

X_1 = 1
X_2 = 3
Y_1 = 2
Y_2 = 4

SOME_REPRODUCTION_PROBABILITY = 0.1
SOME_ENERGY_VALUE = 10
SOME_FOOD_ENERGY_VALUE = 15
SOME_ENERGY = Energy(SOME_ENERGY_VALUE)

RANGE_OF_MOTION = 1
MONSTER_NAME = "name"
SOME_POSITION = Position(X_1, Y_1)
A_MONSTER = NormalMonster(SOME_POSITION, SOME_ENERGY, RANGE_OF_MOTION,
                          MONSTER_NAME)
DELTA_POSITION_WITHIN_RANGE = Position(RANGE_OF_MOTION, 0)


class NormalMonsterTest(unittest.TestCase):
    def setUp(self):
        self.monsters_mock = create_autospec(WorldElements)

    def test_whenHashingMonsterWithSamePosition_thenHashesAreTheSame(self):
        monster_1 = NormalMonster(Position(X_1, Y_1), SOME_ENERGY,
                                  RANGE_OF_MOTION, MONSTER_NAME)
        monster_2 = NormalMonster(Position(X_1, Y_1), SOME_ENERGY,
                                  RANGE_OF_MOTION, MONSTER_NAME)

        self.assertEqual(hash(monster_1), hash(monster_2))