Create attractive VASL scenarios, with loads of useful information embedded to assist with game play.
https://vasl-templates.org
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
12 KiB
301 lines
12 KiB
#!/usr/bin/env python3
|
|
""" Create placeholder files for the Chapter H notes. """
|
|
|
|
import os
|
|
import zipfile
|
|
import json
|
|
import re
|
|
import glob
|
|
|
|
import click
|
|
|
|
nationalities = None
|
|
|
|
# ---------------------------------------------------------------------
|
|
|
|
@click.command()
|
|
@click.option( "--output","-o", "output_fname", help="Output ZIP file to generate." )
|
|
def main( output_fname ): # pylint: disable=too-many-locals,too-many-branches
|
|
"""Create a ZIP file with placeholder files for each Chapter H note and multi-applicable note."""
|
|
|
|
def log( fmt, *args ): #pylint: disable=missing-docstring
|
|
print( fmt.format( *args ) )
|
|
return make_chapter_h_placeholders( output_fname, log=log )
|
|
|
|
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
def make_chapter_h_placeholders( output_fname, log=None \
|
|
): #pylint: disable=too-many-locals,too-many-statements,too-many-branches
|
|
"""Create a ZIP file with placeholder files for each Chapter H note and multi-applicable note."""
|
|
|
|
# initialize
|
|
if not output_fname:
|
|
raise RuntimeError( "Output ZIP file not specified." )
|
|
if not log:
|
|
def log_nothing( fmt, *args ): #pylint: disable=missing-docstring,unused-argument
|
|
pass
|
|
log = log_nothing
|
|
results = {}
|
|
|
|
# load the nationalities
|
|
global nationalities
|
|
fname = os.path.join( os.path.split(__file__)[0], "../webapp/data/default-template-pack/nationalities.json" )
|
|
with open( fname, "r", encoding="utf-8" ) as fp:
|
|
nationalities = json.load( fp )
|
|
|
|
# load the vehicle/ordnance data files
|
|
base_dir = os.path.join( os.path.split(__file__)[0], "../webapp/data/" )
|
|
for vo_type in ("vehicles","ordnance"):
|
|
dname = os.path.join( base_dir, vo_type )
|
|
for root,_,fnames in os.walk( dname ):
|
|
for fname in fnames:
|
|
fname = os.path.join( root, fname )
|
|
if os.path.splitext( fname )[1] != ".json":
|
|
continue
|
|
if os.path.splitext( fname )[0].endswith( ".lend-lease" ):
|
|
# NOTE: Doing this means we will miss any pieces explicitly defined in a lend-lease file
|
|
# (instead of being copied from an existing piece), but we can live with that... :-/
|
|
continue
|
|
dname2, fname2 = os.path.split( fname )
|
|
if os.path.split( dname2 )[1] == "kfw":
|
|
continue # nb: we do these files later
|
|
nat = os.path.splitext( fname2 )[0]
|
|
if nat == "common":
|
|
nat = os.path.split( dname2 )[1]
|
|
if nat == "free-french" or nat.startswith("kfw-"):
|
|
continue
|
|
notes, ma_notes = load_vo_data( fname, nat )
|
|
if nat not in results:
|
|
results[ nat ] = {}
|
|
results[ nat ][ vo_type ] = { "notes": notes, "ma_notes": ma_notes }
|
|
|
|
# insert the K:FW vehicles/ordnance
|
|
kfw_vo_data = load_kfw_vo_data()
|
|
results["kfw-un"] = {
|
|
"vehicles": {
|
|
"notes": kfw_vo_data["kfw-un"]["vehicles"][0],
|
|
"ma_notes": kfw_vo_data["kfw-un"]["vehicles"][1]
|
|
},
|
|
"ordnance": {
|
|
"notes": kfw_vo_data["kfw-un"]["ordnance"][0],
|
|
"ma_notes": kfw_vo_data["kfw-un"]["ordnance"][1]
|
|
}
|
|
}
|
|
results["kfw-comm"] = {
|
|
"vehicles": {
|
|
"notes": kfw_vo_data["kfw-comm"]["vehicles"][0],
|
|
"ma_notes": kfw_vo_data["kfw-comm"]["vehicles"][1]
|
|
},
|
|
"ordnance": {
|
|
"notes": kfw_vo_data["kfw-comm"]["ordnance"][0],
|
|
"ma_notes": kfw_vo_data["kfw-comm"]["ordnance"][1]
|
|
}
|
|
}
|
|
|
|
# load the extensions
|
|
base_dir = os.path.join( os.path.split(__file__)[0], "../webapp/data/extensions" )
|
|
for fname in glob.glob( os.path.join( base_dir, "*.json" ) ):
|
|
extn_data = load_vo_data_from_extension( fname )
|
|
for nat, vo_types in extn_data.items():
|
|
for vo_type in vo_types:
|
|
for key in vo_types[vo_type]:
|
|
if nat not in results:
|
|
results[nat] = {}
|
|
if vo_type not in results[nat]:
|
|
results[nat][vo_type] = {}
|
|
if key not in results[nat][vo_type]:
|
|
results[nat][vo_type][key] = []
|
|
results[nat][vo_type][key].extend( vo_types[vo_type].get( key, [] ) )
|
|
|
|
# FUDGE! Allied Ordnance Note D is not in the Allied Minor common.json file (it's referenced
|
|
# by some of the nationality-specific Guns e.g. Belgian DBT), so we add it in manually.
|
|
assert "D" not in results["allied-minor"]["ordnance"]["ma_notes"]
|
|
results["allied-minor"]["ordnance"]["ma_notes"].append( "D" )
|
|
|
|
# generate the placeholder files
|
|
with zipfile.ZipFile( output_fname, "w" ) as zip_file:
|
|
nats = sorted( results.keys() )
|
|
for nat in nats: #pylint: disable=too-many-nested-blocks
|
|
for vo_type in ("vehicles","ordnance"):
|
|
log( "Generating {} {}...", nat, vo_type )
|
|
for note_type in ("notes","ma_notes"):
|
|
|
|
# get the next set of note ID's
|
|
vals = results[nat].get( vo_type, {} ).get( note_type )
|
|
if not vals:
|
|
continue
|
|
log( "- {}: {}", note_type, ", ".join( str(v) for v in vals ) )
|
|
|
|
for val in vals:
|
|
|
|
# generate the filename for the next note placeholder
|
|
if isinstance(val, str):
|
|
# NOTE: Filenames are always lower-case, unless the note ID itself is lower-case,
|
|
# in which case we indicate this with a trailing underscore
|
|
if re.search( r"^([-a-z]+:)?[A-Z][A-Za-z]?$", val ):
|
|
val = val.lower()
|
|
elif re.search( r"^[a-z]{1,2}?$", val ):
|
|
val += "_"
|
|
if nat == "landing-craft":
|
|
fname = "{}/{}.{}".format( nat, val, "png" if note_type == "notes" else "html" )
|
|
else:
|
|
fname = "{}/{}/{}.{}".format( nat, vo_type, val, "png" if note_type == "notes" else "html" )
|
|
|
|
# add the placeholder file to the ZIP
|
|
fname = fname.replace( ":", "/" )
|
|
zip_file.writestr( fname, b"" )
|
|
log( "" )
|
|
|
|
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
def load_vo_data( fname, nat ):
|
|
"""Load a vehicle/ordnance data file."""
|
|
|
|
# initialize
|
|
notes, ma_notes = set(), set()
|
|
|
|
# load the file
|
|
with open( fname, "r", encoding="utf-8" ) as fp:
|
|
vo_data = json.load( fp )
|
|
for vo_entry in vo_data:
|
|
if "note_number" in vo_entry:
|
|
notes.add(
|
|
_extract_note_number( vo_entry["note_number"] )
|
|
)
|
|
if "notes" in vo_entry and not _ignore_ma_notes(nat):
|
|
ma_notes.update(
|
|
_extract_ma_note_ids( vo_entry["notes"] )
|
|
)
|
|
|
|
return sorted(notes), sorted(ma_notes)
|
|
|
|
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
def load_kfw_vo_data():
|
|
"""Load the K:FW vehicle/ordnance data files."""
|
|
|
|
# load the K:FW vehicles
|
|
un_veh_notes, un_veh_ma_notes = set(), set()
|
|
dname = os.path.join( os.path.split(__file__)[0], "../webapp/data/vehicles/kfw" )
|
|
for fname in ( "us-rok-ounc.json", "bcfk.json", "un-common.json" ):
|
|
notes, ma_notes = load_vo_data( os.path.join(dname,fname), None )
|
|
un_veh_notes.update( notes )
|
|
un_veh_ma_notes.update( ma_notes )
|
|
comm_veh_notes, comm_veh_ma_notes = set(), set()
|
|
for fname in ( "kpa.json", ):
|
|
notes, ma_notes = load_vo_data( os.path.join(dname,"kpa.json"), None )
|
|
comm_veh_notes.update( notes )
|
|
comm_veh_ma_notes.update( ma_notes )
|
|
|
|
# load the K:FW ordnance
|
|
un_ord_notes, un_ord_ma_notes = set(), set()
|
|
dname = os.path.join( os.path.split(__file__)[0], "../webapp/data/ordnance/kfw" )
|
|
for fname in ( "us-rok-ounc.json", "bcfk.json", "un-common.json" ):
|
|
notes, ma_notes = load_vo_data( os.path.join(dname,fname), None )
|
|
un_ord_notes.update( notes )
|
|
un_ord_ma_notes.update( ma_notes )
|
|
comm_ord_notes, comm_ord_ma_notes = set(), set()
|
|
for fname in ( "kpa.json", "cpva.json" ):
|
|
notes, ma_notes = load_vo_data( os.path.join(dname,fname), None )
|
|
comm_ord_notes.update( notes )
|
|
comm_ord_ma_notes.update( ma_notes )
|
|
|
|
return {
|
|
"kfw-un": {
|
|
"vehicles": ( un_veh_notes, un_veh_ma_notes ),
|
|
"ordnance": ( un_ord_notes, un_ord_ma_notes )
|
|
},
|
|
"kfw-comm": {
|
|
"vehicles": ( comm_veh_notes, comm_veh_ma_notes ),
|
|
"ordnance": ( comm_ord_notes, comm_ord_ma_notes )
|
|
}
|
|
}
|
|
|
|
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
def load_vo_data_from_extension( fname ):
|
|
"""Load a vehicle/ordnance extension data file."""
|
|
|
|
# initialize
|
|
results = {}
|
|
|
|
# get the extension ID
|
|
with open( fname, "r", encoding="utf-8" ) as fp:
|
|
data = json.load( fp )
|
|
extn_id = data["extensionId"]
|
|
if extn_id == "08d":
|
|
# NOTE: All the vehicle/ordnance notes and multi-applicable notes in the Fight For Seoul extension
|
|
# actually reference those in K:FW (and there is code in the main application to handle this), so
|
|
# the user doesn't need to set anything up for FfS (other than what they already need to do for K:FW).
|
|
return results
|
|
|
|
# load the file
|
|
for nat in data:
|
|
|
|
if not isinstance( data[nat], dict ):
|
|
continue
|
|
|
|
results[nat] = {}
|
|
for vo_type in ("vehicles","ordnance"):
|
|
notes, ma_notes = set(), set()
|
|
for vo_entry in data[nat].get(vo_type,[]):
|
|
# load the vehicle/ordnance's note number
|
|
if "note_number" in vo_entry:
|
|
notes.add(
|
|
_extract_note_number( vo_entry["note_number"] )
|
|
)
|
|
if "notes" in vo_entry and not _ignore_ma_notes(nat,extn_id):
|
|
ma_notes.update(
|
|
_extract_ma_note_ids( vo_entry["notes"] )
|
|
)
|
|
results[ nat ][ vo_type ] = {
|
|
"notes": [ "{}:{}".format( extn_id, n ) for n in sorted(notes) ],
|
|
"ma_notes": [ "{}:{}".format( extn_id, n ) for n in sorted(ma_notes) ]
|
|
}
|
|
|
|
return results
|
|
|
|
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
MA_NOTE_REGEXES = [
|
|
re.compile( r"^([A-Z]{1,2})$" ),
|
|
re.compile( r"^([A-Z]{1,2})\u2020" ),
|
|
re.compile( r"^([a-z])$" ),
|
|
re.compile( r"^([a-z])\u2020" ),
|
|
re.compile( r"^([A-Z][a-z])$" ),
|
|
re.compile( r"^([A-Za-z])<sup>" ),
|
|
re.compile( r"^<s>([A-Za-z])</s>$" ),
|
|
]
|
|
|
|
REDIRECTED_MA_NOTE_REGEX = re.compile(
|
|
r"^((Ge|Ru|US|Br|Fr|Jp|Ch|Gr|AllM|AxM) ([A-Z]{1,2}|[0-9]{1,2}|Note \d+|<s>P</s>))\u2020?(<sup>\d</sup>)?$"
|
|
)
|
|
|
|
def _extract_note_number( val ):
|
|
"""Extract a vehicle/ordnance's note number."""
|
|
mo = re.search( r"^\d+(\.\d)?", val )
|
|
return mo.group()
|
|
|
|
def _extract_ma_note_ids( val ):
|
|
"""Extract a vehicle/ordnance's multi-applicable note ID's."""
|
|
ma_note_ids = []
|
|
for ma_note in val:
|
|
if REDIRECTED_MA_NOTE_REGEX.search( ma_note ):
|
|
continue
|
|
matches = [ regex.search(ma_note) for regex in MA_NOTE_REGEXES ]
|
|
matches = [ mo.group(1) for mo in matches if mo ]
|
|
assert len(matches) == 1
|
|
ma_note_ids.append( matches[0] )
|
|
return ma_note_ids
|
|
|
|
def _ignore_ma_notes( nat, extn_id=None ):
|
|
if extn_id == "adf-bj" and nat == "american":
|
|
return True
|
|
if extn_id is None and nationalities.get( nat, {} ).get( "type" ) in ("allied-minor","axis-minor"):
|
|
return True
|
|
return False
|
|
|
|
# ---------------------------------------------------------------------
|
|
|
|
if __name__ == "__main__":
|
|
main() #pylint: disable=no-value-for-parameter
|
|
|