Blocks EHEHEHEHEHHEHEHEHEHE :3

Tycho10101 · Tycho10101 · commit a0e6a8baf1e5 · 2025-07-25T17:29:51.000-10:00
I DID IT, I SAVED THE WORLD
diff --git a/PythonWalker/__init__.py b/PythonWalker/__init__.py
@@ -2,25 +2,34 @@
 import requests
 from . import player as player_template
 from websockets.sync.client import connect as ws_conn
+from . import world
     
 def login_with_pass(email, password):
+    print("Logging in...")
     player = player_template.player()
     r = requests.post("https://api.pixelwalker.net/api/collections/users/auth-with-password", json={'identity': email, 'password': password})
     data = r.json()
     player.token = data["token"]
     record = data["record"]
     player.username = record["username"]
     player.id = record["id"]
+    print("Logged in")
     return player
 
-def connect(world_id, user, on_chat=None, on_init=None, on_join=None, on_leave=None, commands=None, custom_init=False):
+def connect(world_id, user, on_chat=None, on_init=None, on_join=None, on_leave=None, on_block=None, commands=None, custom_init=False):
+    print("Getting world type...")
     version = requests.get("https://game.pixelwalker.net/listroomtypes").json()[0]
+    print("Getting join key...")
     headers = {"Authorization": f"Bearer {user.token}"}
     r = requests.get(f"https://api.pixelwalker.net/api/joinkey/{version}/{world_id}", headers=headers)
     join_key = r.json()["token"]
     player_list = {}
+    print("Gathering block info...")
+    block_list = requests.get('https://game.pixelwalker.net/listblocks').json()
     
-    with ws_conn(f"wss://game.pixelwalker.net/ws?joinKey={join_key}") as websocket:
+    print("Connecting...")
+    with ws_conn(f"wss://game.pixelwalker.net/ws?joinKey={join_key}", max_size=None) as websocket:
+        print("Connected")
         while True:
             message = websocket.recv()
             packet = world_pb2.WorldPacket()
@@ -32,53 +41,101 @@ def connect(world_id, user, on_chat=None, on_init=None, on_join=None, on_leave=N
                     send = world_pb2.WorldPacket(player_init_received=world_pb2.PlayerInitReceivedPacket()).SerializeToString()
                     websocket.send(send)
                     
+                world_data = world.decode(packet.player_init_packet.world_data, block_list, packet.player_init_packet.world_width, packet.player_init_packet.world_height)
+                    
                 if commands:
                     for command in commands.keys():
                         cmd = world_pb2.PlayerChatPacket()
                         cmd.message = f"/custom register {command}"
                         send = world_pb2.WorldPacket(player_chat_packet=cmd).SerializeToString()
                         websocket.send(send)
                 player_id = packet.player_init_packet.player_properties.player_id
-                _run_user_handle(on_init, websocket, world_pb2, player_list, packet.player_init_packet)
+                _run_user_handle(on_init, websocket, world_pb2, player_list, packet.player_init_packet, world_data)
                 
             elif packet.HasField("player_chat_packet"):
                 if not packet.player_chat_packet.player_id == player_id:
-                    _run_user_handle(on_chat, websocket, world_pb2, player_list, packet.player_chat_packet)
+                    _run_user_handle(on_chat, websocket, world_pb2, player_list, packet.player_chat_packet, world_data)
                     
             elif packet.HasField("ping"):
                 send = world_pb2.WorldPacket(ping=world_pb2.Ping()).SerializeToString()
                 websocket.send(send)
                 
             elif packet.HasField("player_joined_packet"):
                 player_list[packet.player_joined_packet.properties.player_id] = packet.player_joined_packet.properties.username
-                _run_user_handle(on_join, websocket, world_pb2, player_list, packet.player_joined_packet)
+                _run_user_handle(on_join, websocket, world_pb2, player_list, packet.player_joined_packet, world_data)
                 
             elif packet.HasField("player_left_packet"):
-                _run_user_handle(on_leave, websocket, world_pb2, player_list, packet.player_left_packet)
+                _run_user_handle(on_leave, websocket, world_pb2, player_list, packet.player_left_packet, world_data)
                 del player_list[packet.player_left_packet.player_id]
+                
+            elif packet.HasField('world_block_placed_packet'):
+                id = packet.world_block_placed_packet.block_id
+                if packet.world_block_placed_packet.layer == 0:
+                    layer = 'bg'
+                if packet.world_block_placed_packet.layer == 1:
+                    layer = 'fg'
+                if packet.world_block_placed_packet.layer == 2:
+                    layer = 'ol'
+                if packet.world_block_placed_packet.extra_fields:
+                    block_data = world.decode_block_placed_data(packet.world_block_placed_packet.extra_fields)
+                else:
+                    block_data = []
+                    
+                for position in packet.world_block_placed_packet.positions:
+                    world_data[layer][position.x][position.y]['id'] = id
+                    world_data[layer][position.x][position.y]['data'] = block_data
+                    
+                _run_user_handle(on_block, websocket, world_pb2, player_list, packet.world_block_placed_packet, world_data)
             
             elif packet.HasField("player_direct_message_packet"):
                 if commands:
                     for command in commands.keys():
                         if f"//{command}" == packet.player_direct_message_packet.message or f"{packet.player_direct_message_packet.message}".startswith(f"//{command} "):
-                            _run_custom_cmd(commands[command], websocket, world_pb2, player_list, packet.player_direct_message_packet.from_player_id, packet.player_direct_message_packet.message)
+                            _run_custom_cmd(commands[command], websocket, world_pb2, player_list, packet.player_direct_message_packet.from_player_id, packet.player_direct_message_packet.message, world_data)
             
 class Connection:
-    def __init__(self, websocket, world_pb2, player_list):
+    def __init__(self, websocket, world_pb2, player_list, world_data):
         self.websocket = websocket
         self.proto = world_pb2
         self.players = player_list
+        self.world_data = world_data
     
     def send_chat(self, message):
         packet = self.proto.PlayerChatPacket()
         packet.message = message
         send = self.proto.WorldPacket(player_chat_packet=packet).SerializeToString()
         self.websocket.send(send)
         
-def _run_user_handle(function, websocket, world_pb2, player_list, packet):
+    def place_block(self, x, y, layer, id, data=None):
+        if layer == 0:
+            layer = 'bg'
+        if layer == 1:
+            layer = 'fg'
+        if layer == 2:
+            layer = 'ol'
+        if not self.world_data[layer][x][y]['id'] == id or not self.world_data[layer][x][y]['data'] == data:
+            if layer == 'bg':
+                layer = 0
+            elif layer == 'fg':
+                layer = 1
+            elif layer == 'ol':
+                layer = 2
+                
+            data = world.encode_block_placed_data(id, self.world_data['block_list'], data)
+                
+            packet = self.proto.WorldBlockPlacedPacket()
+            packet.block_id = id
+            packet.layer = layer
+            if data:
+                packet.extra_fields = data
+            packet.positions.append(self.proto.PointInteger(x=x,y=y))
+            send = self.proto.WorldPacket(world_block_placed_packet=packet).SerializeToString()
+            self.websocket.send(send)
+        
+def _run_user_handle(function, websocket, world_pb2, player_list, packet, world_data):
     if function:
-        function(Connection(websocket, world_pb2, player_list), packet)
+        function(Connection(websocket, world_pb2, player_list, world_data), packet)
         
-def _run_custom_cmd(function, websocket, world_pb2, player_list, player_id, message):
+def _run_custom_cmd(function, websocket, world_pb2, player_list, player_id, message, world_data):
     args = message.split(' ')[1:]
-    function(Connection(websocket, world_pb2, player_list), args, player_id)
+    function(Connection(websocket, world_pb2, player_list, world_data), args, player_id)
diff --git a/PythonWalker/world.py b/PythonWalker/world.py
@@ -0,0 +1,153 @@
+from binreader import BinaryReader
+from io import BytesIO
+import struct
+import json
+
+def get_block_by_id(block_list, id):
+    for block in block_list:
+        if block.get("Id") == id:
+            return block
+    return None
+
+def decode(data, block_list, width, height):
+    reader = BinaryReader(BytesIO(data))
+    world_data = {'width': width, 'height': height, 'bg': {}, 'fg': {}, 'ol': {}, 'block_list': block_list}
+    i = 0
+    for l in range(3):
+        if l == 0:
+            layer = 'bg'
+        if l == 1:
+            layer = 'fg'
+        if l == 2:
+            layer = 'ol'
+            
+        for x in range(width):
+            for y in range(height):
+                i += 1
+                id = reader.read_uint32()
+                block = get_block_by_id(block_list, id)
+                block_data = {'id': id, 'data': []}
+                
+                if not block:
+                    raise ValueError(f"Id {id} is not a valid block id.")
+                
+                if "BlockDataArgs" in block:
+                    for arg in block['BlockDataArgs']:
+                        block_data['data'].append(decode_argument(arg, reader))
+                if not x in world_data[layer]:
+                    world_data[layer][x] = []
+                world_data[layer][x].append(block_data)
+                
+    return world_data
+    
+def decode_argument(arg, reader, endian='big'):
+    if arg == 0:
+        size = 0
+        shift = 0
+        while True:
+            byte = ord(reader.read(1))
+            size |= (byte & 0x7F) << shift
+            shift += 7
+            if (byte & 0x80) == 0:
+                break
+        string = reader.read_string(size)
+        data = string
+    elif arg == 1:
+        data = reader.read_bool()
+    elif arg == 3:
+        if endian == 'big':
+            data = reader.read_uint32()
+        else:
+            data = int.from_bytes(reader.read(4))
+    elif arg == 7:
+        data = reader.read_bool()
+    elif arg == 8:
+        data = int.from_bytes(reader.read(reader.read_ubyte()))
+    elif arg == 9:
+        uint32_color = reader.read_uint32()
+        red = (uint32_color >> 16) & 0xFF
+        green = (uint32_color >> 8) & 0xFF
+        blue = uint32_color & 0xFF
+
+        hex_red = format(red, '02X')
+        hex_green = format(green, '02X')
+        hex_blue = format(blue, '02X')
+
+        data = f"#{hex_red}{hex_green}{hex_blue}"
+    else:
+        raise ValueError(f"Argument id {arg} is not a valid block argument.")
+    
+    return data
+    
+def decode_block_placed_data(data):
+    reader = BinaryReader(BytesIO(data))
+    length = len(data)
+    block_data = []
+    while not reader.tell() >= length:
+        arg = reader.read_ubyte()
+        block_data.append(decode_argument(arg, reader, endian='little'))
+    return block_data
+
+def encode_argument(arg, data):
+    if arg == 0:
+        bytes = b''
+        value = len(data)
+        while True:
+            byte = value & 0x7F
+            value >>= 7
+            if value > 0:
+                byte |= 0x80
+            bytes += byte.to_bytes(1)
+            if value == 0:
+                break
+        bytes += data.encode('utf-8')
+    elif arg == 1:
+        if data:
+            bytes = b'\x01'
+        else:
+            bytes = b'\x00'
+    elif arg == 3:
+        bytes = data.to_bytes(4)
+    elif arg == 7:
+        if data:
+            bytes = b'\x01'
+        else:
+            bytes = b'\x00'
+    elif arg == 8:
+        bytes = len(data.to_bytes()).to_bytes() + data.to_bytes()
+    elif arg == 9:
+        if not data.startswith('#') or len(data) != 7:
+            raise ValueError("Invalid hexadecimal color string format. Expected '#RRGGBB'.")
+
+        hex_red = data[1:3]
+        hex_green = data[3:5]
+        hex_blue = data[5:7]
+
+        red = int(hex_red, 16)
+        green = int(hex_green, 16)
+        blue = int(hex_blue, 16)
+
+        uint32_color = (red << 16) | (green << 8) | blue
+        bytes = uint32_color.to_bytes(4, byteorder='little')
+    else:
+        raise ValueError(f"Argument id {arg} is not a valid block argument.")
+    
+    return bytes
+
+def encode_block_placed_data(id, block_list, data=None):
+    block = get_block_by_id(block_list, id)
+    if bool("BlockDataArgs" in block) ^ bool(data):
+        raise ValueError("Block has data, but none given from user.")
+        
+    if "BlockDataArgs" in block:
+        i = 0
+        block_data = b''
+        for arg in block['BlockDataArgs']:
+            block_data += arg.to_bytes(1)
+            block_data += encode_argument(arg, data[i])
+            i += 1
+    else:
+        block_data = None
+        
+    return block_data
+    
diff --git a/README.md b/README.md
@@ -4,22 +4,22 @@ A Python based bot library for [PixelWalker](https://pixelwalker.net)
 Examples can be found [here](https://github.com/Tycho10101/PythonWalker/tree/main/examples).
 
 ## Setup
-- In a command line, run `pip install PythonWalker`
+- In a command line, run `pip install PythonWalker` (add `--upgrade` when updating)
 - Put `import PythonWalker as pw` in your main.py or main Python script
 
 ## Setup (Manual)
 - Put the `/PythonWalker` directory from this repository into the root of your program
 - Put `import PythonWalker as pw` in your main.py or main Python script
-- Install the Protobuf, Requests, and Websockets libraries
+- Install Protobuf, binreader, Requests, and Websockets
 
 ## Features
 - Connect to rooms
 - Chat functions
-- Recive leave and join packets
+- Receive leave and join packets
 - Custom commands
+- Blocks
 
 ## Todo List
-- Blocks
 - Private Messaging
 - And more! (suggest them in the issues page)
 
diff --git a/setup.py b/setup.py
@@ -2,12 +2,13 @@
 
 setup(
 	name="PythonWalker",  # Replace with your project name
-	version="0.2.3",
+	version="0.3.0",
 	packages=find_packages(),  # Automatically finds packages in your project
 	install_requires=[
 		"requests>=2.32.3",
 		"websockets>=13.1",
 		"protobuf",
+        "binreader",
 	],
 	author="Tycho10101",
 	author_email="supallawma@gmail.com",
