246 lines
11 KiB
Python
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(" ", " ")
|
|
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()
|