Implement 26.3 food consumption

tests/test_crop_cache.py

@@ -12,14 +12,17 @@ class TestCropCaching(unittest.TestCase):
         crop_state = object()
         cache_state = Munch(silent=False)
         sleep_state = Munch(silent=False)
+        eat_state = object()
         jobs = JobStates.__new__(JobStates)
         jobs.gather_crop_states = crop_state
         jobs.cache_items_states = cache_state
         jobs.sleep_with_bed_states = sleep_state
+        jobs.eat_food_states = eat_state
 
         try:
             machines = JobStates.farm_crop(jobs)
-            self.assertEqual(machines, [crop_state, sleep_state, cache_state])
+            self.assertEqual(
+                machines, [crop_state, sleep_state, eat_state, cache_state])
             self.assertTrue(cache_state.silent)
             self.assertTrue(sleep_state.silent)
             self.assertTrue({

tests/test_eat_food.py

@@ -0,0 +1,99 @@
+import unittest
+
+from munch import Munch
+from minecraft.networking.modern import ClientTickEnd
+from minecraft.networking.packets import PacketBuffer
+
+from mosfet.game import Game
+from mosfet.info import items
+from mosfet.jobs.eat_food import EatFoodStates
+from mosfet.protocol.modern import UseItemPacket
+from mosfet.protocol.types import Slot
+
+
+class FakeConnection:
+    def __init__(self):
+        self.packets = []
+
+    def write_packet(self, packet, force=False):
+        self.packets.append((packet, force))
+
+
+class FakeGame:
+    def __init__(self, state):
+        self.state = state
+        self.used_hands = []
+
+    def select_item(self, item_ids):
+        for slot, item in self.state.g.inv.items():
+            if item.present and item.item_id in item_ids:
+                self.state.g.holding = item.item_id
+                self.state.g.holding_hand = 0
+                self.state.g.holding_slot = slot - 36
+                return True
+        return False
+
+    def use_item(self, hand=0):
+        self.used_hands.append(hand)
+
+
+class TestEatFood(unittest.TestCase):
+    def test_use_item_packet_encodes_hand_sequence_and_rotation(self):
+        packet = UseItemPacket(hand=1, sequence=300, yaw=90.0, pitch=-30.0)
+        buffer = PacketBuffer()
+        packet.write_fields(buffer)
+        self.assertEqual(packet.id, 0x43)
+        self.assertEqual(buffer.get_writable(), bytes.fromhex(
+            '01ac0242b40000c1f00000'))
+
+    def test_game_use_item_sends_packet_and_tick_end(self):
+        connection = FakeConnection()
+        game = Game.__new__(Game)
+        game.g = Munch(connection=connection, yaw=45.0, pitch=-5.0)
+        game.sequence = 0
+
+        game.use_item(1)
+
+        packet, forced = connection.packets[0]
+        self.assertIsInstance(packet, UseItemPacket)
+        self.assertEqual((packet.hand, packet.sequence,
+                          packet.yaw, packet.pitch), (1, 1, 45.0, -5.0))
+        self.assertTrue(forced)
+        self.assertIsInstance(connection.packets[1][0], ClientTickEnd)
+
+    def test_eat_uses_authoritative_hunger_and_waits_for_confirmation(self):
+        food_id = next(iter(items.FOOD_IDS))
+        state = EatFoodStates(Munch(
+            food=8, health=20.0, food_saturation=0.0,
+            inv={36: Slot(True, food_id, 3)}, holding_hand=0,
+            holding_slot=0, job=None))
+        fake_game = FakeGame(state)
+        state.g.game = fake_game
+
+        state.init()
+        self.assertEqual(state.state, state.select_food)
+        state.select_food()
+        self.assertEqual(state.state, state.wait_for_selection)
+        state.wait_for_selection()
+        self.assertEqual(state.state, state.eat_food)
+        state.eat_food()
+        self.assertEqual(fake_game.used_hands, [0])
+        self.assertEqual(state.state, state.wait)
+
+        # Don't declare success until the server sends a hunger/saturation
+        # update or confirms that it consumed the selected stack.
+        state.wait()
+        self.assertEqual(state.state, state.wait)
+        state.g.food = 16
+        state.g.food_saturation = 4.0
+        state.wait()
+        self.assertEqual(state.state, state.cleanup)
+
+    def test_no_hunger_packet_does_not_eat(self):
+        state = EatFoodStates(Munch(food=None, health=None))
+        state.init()
+        self.assertEqual(state.state, state.cleanup)
+
+
+if __name__ == '__main__':
+    unittest.main()