Add rest of assets, add blue player

scripts/extract_common.py

@@ -442,3 +442,143 @@ class EnumWriter:
         writer.output("return (AnimationFrame) {-1, -1.0f};\n")
         writer.block_end()
         writer.empty_line()
+
+    def filter_by_props(self, tiles, prop_names):
+        filtered = []
+        for tile in tiles:
+            if 'properties' not in tile:
+                continue
+            props = tile['properties']
+            names = prop_names[:]
+            for prop in props:
+                if prop['name'] in names:
+                    names.remove(prop['name'])
+            if len(names) == 0:
+                filtered.append(tile)
+        return filtered
+
+    def get_property(self, tile, prop_name):
+        if 'properties' not in tile:
+            return None
+        props = tile['properties']
+        for prop in props:
+            if prop['name'] == prop_name:
+                return prop
+        return None
+
+
+    def output_get_text_rect(self, func_name, width, tile_width, tile_height):
+        writer = self.writer
+        writer.output(
+            f"static Rectangle {func_name}(BzTileID tile) ")
+        writer.block_start()
+
+        writer.output(f"Rectangle base = {{ (tile % {width}) * {tile_width}, "
+                      f"(tile / {width}) * {tile_height}, {tile_width}, {tile_height} }};\n")
+
+        sized_tiles = {}
+        for tile in self.all_tiles:
+            if 'properties' not in tile:
+                continue
+            props = tile['properties']
+            size_x = 1
+            size_y = 1
+            for prop in props:
+                if prop['name'] == 'size_x':
+                    size_x = int(prop['value'])
+                if prop['name'] == 'size_y':
+                    size_y = int(prop['value'])
+
+            if size_x == 1 and size_y == 1:
+                continue
+            sized_tiles[tile['id']] = (size_x, size_y)
+        sized_map = defaultdict(list)
+        for k, v in sized_tiles.items():
+            sized_map[v].append(k)
+
+        if sized_map:
+            writer.output("switch (tile) ")
+            writer.block_start()
+            for k, v in sized_map.items():
+                for id in v:
+                    writer.output(f"case {id}:\n")
+                writer.indent()
+                x, y = k
+                writer.output(f"base.width *= {x};\n")
+                writer.output(f"base.height *= {y};\n")
+                writer.output("break;\n")
+                writer.unindent()
+            writer.output("default: break;\n")
+            writer.block_end()
+
+        writer.output("return base;\n")
+
+        writer.block_end()
+        writer.empty_line()
+
+    def output_base_index(self, func_name, field):
+        writer = self.writer
+        tiles = self.filter_by_props(self.all_tiles, [field])
+        field_map = defaultdict(list)
+        for tile in tiles:
+            index = self.get_property(tile, field)['value']
+            field_map[index].append(tile['id'])
+        sizes = list(map(lambda x: len(x), field_map.values()))
+        assert len(set(sizes)) == 1
+        indices = list(zip(*field_map.values()))
+        writer.output(
+            f"static BzTileID {func_name}(BzTileID tile) ")
+        writer.block_start()
+
+        writer.output("switch (tile) ")
+        writer.block_start()
+
+        for index in indices:
+            for idx in index:
+                writer.output(f"case {idx}:\n")
+            writer.indent()
+            writer.output(f"return {index[0]};\n")
+            writer.unindent()
+        writer.output("default: return tile;\n")
+        writer.block_end()
+
+        writer.block_end()
+        writer.empty_line()
+
+    def output_index_tile_offset(self, func_name, field, width, tile_width, tile_height):
+        writer = self.writer
+        tiles = self.filter_by_props(self.all_tiles, [field])
+        field_map = defaultdict(list)
+        for tile in tiles:
+            index = self.get_property(tile, field)['value']
+            field_map[index].append(tile['id'])
+        sizes = list(map(lambda x: len(x), field_map.values()))
+        assert len(set(sizes)) == 1
+        indices = list(zip(*field_map.values()))
+        writer.output(
+            f"static Vector2 {func_name}(BzTileID tile, i32 idx) ")
+        writer.block_start()
+        size = sizes[0]
+        writer.output(f"if (idx < 0 || idx >= {size}) return (Vector2) {{0, 0}};\n")
+
+        writer.output("switch (tile) ")
+        writer.block_start()
+
+        def calc_pos(tile):
+            return (tile % width) * tile_width, (tile // width) * tile_height
+
+        for index in indices:
+            base_idx = index[0]
+            base_pos = calc_pos(base_idx)
+            positions = [(0, 0)]
+            for idx in index[1:]:
+                pos = calc_pos(idx)
+                positions.append((pos[0] - base_pos[0], pos[1] - base_pos[1]))
+            str_positions = list(map(lambda x: f"{{{x[0]}, {x[1]}}}", positions))
+            ret = f"((Vector2 []) {{{', '.join(str_positions)}}})[idx]"
+            writer.output(f"case {base_idx}: return {ret};\n")
+        writer.output("default: return (Vector2) {0, 0};\n")
+        writer.block_end()
+
+        writer.block_end()
+        writer.empty_line()

scripts/extract_tileset.py

@@ -34,12 +34,12 @@ def remove_properties(data, dst_file):
 
 
 content = open("../rawAssets/game.tsj").read()
-tiles = json.loads(content)["tiles"]
+all_tiles = json.loads(content)["tiles"]
 remove_properties(content, "../assets/game.tsj")
-terrain_tiles = extract_by_property(tiles, "terrain")
-building_tiles = extract_by_property(tiles, "building")
-entity_tiles = extract_by_property(tiles, "entity")
-item_tiles = extract_by_property(tiles, "item")
+terrain_tiles = extract_by_property(all_tiles, "terrain")
+building_tiles = extract_by_property(all_tiles, "building")
+entity_tiles = extract_by_property(all_tiles, "entity")
+item_tiles = extract_by_property(all_tiles, "item")
 
 writer.header_guard_start()
 script_name = os.path.basename(__file__)
@@ -88,6 +88,12 @@ item_writer.output_enum_to_tile("getItemTile")
 #item_writer.output_has_handle("itemHasHandle")
 #item_writer.output_handle("itemGetHandle")
 
+tile_writer = EnumWriter(writer, all_tiles, "", "")
+
+tile_writer.output_get_text_rect("getTextureRect", 256, 16, 16)
+tile_writer.output_base_index("getTileBase", "player")
+tile_writer.output_index_tile_offset("getTileOffset", "player", 256, 16, 16)
+
 
 writer.header_guard_stop()