Fix submodule pointer

Author: Killklli

worlds/dk64/DK64Client.py

@@ -6,7 +6,7 @@
 
 if __name__ == "__main__":
     Utils.init_logging("DK64Context", exception_logger="Client")
-
+import json
 import asyncio
 import colorama
 import time
@@ -124,7 +124,6 @@ def check_safe_gameplay(self):
     def safe_to_send(self):
         countdown_value = self.n64_client.read_u8(self.memory_pointer + DK64MemoryMap.safety_text_timer)
         return countdown_value == 0
-
     def _getShopStatus(self, p_type: int, p_value: int, p_kong: int) -> bool:
         if p_type == 0xFFFF:
             return False
@@ -203,10 +202,16 @@ def getCheckStatus(self, check_type, flag_index=None, shop_index=None, level_ind
                     has_camera = self.readFlag(0x2FD) != 0
                     has_shockwave = self.readFlag(0x179) != 0
                     return has_camera and has_shockwave
-                return self.readFlag(target_flag) != 0
+                return self.bulk_read_dict.get(target_flag) != 0
             else:
-                return self.readFlag(flag_index) != 0
-
+                return self.bulk_read_dict.get(flag_index) != 0
+    
+    def bulk_lookup(self, flag_index):
+        if flag_index in self.flag_lookup:
+            target_flag = self.flag_lookup[flag_index]
+            self.BulkreadFlag(target_flag)
+        else:
+            self.BulkreadFlag(flag_index)
     async def readChecks(self, cb):
         """Run checks in parallel using asyncio with optimized processing."""
         new_checks = []
@@ -218,7 +223,35 @@ async def readChecks(self, cb):
         }
         shop_map = {"Cranky": 0, "Funky": 1, "Candy": 2}
         kong_map = {"Donkey": 0, "Diddy": 1, "Lanky": 2, "Tiny": 3, "Chunky": 4}
+        self.bulk_read_dict = {}
+        for id in self.remaining_checks[:]:  # Iterate over a copy to avoid modification issues
+            if self.flag_lookup is None:
+                self._build_flag_lookup()
+            name = check_id_to_name.get(id)
+            if not name:
+                continue
 
+            # Check location_name_to_flag first
+            check = location_name_to_flag.get(name)
+            if check:
+                self.bulk_lookup(check)
+
+            # Check item_ids for flag_id
+            check = item_ids.get(id)
+            if check:
+                flag_id = check.get("flag_id")
+                if flag_id:
+                    self.bulk_lookup(flag_id)
+        def byte_shift(index, val):
+            shift = index & 7
+            return (val >> shift) & 1
+        dict_data = self.n64_client.read_dict(self.bulk_read_dict)
+        # Json loads the dict_data
+        dict_data = json.loads(dict_data)
+        self.bulk_read_dict = {}
+        # For each item in the dict, the key is the index the value is the val for byte_shift. Keep the key the same but set the value to the result of byte_shift
+        for key, val in dict_data.items():
+            self.bulk_read_dict[int(key)] = byte_shift(int(key), int(val[0]))
         for id in self.remaining_checks[:]:  # Iterate over a copy to avoid modification issues
             name = check_id_to_name.get(id)
             if not name:
@@ -227,6 +260,7 @@ async def readChecks(self, cb):
             # Check location_name_to_flag first
             check = location_name_to_flag.get(name)
             if check and self.getCheckStatus("location", check):
+                print(name)
                 new_checks.append(id)
                 remove_checks.add(id)
                 continue
@@ -236,6 +270,7 @@ async def readChecks(self, cb):
             if check:
                 flag_id = check.get("flag_id")
                 if flag_id and self.getCheckStatus("location", flag_id):
+                    print(name)
                     new_checks.append(id)
                     remove_checks.add(id)
                 continue
@@ -294,6 +329,11 @@ def readFlag(self, index: int) -> int:
         offset = DK64MemoryMap.EEPROM + byte_index
         val = self.n64_client.read_u8(offset)
         return (val >> shift) & 1
+    bulk_read_dict = {}
+    def BulkreadFlag(self, index: int) -> int:
+        byte_index = index >> 3
+        offset = DK64MemoryMap.EEPROM + byte_index
+        self.bulk_read_dict[index] = offset
 
     async def wait_for_game_ready(self):
         logger.info("Waiting on game to be in valid state...")
@@ -492,7 +532,7 @@ def on_item_get(dk64_checks):
                     await self.client.validate_client_connection()
                     status = self.client.check_safe_gameplay()
                     if status == False:
-                        await asyncio.sleep(5)
+                        await asyncio.sleep(0.5)
                         continue
                     await self.client.main_tick(on_item_get, victory)
                     await asyncio.sleep(1)

worlds/dk64/DK64R

@@ -50,7 +50,57 @@ function startServer() {
                     c.write("Usage: read u8/u16/u32 0xADDRESS SIZE");
                 }
             }
-
+            else if (message.startsWith("dict")) {
+                // Remove "dict " from the beginning
+                var dict = message.substring(5);
+                try {
+                    dict = JSON.parse(dict);
+                } catch (e) {
+                    console.log(e)
+                    c.write("Invalid JSON format for dictionary");
+                    return;
+                }
+                // eg dict {"name": {"type": "u8", "adr": 0x1234, "size": 4}}
+                var result = {};
+                for (var key in dict) {
+                    var item = dict[key];
+                    // If the item is not a dict, assume we just got the address and convert it to a dict
+                    if (typeof item !== "object") {
+                        item = {"adr": item};
+                    }
+                    // If type is not defined default to u8
+                    if (!item.type) {
+                        item.type = "u8";
+                    }
+                    if (!item.size) {
+                        item.size = 1;
+                    }
+                    if (item.type === "u8") {
+                        var values = [];
+                        for (var i = 0; i < item.size; i++) {
+                            values.push(mem.u8[item.adr + i]);
+                        }
+                        result[key] = values;
+                    } else if (item.type === "u16") {
+                        var values = [];
+                        for (var i = 0; i < item.size; i += 2) {
+                            values.push(mem.u16[item.adr + i]);
+                        }
+                        result[key] = values;
+                    } else if (item.type === "u32") {
+                        var values = [];
+                        for (var i = 0; i < item.size; i += 4) {
+                            values.push(mem.u32[item.adr + i]);
+                        }
+                        result[key] = values;
+                    } else {
+                        c.write("Invalid type, use: u8, u16, u32");
+                        return;
+                    }
+                }
+                c.write(JSON.stringify(result));
+                return;
+            }
             else if (message.startsWith("write")) {
                 var parts = message.split(" ");
                 var type = parts[1];

worlds/dk64/client/adapter.js

@@ -154,8 +154,8 @@ def _send_command(self, command):
         """Sends a command to the emulator and retrieves the response."""
         try:
             self._connect()
-            self.socket.send(command.encode())
-            response = self.socket.recv(1024).decode()
+            self.socket.sendall(command.encode())
+            response = self.socket.recv(4096).decode()
             if not response:
                 raise PJ64Exception("No data received from the server")
             return response
@@ -182,12 +182,9 @@ def read_u32(self, address):
         """Reads a 32-bit unsigned integer from memory."""
         return self._read_memory(address, 4)
 
-    def read_u8_block(self, address, size):
-        """Reads an unsigned integer of the given size from memory."""
-        resp = self._send_command(f"read u8 {hex(address)} {size}")
-        # Split by commas and convert to integers
-        return [x for x in resp.split(",")]
-
+    def read_dict(self, dict):
+        """Reads a dictionary of memory addresses and returns the values."""
+        return self._send_command(f"dict {json.dumps(dict, separators=(',', ':'))}")
     def _write_memory(self, command, address, data):
         """Writes data to memory and returns the emulator response."""
         return self._send_command(f"{command} {hex(address)} [{data}]")