(station) merge the general parts of #61

agrf/lib/building/demo.py

@@ -1,16 +1,25 @@
+from dataclasses import dataclass, replace
 from agrf.graphics import LayeredImage
 from agrf.utils import unique_tuple
+from agrf.lib.building.layout import ALayout
 
 
+@dataclass
 class Demo:
-    def __init__(self, title, tiles, remap=None, climate="temperate", subclimate="default"):
-        self.title = title
-        self.tiles = tiles
-        self.remap = remap
-        self.climate = climate
-        self.subclimate = subclimate
+    title: str
+    tiles: list
+    remap: object = None
+    climate: str = "temperate"
+    subclimate: str = "default"
+    merge_bbox: bool = False
 
     def graphics(self, scale, bpp, remap=None):
+        if self.merge_bbox:
+            sprites = []
+            for r, row in enumerate(self.tiles):
+                for c, sprite in enumerate(row[::-1]):
+                    sprites.extend(sprite.demo_translate(c, r).parent_sprites)
+            return ALayout(None, sprites, False).graphics(scale, bpp, remap)
         remap = remap or self.remap
         yofs = 32 * scale
         img = LayeredImage.canvas(
@@ -31,13 +40,11 @@ def graphics(self, scale, bpp, remap=None):
 
     @property
     def T(self):
-        return Demo(self.title, [[tile and tile.T for tile in row] for row in self.tiles[::-1]], self.remap)
+        return replace(self, tiles=[[tile and tile.T for tile in row] for row in self.tiles[::-1]])
 
     @property
     def M(self):
-        return Demo(
-            self.title, [[tile and tile.M for tile in row[::-1]] for row in list(zip(*self.tiles))[::-1]], self.remap
-        )
+        return replace(self, tiles=[[tile and tile.M for tile in row[::-1]] for row in list(zip(*self.tiles))[::-1]])
 
     def get_fingerprint(self):
         return {"tiles": [[x and x.get_fingerprint() for x in row] for row in self.tiles], "remap": "FIXME"}  # FIXME

agrf/lib/building/layout.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass, replace
 import grf
 from PIL import Image
 import functools
@@ -11,6 +12,7 @@ class ChildSpriteContainerMixin:
     def __init__(self, *args, child_sprites=None, **kwargs):
         super().__init__(*args, **kwargs)
         self.child_sprites = child_sprites or []
+        assert all(isinstance(c, AChildSprite) for c in self.child_sprites)
 
     def to_grf(self, sprite_list):
         return [self.parent_to_grf(sprite_list)] + [cs.to_grf(sprite_list) for cs in self.child_sprites]
@@ -97,7 +99,9 @@ def parent_to_grf(self, sprite_list):
             **self.registers_to_grf_dict(),
         )
 
-    def to_parentsprite(self):
+    def to_parentsprite(self, low=False):
+        if low:
+            return ADefaultParentSprite(self.sprite, (16, 16, 0), (0, 0, 0))
         return ADefaultParentSprite(self.sprite, (16, 16, 1), (0, 0, 0))
 
     def to_action2(self, sprite_list):
@@ -156,7 +160,9 @@ def parent_to_grf(self, sprite_list):
             **self.registers_to_grf_dict(),
         )
 
-    def to_parentsprite(self):
+    def to_parentsprite(self, low=False):
+        if low:
+            return AParentSprite(self.sprite, (16, 16, 0), (0, 0, 0))
         return AParentSprite(self.sprite, (16, 16, 1), (0, 0, 0), flags=self.flags)
 
     def to_action2(self, sprite_list):
@@ -231,6 +237,15 @@ def pushdown(self, steps):
                 y += 1
         return ADefaultParentSprite(self.sprite, (1, 1, 1), (x, y, z), self.child_sprites, self.flags)
 
+    def demo_translate(self, xofs, yofs, zofs):
+        return ADefaultParentSprite(
+            self.sprite,
+            self.extent,
+            (self.offset[0] + xofs * 16, self.offset[1] + yofs * 16, self.offset[2] + zofs * 8),
+            self.child_sprites,
+            self.flags,
+        )
+
     @property
     def L(self):
         return self
@@ -326,6 +341,15 @@ def pushdown(self, steps):
                 y += 1
         return AParentSprite(self.sprite, (1, 1, 1), (x, y, z), self.child_sprites, self.flags)
 
+    def demo_translate(self, xofs, yofs, zofs):
+        return AParentSprite(
+            self.sprite,
+            self.extent,
+            (self.offset[0] + xofs * 16, self.offset[1] + yofs * 16, self.offset[2] + zofs * 8),
+            self.child_sprites,
+            self.flags,
+        )
+
     @functools.cache
     def squash(self, ratio):
         return AParentSprite(
@@ -463,25 +487,26 @@ def is_in_front(a, b):
     return False
 
 
+@dataclass(eq=False)
 class ALayout:
-    def __init__(
-        self, ground_sprite, parent_sprites, traversable, category=None, notes=None, flattened=False, altitude=0
-    ):
-        if ground_sprite is None:
+    ground_sprite: object
+    parent_sprites: list
+    traversable: bool
+    category: str = None
+    notes: list = None
+    flattened: bool = False
+    altitude: int = 0
+
+    def __post_init__(self):
+        if self.ground_sprite is None:
             from station.stations.misc import empty_ground
 
-            ground_sprite = empty_ground
-        assert isinstance(ground_sprite, (ADefaultGroundSprite, AGroundSprite))
-        self.ground_sprite = ground_sprite
-        assert all(isinstance(s, (ADefaultParentSprite, AParentSprite)) for s in parent_sprites), [
-            type(s) for s in parent_sprites
+            self.ground_sprite = empty_ground
+        assert isinstance(self.ground_sprite, (ADefaultGroundSprite, AGroundSprite))
+        assert all(isinstance(s, (ADefaultParentSprite, AParentSprite)) for s in self.parent_sprites), [
+            type(s) for s in self.parent_sprites
         ]
-        self.parent_sprites = parent_sprites
-        self.traversable = traversable
-        self.category = category
-        self.notes = notes or []
-        self.flattened = flattened
-        self.altitude = altitude
+        self.notes = self.notes or []
 
     @property
     def sorted_parent_sprites(self):
@@ -526,30 +551,30 @@ def pushdown(self, steps):
 
     @functools.cache
     def squash(self, ratio):
-        return ALayout(
-            self.ground_sprite,
-            [s.squash(ratio) for s in self.sorted_parent_sprites],
-            self.traversable,
-            category=self.category,
-            notes=self.notes,
-            flattened=True,
-            altitude=self.altitude,
-        )
+        return replace(self, parent_sprites=[s.squash(ratio) for s in self.sorted_parent_sprites])
 
+    @functools.cache
     def raise_tile(self, delta=1):
-        return ALayout(
-            self.ground_sprite,
-            self.parent_sprites,
-            self.traversable,
-            category=self.category,
-            notes=self.notes,
-            flattened=True,
-            altitude=self.altitude + delta,
-        )
+        return replace(self, altitude=self.altitude + delta)
 
+    @functools.cache
     def lower_tile(self, delta=1):
         return self.raise_tile(-delta)
 
+    @functools.cache
+    def demo_translate(self, xofs, yofs):
+        from station.stations.misc import empty_ground
+
+        return replace(
+            self,
+            ground_sprite=empty_ground,
+            parent_sprites=[
+                s.demo_translate(xofs, yofs, self.altitude)
+                for s in [self.ground_sprite.to_parentsprite(low=True)] + self.sorted_parent_sprites
+            ],
+            altitude=0,
+        )
+
     def to_grf(self, sprite_list):
         if self.flattened:
             parent_sprites = self.parent_sprites
@@ -585,7 +610,7 @@ def graphics(self, scale, bpp, remap=None, context=None, climate="temperate", su
                 )
             )
 
-        return img.move(0, -self.altitude * 32)
+        return img.move(0, -self.altitude * 8 * scale)
 
     def to_index(self, layout_pool):
         return layout_pool.index(self)

agrf/lib/building/symmetry.py

@@ -3,7 +3,7 @@ class BuildingSymmetryMixin:
     def create_variants(classobj, variants):
         for i, v in enumerate(variants):
             cls = v.__class__
-            v.__class__ = type(cls.__name__, (classobj, cls), {})
+            v.__class__ = type(cls.__name__, (cls, classobj), {})
             if classobj._m_offset == 0:
                 v.M = variants[i ^ 3 if i in [1, 2] else i]
             else:

requirements.txt

@@ -1,2 +1,2 @@
-grf @ git+https://github.com/ahyangyi/grf-py@29a4ba19
+grf @ git+https://github.com/ahyangyi/grf-py@36f4256
 tabulate