Port wood gathering and fix 26.3 swing animation

tests/test_break_animation.py

@@ -0,0 +1,78 @@
+import io
+import time
+import unittest
+from munch import Munch
+
+from minecraft.networking.modern import (
+    ClientTickEnd, EntityAnimationPacket, EntitySwingAnimationPacket,
+    PunchPacket,
+)
+from mosfet.game import Game
+
+
+class RecordingConnection:
+    def __init__(self):
+        self.packets = []
+
+    def write_packet(self, packet, force=False):
+        self.packets.append((packet, force))
+
+
+class BlockBreakAnimationTests(unittest.TestCase):
+    def make_game(self):
+        connection = RecordingConnection()
+        game = object.__new__(Game)
+        game.g = Munch(connection=connection, inv={}, inventory_state_ids={})
+        game.sequence = 0
+        game.break_deadline = None
+        game.breaking_state = None
+        game.next_swing_at = 0.0
+        return game, connection
+
+    def test_26_3_punch_packet_is_the_empty_serverbound_packet(self):
+        self.assertEqual(PunchPacket.id, 0x2E)
+        self.assertEqual(PunchPacket.definition, [])
+
+    def test_observer_packet_decodes_entity_id_and_swing_kind(self):
+        packet = EntityAnimationPacket()
+        packet.read(io.BytesIO(bytes((0x85, 0x01, 0))))
+        self.assertEqual(packet.entity_id, 133)
+        self.assertEqual(packet.animation, 0)
+
+    def test_26_3_observer_swing_packet_decodes_animation_details(self):
+        packet = EntitySwingAnimationPacket()
+        packet.read(io.BytesIO(bytes((0x85, 0x01, 0, 1, 6))))
+        self.assertEqual(EntitySwingAnimationPacket.id, 0x7B)
+        self.assertEqual((packet.entity_id, packet.hand,
+                          packet.animation_type, packet.duration),
+                         (133, 0, 1, 6))
+
+    def test_animate_sends_punch_before_client_tick_end(self):
+        game, connection = self.make_game()
+        game.animate()
+        self.assertEqual([type(packet) for packet, _ in connection.packets],
+                         [PunchPacket, ClientTickEnd])
+        self.assertTrue(all(force for _, force in connection.packets))
+
+    def test_breaking_sends_initial_and_periodic_punches(self):
+        game, connection = self.make_game()
+        game.g.breaking = (1, 2, 3)
+        game.break_deadline = time.monotonic() + 5
+        game.breaking_state = 10
+        game.next_swing_at = 0
+
+        game.tick()
+        self.assertEqual(sum(isinstance(packet, PunchPacket)
+                             for packet, _ in connection.packets), 1)
+        sent = len(connection.packets)
+        game.tick()
+        self.assertEqual(len(connection.packets), sent)
+
+        game.next_swing_at = 0
+        game.tick()
+        self.assertEqual(sum(isinstance(packet, PunchPacket)
+                             for packet, _ in connection.packets), 2)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_gather_wood.py

@@ -0,0 +1,82 @@
+import unittest
+from munch import Munch
+
+from mosfet.commands import Commands
+from mosfet.info import blocks, items
+from mosfet.job import JobStates
+from mosfet.world import World
+
+
+class FakeChunks:
+    def __init__(self, states):
+        self.states = states
+        self.index = {}
+
+    def get_block_at(self, x, y, z):
+        return self.states.get((x, y, z), blocks.AIR)
+
+
+class GatherWoodPortTests(unittest.TestCase):
+    def test_log_states_are_indexed_for_modern_chunk_search(self):
+        self.assertTrue(blocks.LOG_IDS)
+        self.assertTrue(blocks.LOG_IDS.issubset(blocks.INDEXED_IDS))
+
+    def test_tree_search_finds_indexed_26_3_log_states(self):
+        oak_log = blocks.MCD_BLOCKS['oak_log']['minStateId']
+        oak_leaves = blocks.MCD_BLOCKS['oak_leaves']['minStateId']
+        stone = blocks.MCD_BLOCKS['stone']['minStateId']
+        states = {
+            (0, 63, 0): stone,
+            (0, 64, 0): oak_log,
+            (0, 65, 0): oak_log,
+            (0, 66, 0): oak_log,
+            (1, 66, 0): oak_leaves,
+        }
+        chunks = FakeChunks(states)
+        chunks.index[oak_log] = {
+            (0, 64, 0), (0, 65, 0), (0, 66, 0),
+        }
+        world = World(Munch(chunks=chunks))
+        self.assertEqual(list(world.find_trees((0, 64, 0), 10)),
+                         [(0, 64, 0)])
+
+    def test_gather_wood_job_keeps_existing_machine_sequence(self):
+        job = JobStates(Munch())
+        self.assertIsNotNone(job.gather_wood_states)
+        self.assertEqual(job.gather_wood(), [
+            job.gather_wood_states,
+            job.sleep_with_bed_states,
+            job.eat_food_states,
+            job.cache_items_states,
+        ])
+        job.gather_wood_states.state = job.gather_wood_states.find_new_tree
+        job.stop()
+        self.assertIs(job.gather_wood_states.state.__func__,
+                      job.gather_wood_states.idle.__func__)
+
+    def test_gather_wood_command_is_enabled_but_farm_wood_is_not(self):
+        class FakeChat:
+            def __init__(self):
+                self.sent = []
+
+            def set_handler(self, handler):
+                self.handler = handler
+
+            def send(self, message):
+                self.sent.append(message)
+
+        job = JobStates(Munch())
+        chat = FakeChat()
+        g = Munch(name='mosfet1', chat=chat, job=job,
+                  inv={0: Munch(item_id=next(iter(items.BED_IDS)))})
+        Commands(g).handle_chat(('CHAT', 'tester', 'tester: 1gather wood'))
+        self.assertEqual(chat.sent, ['ok'])
+        self.assertIs(job.state.__func__, job.gather_wood.__func__)
+
+        chat.sent.clear()
+        Commands(g).handle_chat(('CHAT', 'tester', 'tester: 1farm wood'))
+        self.assertEqual(chat.sent, ['not migrated to Minecraft 26.3 yet'])
+
+
+if __name__ == '__main__':
+    unittest.main()