Updated WorldStart packet structure, cleaned up display of VariantVariants.

Author: XenoWanderer

packets/data_types.py

@@ -1,6 +1,6 @@
 import logging
 from construct import Construct, Struct, Byte, BFloat64, Flag, \
-    Array, LazyBound, String, Container
+    String, Container
 from construct.core import _read_stream, _write_stream, Adapter
 
 
@@ -70,18 +70,20 @@ def _encode(self, obj, context):
     def _decode(self, obj, context):
         return obj.string
 
-
+class Joiner(Adapter):
+    def _encode(self, obj, context):
+        return obj
+    def _decode(self, obj, context):
+        return "".join(obj)
 star_string_struct = lambda name="star_string": Struct(name,
                                                        VLQ("length"),
                                                        String("string", lambda ctx: ctx.length)
 )
 
-variant_variant = Struct("data",
-                         VLQ("length"),
-                         Array(lambda ctx: ctx.length,
-                               LazyBound("data",
-                                         lambda: Variant(""))))
-
+class VariantVariant(Construct):
+    def _parse(self, stream, context):
+        l = VLQ("").parse_stream(stream)
+        return [Variant("").parse_stream(stream) for _ in range(l)]
 
 class DictVariant(Construct):
     def _parse(self, stream, context):
@@ -108,6 +110,13 @@ def _parse(self, stream, context):
         elif x == 5:
             return star_string().parse_stream(stream)
         elif x == 6:
-            return variant_variant.parse_stream(stream)
+            return VariantVariant("").parse_stream(stream)
         elif x == 7:
             return DictVariant("").parse_stream(stream)
+
+class StarByteArray(Construct):
+    def _parse(self, stream, context):
+        l = VLQ("").parse_stream(stream)
+        return _read_stream(stream, l)
+    def _build(self, obj, stream, context):
+        _write_stream(stream, len(obj), VLQ("").build(len(obj))+obj)

packets/packet_types.py

@@ -1,6 +1,6 @@
 from construct import *
 from enum import IntEnum
-from data_types import SignedVLQ, VLQ, Variant, star_string, DictVariant
+from data_types import SignedVLQ, VLQ, Variant, star_string, DictVariant,  StarByteArray
 
 
 class Direction(IntEnum):
@@ -178,21 +178,15 @@ def _decode(self, obj, context):
 
 
 world_start = lambda name="world_start": Struct(name,
-                                                VLQ("planet_size"),
-                                                Bytes("planet", lambda ctx: ctx.planet_size),
-                                                VLQ("world_structure_size"),
-                                                Bytes("world_structure",
-                                                      lambda ctx: ctx.world_structure_size),
-                                                VLQ("sky_size"),
-                                                Bytes("sky",
-                                                      lambda ctx: ctx.sky_size),
-                                                VLQ("server_weather_size"),
-                                                Bytes("server_weather", lambda ctx: ctx.server_weather_size),
+                                                Variant("planet"),
+                                                Variant("world_structure"),
+                                                StarByteArray("sky_structure"),
+                                                StarByteArray("weather_data"),
                                                 BFloat32("spawn_x"),
                                                 BFloat32("spawn_y"),
-                                                update_world_properties("world_properties"),
-                                                SBInt32("unknown1"),
-                                                Flag("unknown2"))
+                                                Variant("world_properties"),
+                                                UBInt32("client_id"),
+                                                Flag("local_interpolation"))
 
 world_stop = lambda name="world_stop": Struct(name,
                                               star_string("status"))

plugins/core/player_manager/plugin.py

@@ -84,8 +84,8 @@ def after_connect_response(self, data):
                 self.protocol.transport.getPeer().host))
 
     def after_world_start(self, data):
-        world_start = packets.Variant("").parse(data.data)
-        coords = world_start['config']['coordinate']
+        world_start = packets.world_start().parse(data.data)
+        coords = world_start.planet['config']['coordinate']
         if coords is not None:
             parent_system = coords['parentSystem']
             location = parent_system['location']