add german version of cards

Translatable properties now have the language as subkey (currently en, de).

generate_card.py takes an optional argument to select the language.

The latex/Makefile has two new targets de and en each building all
cards under latex/cards/<lang> and latex/build/<lang>

1 files changed, 116 insertions, 75 deletions

diff --git a/scripts/generate_card.py b/scripts/generate_card.py
index aa0347da..0ecc5df5 100755
--- a/scripts/generate_card.py
+++ b/scripts/generate_card.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import pathlib
-import os
+from pathlib import Path
 from typing import MutableMapping
 import yaml
 
@@ -26,142 +26,183 @@ SET_SYMBOLS = {
     'exp1': 'exp1'
 }
 
-LATEX_ROOT = pathlib.Path(os.getcwd())
-ASSETS_DIR = LATEX_ROOT / '../assets'
-CARDS_DIR = LATEX_ROOT / 'cards'
+SCRIPT_PATH = Path(__file__).parent
+GAME_ROOT = SCRIPT_PATH.parent
+ASSETS_DIR = GAME_ROOT / 'assets'
+
+# all keys known by the rules
+KEYS = [
+    'type', 'token', 'buy', 'upkeep', 'play', 'ai', 'health', 'movement',
+    'attack', 'full_action', 'effect'
+]
+
+FORMATTED_KEYS = {
+    'en': {
+        'ai': 'AI',
+        'full_action': 'Full Action'
+    },
+    'de': {
+        'ai': 'KI',
+        'full_action': 'Volle-Aktion',
+        'type': 'Typ',
+        'buy': 'Kauf-Kosten',
+        'upkeep': 'Unterhalts-Kosten',
+        'play': 'Aktivierungs-Kosten',
+        'health': 'Leben',
+        'movement': 'Bewegung',
+        'attack': 'Angriff',
+        'effect': 'Effekt',
+        'durability': 'Haltbarkeit',
+    }
+}
+
 
-def file_for_card(card_name: str, suffix = '.tex') -> pathlib.Path:
+def file_for_card(card_name: str, suffix='.tex') -> pathlib.Path:
     """Return the corresponding latex file name for a card"""
     return pathlib.Path(f'{card_name.lower().replace(" ", "_")}{suffix}')
 
-def get_latex_field(card: MutableMapping, field: str) -> str:
+
+def get_field(card: MutableMapping, field: str, language='en') -> str:
+    """Return the internationalized field value from a card"""
+    value = card[field]
+    if isinstance(value, dict):
+        value = value.get(language, value['en'])
+    return value
+
+
+def get_formatted_key(key: str, language='en') -> str:
+    """Return the internationalized formatted version for key"""
+    return FORMATTED_KEYS[language].get(key, key.capitalize())
+
+
+def get_latex_field(card: MutableMapping,
+                    field: str,
+                    language='en') -> (str, bool):
     """Return the latex_ prefixed field from card or the field itself"""
     latex_field = f'latex_{field}'
-    if latex_field in card:
-        return card[latex_field]
-    else:
-        return card[field]
+    value = card.get(latex_field, card[field])
 
-def generate_markdown(card: MutableMapping, indentation=3):
-    """Output a markdown enumeration"""
+    # internationalize
+    if isinstance(value, dict):
+        value = value.get(language, value['en'])
+
+    return value, latex_field in card
 
-    formatted_keys = {'ai': 'AI', 'full_action': 'Full Action'}
+
+def generate_markdown(card: MutableMapping, language='en', indentation=3):
+    """Output a markdown enumeration"""
 
     print(f'{"#" * indentation} {card["name"]}')
 
     yml_card_path = f'cards-data/{card["set"]}/{file_for_card(card["name"], ".yml")}'
     built_card_path = f'cards/{card["set"]}/{file_for_card(card["name"], "")}'
-    print(f'\n[pdf]({built_card_path}.pdf) [png]({built_card_path}.png) [yml]({yml_card_path})\n')
+    print(
+        f'\n[pdf]({built_card_path}.pdf) [png]({built_card_path}.png) [yml]({yml_card_path})\n'
+    )
 
-    for key in ['type', 'token', 'buy', 'upkeep', 'play', 'ai', 'health', 'movement', 'attack', 'full_action', 'effect']:
+    for key in KEYS:
         if key in card:
-            formatted_key = formatted_keys.get(key, key.capitalize())
-            print(f'* **{formatted_key}**: {card[key]}')
+            formatted_key = get_formatted_key(key, language)
+            value = get_field(card, key, language)
+            print(f'* **{formatted_key}**: {value}')
+
 
-def generate_latex(card: MutableMapping):
+def generate_latex(card: MutableMapping, language='en'):
     """Generate a standalone tikz picture with the card data"""
     card_content = ""
 
-    card_file = file_for_card(card['name'])
+    name = get_field(card, 'name', language)
+    card_file = file_for_card(name)
 
     for ext in ['.jpg', '.png']:
-        image_file =  ASSETS_DIR / card_file.with_suffix(ext)
+        image_file = ASSETS_DIR / card_file.with_suffix(ext)
         if image_file.exists():
             card_content += f'\\cardbackground{{{image_file.name}}}\n'
             break
 
-    card_content += f'\cardtype{card["type"].capitalize()}{"Token" if "token" in card else ""}{{{card["name"]}}}\n'
+    card_content += f'\\cardtype{card["type"].capitalize()}{"Token" if "token" in card else ""}{{{name}}}\n'
 
     if 'buy' in card:
-        card_content += f'\cardbuycost{{{card["buy"]}}}\n'
+        card_content += f'\\cardbuycost{{{card["buy"]}}}\n'
 
     if card['type'] == 'unit':
         stats = []
         abilities = []
-        if 'ai' in card:
-            stats.append(f'AI: {card["ai"]}')
-
-        if 'health' in card:
-            stats.append(f'Health: {card["health"]}')
-
-        if 'movement' in card:
-            stats.append(f'Movement: {card["movement"]}')
-
-        attack = card.get('attack', None)
-        if attack:
-            # attack_sym = '\\faFistRaised'
-            # if "Range" in attack:
-                # attack_sym = '\\ding{246}'
-            stats.append(f'Attack: {attack}')
+        for key in ['ai', 'health', 'movement', 'attack']:
+            if key in card:
+                formatted_key = get_formatted_key(key, language)
+                value = get_field(card, key, language)
+                stats.append(f'{formatted_key}: {value}')
 
         if 'effect' in card:
-            abilities.append(get_latex_field(card, 'effect'))
+            effect, _ = get_latex_field(card, 'effect', language)
+            abilities.append(effect)
 
         if 'full_action' in card:
-            if 'latex_full_action' in card:
-                abilities.append(f'{card["latex_full_action"]}')
-            else:
-                abilities.append(f'\\faRedo: {card["full_action"]}')
+            full_action, is_latex = get_latex_field(card, 'full_action',
+                                                    language)
+            if not is_latex:
+                full_action = f'\\faRedo: {full_action}'
+
+            abilities.append(full_action)
 
         stats_str = '\\\\'.join(stats)
         ability_block = '\\\\ \\vspace{0.2cm} '.join(abilities)
         if stats and abilities:
-            card_content += f'\cardsplitcontent{{{stats_str}}}{{{ability_block}}}'
+            card_content += f'\\cardsplitcontent{{{stats_str}}}{{{ability_block}}}'
         elif stats:
-            card_content += f'\cardcontent{{{stats_str}}}'
+            card_content += f'\\cardcontent{{{stats_str}}}'
 
         card_content += '\n'
 
         if 'upkeep' in card:
-            card_content += f'\cardplaycost{{{card["upkeep"]}}}'
+            card_content += f'\\cardplaycost{{{card["upkeep"]}}}'
 
     elif card['type'] in ['spell', 'artifact']:
-        effect = get_latex_field(card, 'effect')
+        effect, _ = get_latex_field(card, 'effect', language)
         assert effect is not None
-        card_content += f'\cardcontent{{{effect}}}\n'
+        card_content += f'\\cardcontent{{{effect}}}\n'
 
     elif card['type'] == 'equipment':
-        stats = f'Durability: {card["durability"]}'
-        effect = get_latex_field(card, 'effect')
-        card_content += f'\cardsplitcontent{{{stats}}}{{{effect}}}\n'
+        formatted_durability = get_formatted_key('durability')
+        stats = f'{formatted_durability}: {card["durability"]}'
+        effect, _ = get_latex_field(card, 'effect', language)
+        card_content += f'\\cardsplitcontent{{{stats}}}{{{effect}}}\n'
     else:
         print(f'WARNING: unknown card type {card["type"]}!')
 
     if 'play' in card:
-        card_content += f'\cardplaycost{{{card["play"]}}}\n'
+        card_content += f'\\cardplaycost{{{card["play"]}}}\n'
 
     if card['set'] in SET_SYMBOLS:
-        card_content += f'\cardmodule{{{SET_SYMBOLS[card["set"]]}}}'
+        card_content += f'\\cardmodule{{{SET_SYMBOLS[card["set"]]}}}'
     else:
         print(f'WARNING unknown set: {card["set"]}')
 
-    set_dir = CARDS_DIR / card['set']
-    if not set_dir.exists():
-        set_dir.mkdir(parents=True)
-
-    with open(set_dir / card_file, 'w') as tex_file:
-        print(CARD_TEMPLATE.format(card_content), file=tex_file)
+    print(CARD_TEMPLATE.format(card_content))
 
 
 def main():
     """Generate one standalone tikz picture for each card in the input data"""
 
-    parser = argparse.ArgumentParser(description='generate latex standalone cards')
-    parser.add_argument('data', help='yaml file or directory containing yaml files defining the cards to generate')
-    parser.add_argument('--latex-root', help='path to the latex root directory')
-    parser.add_argument('--format', choices=['latex', 'markdown'], default='latex', help='output format')
+    parser = argparse.ArgumentParser(
+        description='generate latex standalone cards')
+    parser.add_argument(
+        'data',
+        help=
+        'yaml file or directory containing yaml files defining the cards to generate'
+    )
+    parser.add_argument('--format',
+                        choices=['latex', 'markdown'],
+                        default='latex',
+                        help='output format')
+    parser.add_argument('--language',
+                        choices=['en', 'de'],
+                        default='en',
+                        help='the language of the card text')
 
     args = parser.parse_args()
 
-    if args.latex_root:
-        global LATEX_ROOT
-        LATEX_ROOT = pathlib.Path(args.latex_root)
-        global CARDS_DIR
-        CARDS_DIR = LATEX_ROOT / 'cards'
-        global ASSETS_DIR
-        ASSETS_DIR = LATEX_ROOT / '../assets'
-
-
     data_files = [args.data]
     data_path = pathlib.Path(args.data)
     if data_path.is_dir():
@@ -170,15 +211,15 @@ def main():
     else:
         card_set = data_path.parent.stem
 
-    for f in data_files:
-        with open(f, 'r') as yaml_file:
+    for data_file in data_files:
+        with open(data_file, 'r') as yaml_file:
             card = yaml.full_load(yaml_file)
 
         card['set'] = card_set
         if args.format == 'latex':
-            generate_latex(card)
+            generate_latex(card, language=args.language)
         elif args.format == 'markdown':
-            generate_markdown(card)
+            generate_markdown(card, language=args.language)
 
 
 if __name__ == '__main__':