mirror of
https://github.com/Threnklyn/dungeon-sheets.git
synced 2026-05-18 20:23:27 +02:00
Mark Wolfman
402 lines
17 KiB
Python
402 lines
17 KiB
Python
#!/usr/bin/env python
|
|
|
|
import logging
|
|
log = logging.getLogger(__name__)
|
|
import argparse
|
|
import importlib.util
|
|
import os
|
|
import subprocess
|
|
import warnings
|
|
import re
|
|
|
|
from fdfgen import forge_fdf
|
|
|
|
from dungeonsheets import character, exceptions
|
|
from dungeonsheets.stats import mod_str
|
|
|
|
|
|
"""Program to take character definitions and build a PDF of the
|
|
character sheet."""
|
|
|
|
def text_box(string):
|
|
"""Format a string for displaying in a text box."""
|
|
# Remove line breaks
|
|
new_string = string.replace('\n', ' ').replace('\r', ' ')
|
|
# Remove multiple whitespace
|
|
new_string = ' '.join(new_string.split())
|
|
return new_string
|
|
|
|
|
|
def load_character_file(filename):
|
|
"""Create a character object from the given definition file.
|
|
|
|
The definition file should be an importable python file, filled
|
|
with variables describing the character.
|
|
|
|
Parameters
|
|
----------
|
|
filename : str
|
|
The path to the file that will be imported.
|
|
|
|
"""
|
|
# Parse the file name
|
|
dir_, fname = os.path.split(os.path.abspath(filename))
|
|
module_name, ext = os.path.splitext(fname)
|
|
if ext != '.py':
|
|
raise ValueError(f"Character definition {filename} is not a python file.")
|
|
# Check if this file contains the version string
|
|
version_re = re.compile('dungeonsheets_version\s*=\s*[\'"]([0-4.]+)[\'"]')
|
|
with open(filename, mode='r') as f:
|
|
version = None
|
|
for line in f:
|
|
match = version_re.match(line)
|
|
if match:
|
|
version = match.group(1)
|
|
break
|
|
if version is None:
|
|
# Not a valid DND character file
|
|
raise exceptions.CharacterFileFormatError(
|
|
"No ``dungeonsheets_version = `` entry.")
|
|
# Import the module to extract the information
|
|
spec = importlib.util.spec_from_file_location('module', filename)
|
|
module = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(module)
|
|
# Prepare a list of properties for this character
|
|
char_props = {}
|
|
for prop_name in dir(module):
|
|
if prop_name[0:2] != '__':
|
|
char_props[prop_name] = getattr(module, prop_name)
|
|
return char_props
|
|
|
|
|
|
def create_spellbook_pdf(character, basename):
|
|
from jinja2 import Environment, PackageLoader
|
|
env = Environment(
|
|
loader=PackageLoader('dungeonsheets', ''),
|
|
block_start_string='[%',
|
|
block_end_string='%]',
|
|
variable_start_string='[[',
|
|
variable_end_string=']]',
|
|
)
|
|
template = env.get_template('spellbook_template.tex')
|
|
tex = template.render(character=character)
|
|
# Create tex document
|
|
tex_file = f'{basename}.tex'
|
|
with open(tex_file, mode='w') as f:
|
|
f.write(tex)
|
|
# Convenience function for removing temporary files
|
|
def remove_temp_files(basename_):
|
|
filenames = [f'{basename_}.tex', f'{basename_}.aux',
|
|
f'{basename_}.log']
|
|
for filename in filenames:
|
|
if os.path.exists(filename):
|
|
os.remove(filename)
|
|
# Compile the PDF
|
|
pdf_file = f'{basename}.pdf'
|
|
output_dir = os.path.abspath(os.path.dirname(pdf_file))
|
|
try:
|
|
result = subprocess.run(['pdflatex', '--output-directory',
|
|
output_dir, tex_file, '-halt-on-error'],
|
|
stdout=subprocess.DEVNULL, timeout=10)
|
|
except FileNotFoundError:
|
|
# Remove temporary files
|
|
remove_temp_files(basename)
|
|
raise exceptions.LatexNotFoundError()
|
|
else:
|
|
if result.returncode == 0:
|
|
remove_temp_files(basename)
|
|
else:
|
|
raise exceptions.LatexError(f'Processing of {basename}.tex failed.')
|
|
|
|
|
|
def create_spells_pdf(character, basename, flatten=False):
|
|
class_level = (character.class_name + ' ' + str(character.level))
|
|
spell_level = lambda x : (x or '')
|
|
fields = [
|
|
('Spellcasting Class 2', class_level),
|
|
("SpellcastingAbility 2", character.spellcasting_ability.capitalize()),
|
|
('SpellSaveDC 2', character.spell_save_dc),
|
|
('SpellAtkBonus 2', mod_str(character.spell_attack_bonus)),
|
|
# Number of spell slots
|
|
('SlotsTotal 19', spell_level(character.spell_slots(1))),
|
|
('SlotsTotal 20', spell_level(character.spell_slots(2))),
|
|
('SlotsTotal 21', spell_level(character.spell_slots(3))),
|
|
('SlotsTotal 22', spell_level(character.spell_slots(4))),
|
|
('SlotsTotal 23', spell_level(character.spell_slots(5))),
|
|
('SlotsTotal 24', spell_level(character.spell_slots(6))),
|
|
('SlotsTotal 25', spell_level(character.spell_slots(7))),
|
|
('SlotsTotal 26', spell_level(character.spell_slots(8))),
|
|
('SlotsTotal 27', spell_level(character.spell_slots(9))),
|
|
]
|
|
# Cantrips
|
|
cantrip_fields = (f'Spells 10{i}' for i in (14, 16, 17, 18, 19, 20, 21, 22))
|
|
cantrips = (spl for spl in character.spells if spl.level == 0)
|
|
for spell, field_name in zip(cantrips, cantrip_fields):
|
|
fields.append((field_name, str(spell)))
|
|
# Spells for each level
|
|
field_numbers = {
|
|
1: (1015, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, ),
|
|
2: (1046, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, ),
|
|
3: (1048, 1047, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, ),
|
|
4: (1061, 1060, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, ),
|
|
5: (1074, 1073, 1075, 1076, 1077, 1078, 1079, 1080, 1081, ),
|
|
6: (1083, 1082, 1084, 1085, 1086, 1087, 1088, 1089, 1090, ),
|
|
7: (1092, 1091, 1093, 1094, 1095, 1096, 1097, 1098, 1099, ),
|
|
8: (10101, 10100, 10102, 10103, 10104, 10105, 10106, ),
|
|
9: (10108, 10107, 10109, 101010, 101011, 101012, 101013),
|
|
}
|
|
prep_numbers = {
|
|
1: (251, 309, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, ),
|
|
2: (313, 310, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, ),
|
|
3: (315, 314, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, ),
|
|
4: (317, 316, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, ),
|
|
5: (319, 318, 3053, 3054, 3055, 3056, 3057, 3058, 3059, ),
|
|
6: (321, 320, 3060, 3061, 3062, 3063, 3064, 3065, 3066, ),
|
|
7: (323, 322, 3067, 3068, 3069, 3070, 3071, 3072, 3073, ),
|
|
8: (325, 324, 3074, 3075, 3076, 3077, 3078, ),
|
|
9: (327, 326, 3079, 3080, 3081, 3082, 3083, ),
|
|
}
|
|
for level in field_numbers.keys():
|
|
spells = tuple(spl for spl in character.spells if spl.level == level)
|
|
field_names = tuple(f'Spells {i}' for i in field_numbers[level])
|
|
prep_names = tuple(f'Check Box {i}' for i in prep_numbers[level])
|
|
for spell, field, chk_field in zip(spells, field_names, prep_names):
|
|
fields.append((field, str(spell)))
|
|
is_prepared = any([isinstance(spell, Spl) for Spl in character.spells_prepared])
|
|
fields.append((chk_field, is_prepared))
|
|
# # Uncomment to post field names instead:
|
|
# for field in field_names:
|
|
# fields.append((field, field))
|
|
# Make the actual pdf
|
|
dirname = os.path.dirname(os.path.abspath(__file__))
|
|
src_pdf = os.path.join(dirname, 'blank-spell-sheet-default.pdf')
|
|
make_pdf(fields, src_pdf=src_pdf, basename=basename, flatten=flatten)
|
|
|
|
|
|
def create_character_pdf(character, basename, flatten=False):
|
|
# Prepare the list of fields
|
|
class_level = (character.class_name + ' ' + str(character.level))
|
|
fields = [
|
|
# Character description
|
|
('CharacterName', character.name),
|
|
('ClassLevel', class_level),
|
|
('Background', character.background),
|
|
('PlayerName', character.player_name),
|
|
('Race ', str(character.race)),
|
|
('Alignment', character.alignment),
|
|
('XP', character.xp),
|
|
# Abilities
|
|
('ProfBonus', mod_str(character.proficiency_bonus)),
|
|
('STRmod', str(character.strength.value)),
|
|
('STR', mod_str(character.strength.modifier)),
|
|
('DEXmod ', character.dexterity.value),
|
|
('DEX', mod_str(character.dexterity.modifier)),
|
|
('CONmod', character.constitution.value),
|
|
('CON', mod_str(character.constitution.modifier)),
|
|
('INTmod', character.intelligence.value),
|
|
('INT', mod_str(character.intelligence.modifier)),
|
|
('WISmod', character.wisdom.value),
|
|
('WIS', mod_str(character.wisdom.modifier)),
|
|
('CHamod', character.charisma.value),
|
|
('CHA', mod_str(character.charisma.modifier)),
|
|
('AC', character.armor_class),
|
|
('Initiative', mod_str(character.dexterity.modifier)),
|
|
('Speed', character.speed),
|
|
('Passive', 10 + character.perception),
|
|
# Saving throws (proficiencies handled later)
|
|
('ST Strength', mod_str(character.strength.saving_throw)),
|
|
('ST Dexterity', mod_str(character.dexterity.saving_throw)),
|
|
('ST Constitution', mod_str(character.constitution.saving_throw)),
|
|
('ST Intelligence', mod_str(character.intelligence.saving_throw)),
|
|
('ST Wisdom', mod_str(character.wisdom.saving_throw)),
|
|
('ST Charisma', mod_str(character.charisma.saving_throw)),
|
|
# Skills (proficiencies handled below)
|
|
('Acrobatics', mod_str(character.acrobatics)),
|
|
('Animal', mod_str(character.animal_handling)),
|
|
('Arcana', mod_str(character.arcana)),
|
|
('Athletics', mod_str(character.athletics)),
|
|
('Deception ', mod_str(character.deception)),
|
|
('History ', mod_str(character.history)),
|
|
('Insight', mod_str(character.insight)),
|
|
('Intimidation', mod_str(character.intimidation)),
|
|
('Investigation ', mod_str(character.investigation)),
|
|
('Medicine', mod_str(character.medicine)),
|
|
('Nature', mod_str(character.nature)),
|
|
('Perception ', mod_str(character.perception)),
|
|
('Performance', mod_str(character.performance)),
|
|
('Persuasion', mod_str(character.persuasian)),
|
|
('Religion', mod_str(character.religion)),
|
|
('SleightofHand', mod_str(character.sleight_of_hand)),
|
|
('Stealth ', mod_str(character.stealth)),
|
|
('Survival', mod_str(character.survival)),
|
|
# Hit points
|
|
('HDTotal', character.hit_dice),
|
|
('HPMax', character.hp_max),
|
|
# Personality traits and other features
|
|
('PersonalityTraits ', text_box(character.personality_traits)),
|
|
('Ideals', text_box(character.ideals)),
|
|
('Bonds', text_box(character.bonds)),
|
|
('Flaws', text_box(character.flaws)),
|
|
('Features and Traits', text_box(character.features_and_traits)),
|
|
# Inventory
|
|
('CP', character.cp),
|
|
('SP', character.sp),
|
|
('EP', character.ep),
|
|
('GP', character.gp),
|
|
('PP', character.pp),
|
|
('Equipment', text_box(character.equipment)),
|
|
]
|
|
# Check boxes for proficiencies
|
|
ST_boxes = {
|
|
'strength': 'Check Box 11',
|
|
'dexterity': 'Check Box 18',
|
|
'constitution': 'Check Box 19',
|
|
'intelligence': 'Check Box 20',
|
|
'wisdom': 'Check Box 21',
|
|
'charisma': 'Check Box 22',
|
|
}
|
|
for ability in character.saving_throw_proficiencies:
|
|
fields.append((ST_boxes[ability], 'Yes'))
|
|
skill_boxes = {
|
|
'acrobatics': 'Check Box 23',
|
|
'animal_handling': 'Check Box 24',
|
|
'arcana': 'Check Box 25',
|
|
'athletics': 'Check Box 26',
|
|
'deception': 'Check Box 27',
|
|
'history': 'Check Box 28',
|
|
'insight': 'Check Box 29',
|
|
'intimidation': 'Check Box 30',
|
|
'investigation': 'Check Box 31',
|
|
'medicine': 'Check Box 32',
|
|
'nature': 'Check Box 33',
|
|
'perception': 'Check Box 34',
|
|
'performance': 'Check Box 35',
|
|
'persuasian': 'Check Box 36',
|
|
'religion': 'Check Box 37',
|
|
'sleight_of_hand': 'Check Box 38',
|
|
'stealth': 'Check Box 39',
|
|
'survival': 'Check Box 40',
|
|
}
|
|
# Add skill proficienies
|
|
for skill in character.skill_proficiencies:
|
|
try:
|
|
fields.append((skill_boxes[skill.replace(' ', '_').lower()], 'Yes'))
|
|
except KeyError:
|
|
raise KeyError(f"Unknown skill: '{skill}'")
|
|
# Add weapons
|
|
weapon_fields = [('Wpn Name', 'Wpn1 AtkBonus', 'Wpn1 Damage'),
|
|
('Wpn Name 2', 'Wpn2 AtkBonus ', 'Wpn2 Damage '),
|
|
('Wpn Name 3', 'Wpn3 AtkBonus ', 'Wpn3 Damage '),]
|
|
for _fields, weapon in zip(weapon_fields, character.weapons):
|
|
name_field, atk_field, dmg_field = _fields
|
|
fields.append((name_field, weapon.name))
|
|
fields.append((atk_field, mod_str(weapon.attack_bonus)))
|
|
fields.append((dmg_field, f'{weapon.damage} {weapon.damage_type}'))
|
|
# Other attack information
|
|
attack_str = f'Armor: {character.armor}'
|
|
attack_str += f'Shield: {character.shield}\n\n'
|
|
attack_str += character.attacks_and_spellcasting
|
|
fields.append(('AttacksSpellcasting', text_box(attack_str)))
|
|
# Other proficiencies and languages
|
|
prof_text = "Proficiencies:\n" + text_box(character.proficiencies_text)
|
|
prof_text += "\n\nLanguages:\n" + text_box(character.languages)
|
|
fields.append(('ProficienciesLang', prof_text))
|
|
# Prepare the actual PDF
|
|
dirname = os.path.dirname(os.path.abspath(__file__))
|
|
src_pdf = os.path.join(dirname, 'blank-character-sheet-default.pdf')
|
|
return make_pdf(fields, src_pdf=src_pdf, basename=basename, flatten=flatten)
|
|
|
|
|
|
def make_pdf(fields, src_pdf, basename, flatten=False):
|
|
# Create the actual FDF file
|
|
fdfname = basename + '.fdf'
|
|
fdf = forge_fdf("", fields, [], [], [])
|
|
fdf_file = open(fdfname, "wb")
|
|
fdf_file.write(fdf)
|
|
fdf_file.close()
|
|
# Build the final flattened PDF documents
|
|
dest_pdf = basename + '.pdf'
|
|
popenargs = [
|
|
'pdftk', src_pdf, 'fill_form', fdfname, 'output', dest_pdf,
|
|
]
|
|
if flatten:
|
|
popenargs.append('flatten')
|
|
subprocess.call(popenargs)
|
|
# Clean up temporary files
|
|
os.remove(fdfname)
|
|
|
|
|
|
def make_sheet(character_file, flatten=False):
|
|
"""Prepare a PDF character sheet from the given character file.
|
|
|
|
Parameters
|
|
----------
|
|
flatten : bool, optional
|
|
If true, the resulting PDF will not be a fillable form.
|
|
|
|
"""
|
|
# Create a character from the character definition
|
|
char_props = load_character_file(character_file)
|
|
class_name = char_props.pop('character_class').lower().capitalize()
|
|
CharClass = getattr(character, class_name)
|
|
char = CharClass(**char_props)
|
|
# Set the fields in the FDF
|
|
char_base = os.path.splitext(character_file)[0] + '_char'
|
|
sheets = [char_base + '.pdf']
|
|
create_character_pdf(character=char, basename=char_base, flatten=flatten)
|
|
if char.is_spellcaster:
|
|
# Create spell sheet
|
|
spell_base = os.path.splitext(character_file)[0] + '_spells'
|
|
create_spells_pdf(character=char, basename=spell_base, flatten=flatten)
|
|
sheets.append(spell_base + '.pdf')
|
|
# Create spell book
|
|
spellbook_base = os.path.splitext(character_file)[0] + '_spellbook'
|
|
try:
|
|
create_spellbook_pdf(character=char, basename=spellbook_base)
|
|
except exceptions.LatexNotFoundError as e:
|
|
log.warning('``pdflatex`` not available. Skipping spellbook '
|
|
f'for {char.name}')
|
|
else:
|
|
sheets.append(spellbook_base + '.pdf')
|
|
# Combine sheets into final pdf
|
|
final_pdf = os.path.splitext(character_file)[0] + '.pdf'
|
|
popenargs = ('pdftk', *sheets, 'cat', 'output', final_pdf)
|
|
subprocess.call(popenargs)
|
|
# Remove temporary files
|
|
for sheet in sheets:
|
|
os.remove(sheet)
|
|
|
|
|
|
def main():
|
|
# Prepare an argument parser
|
|
parser = argparse.ArgumentParser(
|
|
description='Prepare Dungeons and Dragons character sheets as PDFs')
|
|
parser.add_argument('filename', type=str, nargs="?",
|
|
help="Python file with character definition")
|
|
parser.add_argument('--editable', '-e', action="store_true",
|
|
help="Keep the PDF fields in place once processed.")
|
|
args = parser.parse_args()
|
|
# Process the requested files
|
|
if args.filename is None:
|
|
filenames = [f for f in os.listdir('.') if os.path.splitext(f)[1] == '.py']
|
|
else:
|
|
filenames = [args.filename]
|
|
for filename in filenames:
|
|
print(f"Processing {os.path.splitext(filename)[0]}...", end='')
|
|
try:
|
|
make_sheet(character_file=filename, flatten=(not args.editable))
|
|
except exceptions.CharacterFileFormatError as e:
|
|
# Only raise the failed exception if this file is explicitly given
|
|
print('invalid')
|
|
if args.filename:
|
|
raise
|
|
except Exception as e:
|
|
print('failed')
|
|
raise
|
|
else:
|
|
print("done")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|