add script to generate images from map files and tile assets

1 files changed, 143 insertions, 0 deletions

diff --git a/scripts/generate_map_img.py b/scripts/generate_map_img.py
new file mode 100755
index 00000000..608c1fe6
--- /dev/null
+++ b/scripts/generate_map_img.py
@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+import argparse
+import cv2
+import pathlib
+import numpy
+import os
+from typing import MutableMapping
+
+MAP_ROOT = pathlib.Path(os.getcwd())
+TILES_DIR = MAP_ROOT / 'tiles'
+
+def get_tile_path(tile: str) -> pathlib.Path:
+    """Return the corresponding image file name for a tile"""
+    return TILES_DIR / f'{tile.lower().replace(" ", "_")}.png'
+
+def read_map(map_path: pathlib.Path) -> MutableMapping:
+    """Read and parse a map file"""
+    map_definition = {'symbols': {}, 'rules': {}}
+    with open(map_path, 'r') as map_file:
+        lines = [l[:-1] for l in map_file.readlines()] # remove new lines
+
+    # sections in map files are seperated by an empty line
+    section_end = lines.index('')
+    map_string = '\n'.join(lines[:section_end])
+    lines = lines [section_end+1:] # consume map string
+
+    section_end = lines.index('')
+    for symbol_def in lines[:section_end]:
+        symbol, tile = symbol_def.split(':=')
+        symbol = symbol.strip()
+        tile = tile.strip()
+        map_definition['symbols'][symbol] = tile
+    lines = lines[section_end + 1:] # consume symbol definitions
+
+    # build up tiles
+    tiles = []
+    for line in map_string.splitlines():
+        row = []
+        for symbol in line:
+            tile = "neutral"
+            if symbol != ' ':
+                if symbol not in map_definition['symbols']:
+                    print(f'WARNING unknown symbol "{symbol}"')
+                else:
+                    tile = map_definition['symbols'][symbol]
+            row.append(tile)
+        tiles.append(row)
+
+    map_definition['tiles'] = tiles
+
+    for rule in lines:
+        name, rule = symbol_def.split(':=')
+        name = name.strip()
+        rule = rule.strip()
+        map_definition['rules'][name] = rule
+
+    return map_definition
+
+
+def generate_img(map_path: pathlib.Path):
+    """Generate a image from a map file"""
+    map_definition = read_map(map_path)
+
+    tiles = map_definition['tiles']
+
+    rows_imgs = []
+    for i, row in enumerate(tiles):
+        tile_imgs = []
+        for j, tile in enumerate(row):
+            # find the right street and rotation
+            if tile == 'street':
+                # check continuations
+                left = j > 1 and row[j-1] == 'street'
+                right = j < len(row) - 1 and row[j+1] == 'street'
+                above = i > 1 and tiles[i-1][j] == 'street'
+                below = i < len(tiles) - 1 and tiles[i+1][j] == 'street'
+
+                connections = len([b for b in [left, right, above, below] if b == True])
+                # straight lines
+                if connections == 1 or (connections == 2 and ((left and right) or (above and below))):
+                    tile_img = cv2.imread(str(get_tile_path('street')))
+                    if above or below:
+                        tile_img = numpy.rot90(tile_img)
+                # elbow
+                elif connections == 2:
+                    # normal orientation above and right
+                    tile_img = cv2.imread(str(get_tile_path('street_2')))
+                    if right and below:
+                        tile_img = numpy.rot90(tile_img, 3)
+                    elif left and below:
+                        tile_img = numpy.rot90(tile_img, 2)
+                    elif above and left:
+                        tile_img = numpy.rot90(tile_img)
+                elif connections == 3:
+                    # normal orientation left above right
+                    tile_img = cv2.imread(str(get_tile_path('street_3')))
+                    if above and right and below:
+                        tile_img = numpy.rot90(tile_img, 3)
+                    elif left and below and right:
+                        tile_img = numpy.rot90(tile_img, 2)
+                    elif below and left and above:
+                        tile_img = numpy.rot90(tile_img)
+                elif connections == 4:
+                    tile_img = cv2.imread(str(get_tile_path('street_4')))
+            else:
+                tile_img = cv2.imread(str(get_tile_path(tile)))
+
+            tile_imgs.append(tile_img)
+
+        row_img = cv2.hconcat(tile_imgs)
+        rows_imgs.append(row_img)
+
+    map_img = cv2.vconcat(rows_imgs)
+    cv2.imshow(f'{map_path.stem}.png', map_img)
+    cv2.waitKey(0)
+    cv2.imwrite(f'{map_path.stem}.png', map_img)
+
+def main():
+    """Generate map images from map files"""
+
+    parser = argparse.ArgumentParser(description='generate latex standalone cards')
+    parser.add_argument('map_input', help='map file or directory containing map files')
+    parser.add_argument('--map-root', help='path to the map root directory')
+
+    args = parser.parse_args()
+
+    if args.map_root:
+        global MAP_ROOT
+        MAP_ROOT = pathlib.Path(args.latex_root)
+        global TILES_DIR
+        TILES_DIR = MAP_ROOT / 'tiles'
+
+
+    map_path = pathlib.Path(args.map_input)
+    map_files = [map_path]
+    if map_path.is_dir():
+        map_files = map_path.glob('*.map')
+
+    for m in map_files:
+        generate_img(m)
+
+if __name__ == '__main__':
+    main()