Port loiter and harden 26.3 bed updates

tests/test_threat_detection.py

@@ -0,0 +1,111 @@
+import unittest
+
+from munch import Munch
+
+from mosfet.commands import Commands
+from mosfet.info import blocks, mobs
+from mosfet.job import JobStates
+from mosfet.jobs.check_threats import CheckThreatsStates
+from mosfet.world import World
+
+
+class FakeChunks:
+    def __init__(self, solid=()):
+        self.solid = set(solid)
+
+    def get_block_at(self, x, y, z):
+        return blocks.STONE if (x, y, z) in self.solid else blocks.AIR
+
+
+class FakeChat:
+    def __init__(self):
+        self.handler = None
+        self.messages = []
+
+    def set_handler(self, handler):
+        self.handler = handler
+
+    def send(self, message):
+        self.messages.append(message)
+
+
+class TestThreatDetection(unittest.TestCase):
+    def test_find_threats_filters_passive_and_distant_entities(self):
+        zombie = mobs.MOBS['minecraft:zombie']['protocol_id']
+        villager = mobs.MOBS['minecraft:villager']['protocol_id']
+        world = World(Munch(mobs={
+            1: Munch(entity_id=1, type=zombie, x=3.2, y=64, z=0),
+            2: Munch(entity_id=2, type=villager, x=2, y=64, z=0),
+            3: Munch(entity_id=3, type=zombie, x=30, y=64, z=0),
+        }))
+        world.check_air_column = lambda pos, distance: True
+
+        result = world.find_threats((0, 64, 0), 12)
+
+        self.assertEqual([threat.entity_id for threat in result], [1])
+
+    def test_air_column_excludes_mobs_under_a_solid_roof(self):
+        world = World(Munch(chunks=FakeChunks(solid={(0, 67, 0)})))
+        self.assertFalse(world.check_air_column((0, 64, 0), 5))
+        self.assertTrue(world.check_air_column((2, 64, 0), 5))
+
+    def test_threat_state_falls_back_to_reachable_clear_area(self):
+        spot = (8, 64, 0)
+
+        class SafeWorld:
+            def find_blocks_indexed(self, center, block_ids, distance=0):
+                return []
+
+            def find_bed_areas(self, center, distance):
+                return [spot]
+
+            def find_threats(self, center, distance):
+                return []
+
+            def path_to_place(self, start, target):
+                return [start, target]
+
+        g = Munch(world=SafeWorld(), pos=(0, 64, 0), path=[], look_at=None)
+        state = CheckThreatsStates(g)
+        state.state = state.find_safety
+        state.threats = [Munch(entity_id=7)]
+
+        state.find_safety()
+
+        self.assertEqual(state.state, state.going_to_safety)
+        self.assertEqual(state.safety, spot)
+        self.assertFalse(state.external_safety)
+        self.assertEqual(g.path[-1], spot)
+
+        g.pos = spot
+        state.going_to_safety()
+        self.assertEqual(state.state, state.wait)
+        self.assertEqual(state.wait_time, 3)
+
+    def test_loiter_is_enabled_as_a_job(self):
+        check = object()
+        sleep = Munch(silent=False)
+        eat = object()
+        job = JobStates.__new__(JobStates)
+        job.check_threats_states = check
+        job.sleep_with_bed_states = sleep
+        job.eat_food_states = eat
+
+        self.assertEqual(JobStates.loiter(job), [check, sleep, eat])
+        self.assertTrue(sleep.silent)
+
+    def test_loiter_command_is_no_longer_rejected(self):
+        def loiter():
+            return []
+
+        chat = FakeChat()
+        job = Munch(loiter=loiter, state=None)
+        commands = Commands(Munch(name='mosfet1', chat=chat, job=job))
+        commands.handle_chat(('CHAT', 'player-uuid', 'tanner: 1loiter'))
+
+        self.assertIs(job.state, loiter)
+        self.assertEqual(chat.messages, ['ok'])
+
+
+if __name__ == '__main__':
+    unittest.main()