Files
fs25-adsmartpickup/tools/build_help.py
T

246 lines
11 KiB
Python

#!/usr/bin/env python3
"""Byg modens hjælp (manualen i spillet) ud fra docs/BRUGERMANUAL.md og docs/USER_MANUAL.md.
Skriver FS25_ADSmartPickup/help/help_da.xml og help_en.xml:
<section id="s12" level="3" title="..."><p>...</p></section> -- hvert afsnit i manualen (indhold + søgning)
<alias id="flow.policy" ref="s38"/> -- en række/et trin i spillet -> afsnit
<alias id="set.contracts" ref="s23" title="..."><p>...</p></alias> -- en tabelrække (indstilling) som egen tekst
Manualerne har de samme overskrifter i samme rækkefølge (dansk/engelsk); afsnit parres efter rækkefølge.
Kør fra repo-roden: python3 tools/build_help.py
"""
import os
import re
import sys
from xml.sax.saxutils import escape, quoteattr
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DOCS = {"da": "docs/BRUGERMANUAL.md", "en": "docs/USER_MANUAL.md"}
OUT_DIR = "FS25_ADSmartPickup/help"
# Række/trin i spillet -> afsnit (dansk overskrift; "kapitel|overskrift" når overskriften findes flere steder)
# eller "row:<dansk tabelcelle>" for en indstilling i en tabel.
ALIASES = {
# flow-guidens trin (".out"/".in" = udkørsel/forsyning; uden endelse = begge)
"flowstep.name": 'Guiden "Opsæt flow"',
"flowstep.direction": "Grundbegreber",
"flowstep.buildings": "Bygningslisten",
"flowstep.goods.out": "Politik pr. vare",
"flowstep.goods.in": "Opsætning",
"flowstep.store": "Lager: tvunget aflæsningssted",
"flowstep.feed": "Lever også til (fodring med samme vogn)",
"flowstep.rules.out": "Regler for udkørsel",
"flowstep.rules.in": "Regler for forsyning",
"flowstep.wait": "Wait-punkter",
"flowstep.tractors": "Traktorer i et flow",
"flowstep.summary": 'Guiden "Opsæt flow"',
# flow-guidens rækker
"flow.kind": "Grundbegreber",
"flow.showAllBuildings": "Bygningslisten",
"flow.sellUnused": "Politik pr. vare",
"flow.policy": "Politik pr. vare",
"flow.ingredientMode": "Opsætning",
"flow.storeAuto": "Lager: tvunget aflæsningssted",
"flow.sellAtPercent": "Prisen",
"flow.storeAbovePercent": "Regler for udkørsel",
"flow.sellAbovePercent": "Regler for udkørsel",
"flow.minSourcePercent": "Regler for udkørsel",
"flow.collectRound": "Opsamlingsrunde",
"flow.loops": "Regler for forsyning",
"flow.returnBelowPercent": "Regler for forsyning",
"flow.waitPoolGroup": "Wait-punkter",
"flow.borrowTractor": "Lån en ledig traktor (flows uden fast traktor)",
"flow.borrowWagonId": "Lån en ledig traktor (flows uden fast traktor)",
"flow.lockSet": "Låst traktor og vogn (fjerne områder)",
"flow.wagon": "Flow-vogne",
"flow.spareWagon": "Flow-vogne",
# mark-guiden
"fieldstep.field": 'Guiden "Opsæt mark"',
"fieldstep.crop": 'Guiden "Opsæt mark"',
"fieldstep.cropChoice": "Vælg og glem: afgrøde på marken",
"fieldstep.prep": 'Guiden "Opsæt mark"',
"fieldstep.care": 'Guiden "Opsæt mark"',
"fieldstep.machines": "Markflåde og maskinpulje",
"fieldstep.store": 'Guiden "Opsæt mark"',
"fieldstep.summary": 'Guiden "Opsæt mark"',
"field.targetFruit": "Vælg og glem: afgrøde på marken",
"field.sow": 'Guiden "Opsæt mark"',
"field.chainFree": "Markér en mark fri til kæden",
"field.rake": "Markarbejde på græs",
"field.straw": 'Guiden "Opsæt mark"',
"field.prepAuto": 'Guiden "Opsæt mark"',
"field.careAuto": 'Guiden "Opsæt mark"',
"field.rigIds": "Markflåde og maskinpulje",
"field.rigs": "Markflåde og maskinpulje",
"field.unloaders": "Markflåde og maskinpulje",
"field.useDedicated": "Markflåde og maskinpulje",
"field.useFieldSilo": "Marksiloer",
"field.storeAuto": 'Guiden "Opsæt mark"',
# Indstillinger
"set.section": "Indstillinger",
"set.stableSiloRange": "row:Stald-silo: afstand fra stald til egen silo",
"set.waitHomeMinutes": "row:Wait: ventetid før resten køres hjem i gårdens lager",
"set.parkLoadedMinutes": "Rest-læs og Wait",
"set.strayFullMinutes": "row:AutoDrive-tur uden flow ved fuldt mål: tøm efter",
"set.troughRefillPercent": "row:Fodertrug: kør først når truget er fyldt højst X %",
"set.contracts": "row:Hvem kører kontrakter",
"set.morningBriefing": "row:Morgenbriefing",
"set.playerDrive": "row:Maskiner uden parkering",
"set.playerPopup": "row:Besked når du skal køre en maskine",
"set.slurryFertilizer": "row:Gylle som gødning",
"set.slurryMinShare": "row:Gylle: mindst så meget af markens behov på lager",
"set.autoAll": "Alt automatisk: alle marker på én gang",
"set.farmSurplusPercent": "Alt automatisk: alle marker på én gang",
"set.startAllStaggerSec": "Stop alt og parkér",
"set.sellReadyAnimals": "Sælg slagteklare dyr",
"set.sellReadySpreadMonths": "Sælg slagteklare dyr",
"set.lockTractor": "Sælg slagteklare dyr",
# Marksiloer
"fs.fsEnabled": "Marksiloer",
"fs.fsMaxVehicles": "Marksiloer",
"fs.fsMinLiters": "Marksiloer",
"fs.fsToProduction": "Marksiloer",
"fs.fsReserveDays": "Marksiloer",
}
HEADING = re.compile(r"^(#{2,4}) (.+?)\s*$")
TABLE_ROW = re.compile(r"^\|(.+)\|\s*$")
def plain(text):
"""Markdown -> ren tekst (fed/kursiv/kode/links)."""
text = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", text)
text = re.sub(r"`([^`]*)`", r"\1", text)
text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
text = re.sub(r"(?<![\w*])\*([^*\n]+)\*(?![\w*])", r"\1", text)
text = text.replace("<br>", " ").replace("&nbsp;", " ")
return re.sub(r"\s+", " ", text).strip()
def cells(line):
return [c.strip() for c in TABLE_ROW.match(line).group(1).split("|")]
def paragraphs(lines):
"""Afsnittets linjer -> afsnit (tekst). Tabeller: én linje pr. række ("A — B — C"), punkter: "• ..."."""
result, current, header = [], [], None
def flush():
if current:
result.append(plain(" ".join(current)))
current.clear()
in_code = False
for line in lines:
stripped = line.strip()
if stripped.startswith("```"):
flush()
in_code = not in_code
continue
if in_code:
# kodeblok/eksempel: én linje pr. afsnit, ingen sammenfletning
if stripped:
result.append(stripped)
continue
if re.fullmatch(r"-{3,}|\*{3,}", stripped):
flush()
continue
if TABLE_ROW.match(stripped):
flush()
row = cells(stripped)
if all(re.fullmatch(r":?-{2,}:?", c) for c in row if c):
continue
if header is None:
header = row
continue
result.append(" — ".join(plain(c) for c in row if c))
continue
header = None
if not stripped:
flush()
continue
bullet = re.match(r"^(\s*)(?:[-*]|\d+\.) (.*)$", line)
if bullet:
flush()
current.append((" " if bullet.group(1) else "") + "• " + bullet.group(2))
continue
current.append(stripped)
flush()
return [p for p in result if p]
def parse(path):
"""-> sektioner [{level, title, lines, chapter}] og tabelrækker [(første celle, tekst)]"""
sections, rows, chapter = [], [], ""
current = None
in_code = False
with open(os.path.join(ROOT, path), encoding="utf-8") as handle:
for raw in handle:
line = raw.rstrip("\n")
if line.strip().startswith("```"):
in_code = not in_code
match = None if in_code else HEADING.match(line)
if match:
level, title = len(match.group(1)), plain(match.group(2))
if level == 2:
chapter = title.split(".")[0] if re.match(r"^\d+\.", title) else ""
current = {"level": level, "title": title, "lines": [], "chapter": chapter}
sections.append(current)
continue
if current is not None:
current["lines"].append(line)
if TABLE_ROW.match(line.strip()) and line.strip().startswith("| **"):
row = cells(line.strip())
rows.append((plain(row[0]), " — ".join(plain(c) for c in row[1:] if c)))
return sections, rows
def resolve(spec, sections):
chapter, _, title = spec.rpartition("|")
def bare(text): return re.sub(r"^\d+\. ", "", text) # "12. Marksiloer" -> "Marksiloer"
found = [i for i, s in enumerate(sections) if bare(s["title"]) == title and (not chapter or s["chapter"] == chapter)]
if len(found) != 1:
sys.exit("hjælp: overskriften %r findes %d gange" % (spec, len(found)))
return found[0]
def main():
parsed = {lang: parse(path) for lang, path in DOCS.items()}
da_sections, da_rows = parsed["da"]
for lang, (sections, rows) in parsed.items():
levels = [s["level"] for s in sections]
if levels != [s["level"] for s in da_sections]:
sys.exit("hjælp: %s har overskrifterne på andre niveauer end dansk (manualerne er ude af takt)" % lang)
if len(sections) != len(da_sections) or len(rows) != len(da_rows):
sys.exit("hjælp: %s har %d afsnit/%d tabelrækker, dansk %d/%d" % (lang, len(sections), len(rows), len(da_sections), len(da_rows)))
os.makedirs(os.path.join(ROOT, OUT_DIR), exist_ok=True)
for lang, (sections, rows) in parsed.items():
out = ['<?xml version="1.0" encoding="utf-8" standalone="no"?>', "<help>"]
for index, section in enumerate(sections):
# indholdsfortegnelsen i manualen er links; spillet har sin egen
if index == 0:
continue
body = paragraphs(section["lines"])
out.append(' <section id="s%d" level="%d" title=%s>' % (index, section["level"], quoteattr(section["title"])))
out.extend(" <p>%s</p>" % escape(p) for p in body)
out.append(" </section>")
for alias, spec in sorted(ALIASES.items()):
if spec.startswith("row:"):
key = spec[4:]
matches = [i for i, (cell, _) in enumerate(da_rows) if cell == key]
if len(matches) != 1:
sys.exit("hjælp: tabelrækken %r findes %d gange" % (key, len(matches)))
cell, text = rows[matches[0]]
ref = resolve("Indstillinger", da_sections)
out.append(' <alias id=%s ref="s%d" title=%s><p>%s</p></alias>' % (quoteattr(alias), ref, quoteattr(cell), escape(text)))
else:
out.append(' <alias id=%s ref="s%d"/>' % (quoteattr(alias), resolve(spec, da_sections)))
out.append("</help>")
with open(os.path.join(ROOT, OUT_DIR, "help_%s.xml" % lang), "w", encoding="utf-8") as handle:
handle.write("\n".join(out) + "\n")
print("help_%s.xml: %d afsnit, %d genveje" % (lang, len(sections) - 1, len(ALIASES)))
if __name__ == "__main__":
main()