utils.py

# vim: set tabstop=8 softtabstop=0 expandtab shiftwidth=4 smarttab : #
import re
import math
import copy
import json
from slugify import slugify

def ordinal(n):
    return "%d%s" % (n,"tsnrhtdd"[(n//10%10!=1)*(n%10<4)*n%10::4])


def parseRIV(m, t):
    lis = []
    for r in m[t]:    
        if isinstance(r, dict):
            if 'special' in r:
                lis.append(r['special'])
#            elif t in r:
#                lis += parseRIV(r, t)
#            elif 'resist' in r:
#                lis += parseRIV(r, 'resist')
            else:
                riv = []
                for x in r[t]:
                    if isinstance(x, dict) and t in x:
                        if len(riv) > 0:
                            riv[-1] += "; {}{}{}".format(
                                x['preNote'] +
                                " " if 'preNote' in x else "",
                                ", ".join(parseRIV(x, t)),
                                " " +
                                x['note'] if 'note' in x else "")
                        else:
                            riv.append(
                            "{}{}{}".format(
                                x['preNote'] +
                                " " if 'preNote' in x else "",
                                ", ".join(parseRIV(x, t)),
                                " " +
                                x['note'] if 'note' in x else ""))
                    else:
                        riv.append(x)
                if len(lis) > 0:
                    lis[-1] += "; {}{}{}".format(
                            r['preNote'] +
                            " " if 'preNote' in r else "",
                            ", ".join(riv),
                            " " +
                            r['note'] if 'note' in r else "")

                else:
                    lis.append(
                        "{}{}{}".format(
                            r['preNote'] +
                            " " if 'preNote' in r else "",
                            ", ".join(riv),
                            " " +
                            r['note'] if 'note' in r else ""))
        else:
            lis.append(r)
    return lis


def remove5eShit(s):
    if type(s) == int or type(s) == float:
        return str(s)
    s = re.sub(r'{@dc (.*?)}', r'DC \1', s)
    s = re.sub(r'{@hit \+?(.*?)}', r'+\1', s)
    s = re.sub(r'{@atk mw}', r'Melee Weapon Attack:', s)
    s = re.sub(r'{@atk rw}', r'Ranged Weapon Attack:', s)
    s = re.sub(r'{@atk ms}', r'Melee Spell Attack:', s)
    s = re.sub(r'{@atk rs}', r'Ranged Spell Attack:', s)
    s = re.sub(r'{@atk mw,rw}', r'Melee or Ranged Weapon Attack:', s)
    s = re.sub(r'{@atk r}', r'Ranged Attack:', s)
    s = re.sub(r'{@atk m}', r'Melee Attack:', s)
    s = re.sub(r'{@h}', r'', s)
    s = re.sub(r'{@recharge (.*?)}', r'(Recharge \1-6)', s)
    s = re.sub(r'{@recharge}', r'(Recharge 6)', s)
    s = re.sub(r'{@dice (.*?)(\|.*?)?}', r'\1', s)
    s = re.sub(r'{@scaledice (.*?)\|(.*?)\|(.*?)}', r'\3', s)
    s = re.sub(r'{@scaledamage (.*?)\|(.*?)\|(.*?)}', r'\3', s)
    s = re.sub(r'{@table (.*?)\|(.*?)\|(.*?)}', r'\3', s)
    s = re.sub(r'{@filter (.*?)(\|.*?)?}', r'\1', s)
    s = re.sub(r'{@\w+ ([^{]*?)(\|[^{]*?)?}', r'\1', s)
    s = re.sub(r'{@\w+ ((.*?|{.*?})?)(\|(.*?|{.*?})?)?}', r'\1', s)
    return s.strip()


def indent(elem, level=0):
    i = "\n" + level * "  "
    j = "\n" + (level - 1) * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for subelem in elem:
            indent(subelem, level + 1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = j
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = j
    return elem


def convertSize(s):
    return {
        'T': "Tiny",
        'S': "Small",
        'M': "Medium",
        'L': "Large",
        'H': "Huge",
        'G': "Gargantuan",
    }[s]


def convertAlign(s):
    if isinstance(s, dict):
        if 'special' in s:
            return s['special']
        else:
            if 'chance' in s:
                return " ".join(
                    [convertAlign(x) for x in s['alignment']]) + " ({}%)".format(s['chance'])
            return " ".join([convertAlign(x) for x in s['alignment']])
    else:
        alignment = s.upper()
        return {"L": "Lawful",
                "N": "Neutral",
                "NX": "Neutral (Law/Chaos axis)",
                "NY": "Neutral (Good/Evil axis)",
                "C": "Chaotic",
                "G": "Good",
                "E": "Evil",
                "U": "Unaligned",
                "A": "Any alignment",
                }[alignment]


def convertAlignList(s):
    if len(s) == 1:
        return convertAlign(s[0])
    elif len(s) == 2:
        return " ".join([convertAlign(x) for x in s])
    elif len(s) == 3:
        if "NX" in s and "NY" in s and "N" in s:
            return "Any Neutral Alignment"
    elif len(s) == 5:
        if "G" not in s:
            return "Any Non-Good Alignment"
        elif "E" not in s:
            return "Any Non-Evil Alignment"
        elif "L" not in s:
            return "Any Non-Lawful Alignment"
        elif "C" not in s:
            return "Any Non-Chaotic Alignment"
    elif len(s) == 4:
        if "L" not in s and "NX" not in s:
            return "Any Chaotic Alignment"
        if "G" not in s and "NY" not in s:
            return "Any Evil Alignment"
        if "C" not in s and "NX" not in s:
            return "Any Lawful Alignment"
        if "E" not in s and "NY" not in s:
            return "Any Good Alignment"

def modifyMonster(m,mods):
    for mod in mods:
        if mod == '*':
            if type(mods[mod]) == list:
                for amod in mods[mod]:
                    if amod["mode"] == "replaceTxt":
                        mr = amod["replace"]
                        mw = amod["with"]
                        mf = ""
                        if "flags" in amod:
                            mf = amod["flags"]
                        m = modRepl(m,mr,mw,mf)
            else:
                if mods[mod]["mode"] == "replaceTxt":
                    mr = mods[mod]["replace"]
                    mw = mods[mod]["with"]
                    mf = ""
                    if "flags" in mods[mod]:
                        mf = mods[mod]["flags"]
                    m = modRepl(m,mr,mw,mf)
        elif mod == 'trait' or mod == 'action' or mod == 'reaction' or mod == 'legendary':
            if mod not in m:
                m[mod] = []
            m[mod] = modTraits(m[mod],mods[mod])
        elif mod == 'spellcasting' or mod == 'languages' or mod == 'resist' or mod == "variant" or mod == "immune" or mod == "conditionImmune" or mod == "vulnerable":
            if mod not in m:
                m[mod] = []
            m[mod] = modList(m[mod],mods[mod])
        elif mod == "hp":
            if mods[mod]["mode"] == "scalarMultProp":
                if mods[mod]["floor"]:
                    m["hp"][mods[mod]["prop"]] = math.floor(m["hp"][mods[mod]["prop"]] * mods[mod]["scalar"])
                else:
                    m["hp"][mods[mod]["prop"]] = round(m["hp"][mods[mod]["prop"]] * mods[mod]["scalar"])
            else:
                print("Unhandled HP mode:", mods[mod]["mode"])
        elif mod == 'skill' or mod == 'save':
            if mod not in m:
                continue
            if mods[mod]["mode"] == "scalarAddProp":
                if mods[mod]["prop"] == "*":
                    for s in m[mod]:
                        m[mod][s] = "{:+d}".format(int(m[mod][s])+mods[mod]["scalar"])
                else:
                    m[mod][mods[mod]["prop"]] = "{:+d}".format(int(m[mod][mods[mod]["prop"]])+mods[mod]["scalar"])
            else:
                print("Unhandled " + mod + " mode:", mods[mod]["mode"])
        elif mod == '_':
            mod_s = []
            if type(mods[mod]) == list:
                mod_s.extend(mods[mod])
            else:
                mod_s.append(mods[mod])
            for ms in mod_s:
                if ms["mode"] == "addSenses":
                    if 'senses' not in m:
                        m["senses"] = []
                    if type(ms["senses"]) == list:
                        for i in range(len(ms["senses"])):
                            m["senses"].append("{} {} ft.".format(ms["senses"][i]["type"],ms["senses"][i]["range"]))
                    else:
                        m["senses"].append("{} {} ft.".format(ms["senses"]["type"],ms["senses"]["range"]))
                elif ms["mode"] == "scalarMultXp":
                    m["cr"] = multiCR(m["cr"],ms["scalar"])
                elif ms["mode"] == "maxSize":
                    sizes = [ 'T', 'S', 'M', 'L', 'H', 'G' ]
                    if sizes.index(ms["max"]) < sizes.index(m["size"]):
                        m["size"] = ms["max"]
                elif ms["mode"] == "addSkills":
                    if 'skill' not in m:
                        m["skill"] = {}
                    for skill in ms["skills"]:
                        m["skill"][skill] = '{:+d}'.format(ms["skills"][skill])
                elif ms["mode"] == "addSpells":
                    if "spells" in ms:
                        for slevel in ms["spells"]:
                            if slevel not in m["spellcasting"][0]["spells"]:
                                m["spellcasting"][0]["spells"][slevel] = { "spells": [] }
                            for spell in ms["spells"][slevel]["spells"]:
                                if spell not in m["spellcasting"][0]["spells"][slevel]["spells"]:
                                    m["spellcasting"][0]["spells"][slevel]["spells"].append(spell)
                    else:
                        if "will" in ms:
                            spell_type = "will"
                            for spell in ms[spell_type]:
                                if spell not in m["spellcasting"][0][spell_type]:
                                    m["spellcasting"][0][spell_type].append(spell)
                        else:
                            spell_type = "daily"
                            for slevel in ms[spell_type]:
                                for spell in ms[spell_type][slevel]:
                                    if spell not in m["spellcasting"][0][spell_type][slevel]:
                                        m["spellcasting"][0][spell_type][slevel].append(spell)
                elif ms["mode"] == "replaceSpells":
                    if "spells" in ms:
                        for slevel in ms["spells"]:
                            for spell in ms["spells"][slevel]:
                                if spell["replace"] not in m["spellcasting"][0]["spells"][slevel]["spells"]:
                                    m["spellcasting"][0]["spells"][slevel]["spells"].append(spell["with"])
                                else:
                                    for i in range(len(m["spellcasting"][0]["spells"][slevel]["spells"])):
                                        if m["spellcasting"][0]["spells"][slevel]["spells"][i] == spell["replace"]:
                                            m["spellcasting"][0]["spells"][slevel]["spells"][i] = spell["with"]
                    else:
                        if "will" in ms:
                            spell_type = "will"
                            for spell in ms[spell_type]:
                                if spell["replace"] not in m["spellcasting"][0][spell_type]:
                                    m["spellcasting"][0][spell_type].append(spell["with"])
                                else:
                                    for i in range(len(m["spellcasting"][0][spell_type])):
                                        if m["spellcasting"][0][spell_type][i] == spell["replace"]:
                                            m["spellcasting"][0][spell_type][i] == spell["with"]

                        else:
                            spell_type = "daily"
                            for slevel in ms[spell_type]:
                                for spell in ms[spell_type][slevel]:
                                    if spell["replace"] not in m["spellcasting"][0][spell_type][slevel]:
                                        m["spellcasting"][0][spell_type][slevel].append(spell["with"])
                                    else:
                                        for i in range(len(m["spellcasting"][0][spell_type][slevel])):
                                            if m["spellcasting"][0][spell_type][slevel][i] == spell["replace"]:
                                                m["spellcasting"][0][spell_type][slevel][i] == spell["with"]
                else:
                    print("Unhandled _ mod: " + ms["mode"])
                    print(m["name"],m["source"])
        else:
            print("Unhandled mod: " + mod)
            print(m["name"],m["source"])
    return m

def modifyItem(m,mods):
    for mod in mods:
        if mod == 'entries':
            if mod not in m:
                m[mod] = []
            m[mod] = modList(m[mod],mods[mod])
        else:
            print("Unhandled mod: " + mod)
    return m

def modTraits(trait,mod):
    if type(mod) == list:
        for mt in range(len(mod)):
            trait = modTraits(trait,mod[mt])
    else:
        if mod == "remove":
            del trait[:]
        elif mod['mode'] == "prependArr":
            if type(mod['items']) == list:
                for item in reversed(mod['items']):
                    trait.insert(0,item)
            else:
                trait.insert(0,mod['items'])
        elif mod['mode'] == "insertArr":
            trait.insert(mod['index'],mod['items'])
        elif mod['mode'] == "appendArr":
            if type(mod['items']) == list:
                trait.extend(mod['items'])
            else:
                trait.append(mod['items'])
        elif mod['mode'] == "replaceOrAppendArr" or mod['mode'] == "replaceArr":
            for t in range(len(trait)):
                if trait[t]['name'] == mod['replace']:
                    del trait[t]
                    if type(mod["items"]) == list:
                        for item in mod["items"]:
                            trait.insert(t,item)
                    else:
                        trait.insert(t,mod["items"])
                    break
        elif mod['mode'] == "removeArr":
            trait = [ t for t in trait if t['name'] not in mod['names'] ]
        elif mod['mode'] == 'replaceTxt':
            for t in trait:
                f = ""
                if "flags" in mod:
                    f = mod["with"]
                t["entries"] = modRepl(t["entries"],mod["replace"],mod["with"],f)
        elif mod['mode'] == 'scalarAddHit':
            for t in range(len(trait)):
                for i in range(len(trait[t]["entries"])):
                    def iterDict(d):
                        if type(d) == dict:
                            for k,v in d.items():
                                d[k] = iterDict(v)
                        elif type(d) == list:
                            for i in range(len(d)):
                                d[i] = iterDict(d[i])
                        elif type(d) == str:
                            for match in re.finditer(r'{@hit ([-+0-9]*)}',d):
                                toHit = int(match.group(1)) + mod['scalar']
                                d = modRepl(d,match.group(0),"{{@hit {:+d}}}".format(toHit),"")
                        return d
                    trait[t]["entries"][i] = iterDict(trait[t]["entries"][i])
        elif mod['mode'] == 'scalarAddDc':
            for t in range(len(trait)):
                for i in range(len(trait[t]["entries"])):
                    def iterDict(d):
                        if type(d) == dict:
                            for k,v in d.items():
                                d[k] = iterDict(v)
                        elif type(d) == list:
                            for i in range(len(d)):
                                d[i] = iterDict(d[i])
                        elif type(d) == str:
                            for match in re.finditer(r'{@dc ([-+0-9]*)}',d):
                                dc = int(match.group(1)) + mod['scalar']
                                d = modRepl(d,match.group(0),"{{@dc {:d}}}".format(dc),"")
                        return d
                    trait[t]["entries"][i] = iterDict(trait[t]["entries"][i])
        else:
            print("Unhandled tmode: " + mod['mode'],mod)
    return trait

def modList(items,mod):
    if type(mod) == list:
        for mt in range(len(mod)):
            items = modList(items,mod[mt])
    else:
        if mod == "remove":
            del items[:]
        elif mod['mode'] == "appendArr" or mod['mode'] == "appendIfNotExistsArr":
            if type(mod["items"]) == list:
                items.extend(mod["items"])
            else:
                items.append(mod['items'])
        elif mod['mode'] == "replaceOrAppendArr" or mod['mode'] == "replaceArr":
            for i in range(len(items)):
                if 'name' in items[i] and items[i]['name'] == mod['replace']:
                    del items[i]
                    if type(mod["items"]) == list:
                        for item in mod["items"]:
                            items.insert(i,item)
                    else:
                        items.insert(i,mod["items"])
                    break
        elif mod['mode'] == "removeArr":
            if 'names' in mod:
                items = [ item for item in items if item not in mod['names'] ]
            elif 'items' in mod:
                items = [ item for item in items if type(item) != str or item not in mod['items'] ]
            else:
                print("Unhandled mode: " + mod['mode'],mod)
        elif mod['mode'] == 'insertArr':
            if type(mod['items']) == list:
                for item in reversed(mod['items']):
                    items.insert(mod['index'],item)
            else:
                items.insert(mod['index'],mod['items'])
        elif mod['mode'] == 'scalarAddHit':
            for i in range(len(items)):
                if type(items[i]) == dict and "entries" in items[i]:
                    for e in range(len(items[i]["entries"])):
                        if type(items[i]["entries"][e]) == dict and "entries" in items[i]["entries"][e]:
                            for e2 in range(len(items[i]["entries"][e]["entries"])):
                                for match in re.finditer(r'{@hit ([-+0-9]*)}',items[i]["entries"][e]["entries"][e2]):
                                    toHit = int(match.group(1)) + mod['scalar']
                                    items[i]["entries"][e]["entries"][e2] = modRepl(items[i]["entries"][e]["entries"][e2],match.group(0),"{{@hit {:+d}}}".format(toHit),"")
                        else:
                            for match in re.finditer(r'{@hit ([-+0-9]*)}',items[i]["entries"][e]):
                                toHit = int(match.group(1)) + mod['scalar']
                                items[i]["entries"][e] = modRepl(items[i]["entries"][e],match.group(0),"{{@hit {:+d}}}".format(toHit),"")
                elif type(items[i]) == dict and "headerEntries" in items[i]:
                    for e in range(len(items[i]["headerEntries"])):
                        for match in re.finditer(r'{@hit ([-+0-9]*)}',items[i]["headerEntries"][e]):
                            toHit = int(match.group(1)) + mod['scalar']
                            items[i]["headerEntries"][e] = modRepl(items[i]["headerEntries"][e],match.group(0),"{{@hit {:+d}}}".format(toHit),"")
                else:
                    for match in re.finditer(r'{@hit ([-+0-9]*)}',items[i]):
                        toHit = int(match.group(1)) + mod['scalar']
                        items[i] = modRepl(items[i],match.group(0),"{{@hit {:+d}}}".format(toHit),"")
        elif mod['mode'] == 'scalarAddDc':
            for i in range(len(items)):
                if type(items[i]) == dict and "entries" in items[i]:
                    for e in range(len(items[i]["entries"])):
                        if type(items[i]["entries"][e]) == dict and "entries" in items[i]["entries"][e]:
                            for e2 in range(len(items[i]["entries"][e]["entries"])):
                                for match in re.finditer(r'{@dc ([-+0-9]*)}',items[i]["entries"][e]["entries"][e2]):
                                    dc = int(match.group(1)) + mod['scalar']
                                    items[i]["entries"][e]["entries"][e2] = modRepl(items[i]["entries"][e]["entries"][e2],match.group(0),"{{@dc {:+d}}}".format(dc),"")
                        else:
                            for match in re.finditer(r'{@dc ([-+0-9]*)}',items[i]["entries"][e]):
                                dc = int(match.group(1)) + mod['scalar']
                                items[i]["entries"][e] = modRepl(items[i]["entries"][e],match.group(0),"{{@dc {:d}}}".format(dc),"")
                elif type(items[i]) == dict and "headerEntries" in items[i]:
                    for e in range(len(items[i]["headerEntries"])):
                        for match in re.finditer(r'{@dc ([-+0-9]*)}',items[i]["headerEntries"][e]):
                            dc = int(match.group(1)) + mod['scalar']
                            items[i]["headerEntries"][e] = modRepl(items[i]["headerEntries"][e],match.group(0),"{{@dc {:d}}}".format(dc),"")
                else:
                    for match in re.finditer(r'{@dc ([-+0-9]*)}',items[i]):
                        dc = int(match.group(1)) + mod['scalar']
                        items[i] = modRepl(items[i],match.group(0),"{{@dc {:d}}}".format(dc),"")
        else:
            print("Unhandled mode: " + mod['mode'],mod)
    return items

def modRepl(s,r,w,f):
    if type(s) == str:
        if "i" in f:
            repl = re.compile(r,re.IGNORECASE)
        else:
            repl = re.compile(r)
        s = repl.sub(w,s)
    elif type(s) == list:
        for i in range(len(s)):
            s[i] = modRepl(s[i],r,w,f)
    elif type(s) == dict:
        for i in s:
            s[i] = modRepl(s[i],r,w,f)
    return s

def fixTags(s,m,nohtml=False):
    if '×' in s:
        s=s.replace('×','x')
    if '{=' in s:
        def propRepl(matchobj):
            if matchobj.group(1) in m:
                flags = matchobj.group(2)
                if matchobj.group(1) == 'dmgType':
                    if m[matchobj.group(1)] == 'B':
                        return "bludgeoning"
                    elif m[matchobj.group(1)] == 'P':
                        return "piercing"
                    elif m[matchobj.group(1)] == 'S':
                        return "slashing"
                repl = m[matchobj.group(1)]
                if not flags == None:
                    if 'a' in flags:
                        if repl[0].lower() in 'aeiou':
                            repl = 'an'
                        else:
                            repl = 'a'
                    if 'l' in flags:
                        repl = repl.lower()
                    if 't' in flags:
                        repl = repl.title()
                return repl
            else:
                return matchobj.group(1)
        s = re.sub(r'{=(.*?)([/].*?)?}', propRepl, s)
    if not nohtml:
        s = re.sub(r'{@([bi]) (.*?)}',r'<\1>\2</\1>', s)
        s = re.sub(r'{@italic (.*?)}',r'<i>\1</i>', s)
        s = re.sub(r'{@spell (.*?)}', r'<spell>\1</spell>', s)
        s = re.sub(r'{@link (.*?)\|(.*?)?}', r'<a href="\2">\1</a>', s)
        def createMLink(matchobj):
            return "<a href=\"/monster/{}\">{}</a>".format(slugify(matchobj.group(1)),matchobj.group(2))
        s = re.sub(r'{@creature (.*?)\|\|(.*?)?}', createMLink, s)
        s = re.sub(r'{@creature (.*?)(\|.*?)?}', r'<monster>\1</monster>', s)
        s = re.sub(r'{@item (.*?)(\|.*?)?}', r'<item>\1</item>', s)
    else:
        s = re.sub(r'{@link (.*?)\|(.*?)?}', r'\1 (\2)', s)

    if '{@' in s:
        s = remove5eShit(s)

    name = m['name']
    if 'original_name' in m:
        s = re.sub(re.escape(m['original_name']),name,s,flags=re.I)

    if '<$' not in s:
        return s

    if 'isNpc' in m and m['isNpc']:
        nameparts = name.split(" ")
        name = nameparts[0]
    s = re.sub(re.escape('<$title_name$>'), name, s)
    s = re.sub(re.escape('<$short_name$>'), name, s)
    s = re.sub(re.escape('<$damage_avg__2.5+str$>'), "{:d}".format(math.floor(2.5+getAbilityMod(m["str"]))), s)
    s = re.sub(re.escape('<$damage_mod__str$>'), " {:+d}".format(getAbilityMod(m["str"])) if getAbilityMod(m["str"]) != 0 else "", s)
    s = re.sub(re.escape('<$spell_dc__cha$>'), "{:d}".format(8+crToP(m["cr"])+getAbilityMod(m["cha"])), s)
    s = re.sub(re.escape('<$to_hit__str$>'), "{:+d}".format(crToP(m["cr"])+getAbilityMod(m["str"])), s)

    if re.search(r'{[@=](.*?)}',s):
        s = fixTags(s,m)

    return s

def crToP(cr):
    if "/" in cr:
        fraction = list(map(float,cr.split("/",2)))
        cr = fraction[0]/fraction[1]
    else:
        cr = float(cr)
    return math.ceil(1+cr/4)

def getAbilityMod(score):
    return math.floor((float(score)-10)/2)

def multiCR(cr,scale):
    if type(cr) == dict:
        for k in cr:
            cr[k] = multiCR(cr[k],scale)
    else:
        if "/" in cr:
            fraction = list(map(float,cr.split("/",2)))
            cr = fraction[0]/fraction[1]
        else:
            cr = float(cr)
        cr = cr * scale
        if cr < 0.125:
            cr = "0"
        elif cr < 0.25:
            cr = "1/8"
        elif cr < 0.5:
            cr = "1/4"
        elif cr < 1:
            cr = "1/2"
        else:
            cr = '{:.0f}'.format(cr)
    return cr

def appendFluff(fluff,m,t='monsterFluff',nohtml=False):
    entries = []
    for f in fluff[t]:
        if f['name'] == m:
            if 'entries' in f:
                for e in f['entries']:
                    if type(e) == dict and 'entries' in e and any('entries' in se for se in e['entries']):
                        for se in e['entries']:
                            if type(se) == dict and 'entries' in se:
                                if 'name' in se:
                                    if nohtml:
                                        entries.append("{}".format(se['name']))
                                    else:
                                        entries.append("<b>{}</b>".format(se['name']))
                                entries += (se['entries'])
                    else:
                        entries.append(e)
            elif "_copy" in f:
                entries = appendFluff(fluff,f['_copy']['name'],t,nohtml)
            if "_appendCopy" in f:
                entries = entries + appendFluff(fluff,f['_appendCopy']['name'],t,nohtml)
    return entries

def findFluffImage(fluff,m,t='monsterFluff'):
    for f in fluff[t]:
        if f['name'] == m:
            if 'images' in f and f['images']:
                for image in f['images']:
                    if 'href' in image and 'path' in image['href']:
                        return image['href']['path']
            elif "_copy" in f:
                return findFluffImage(fluff,(f['_copy']['name']),t)
    return None


def getFriendlySource(source,args=None):
    friendly = source
    allbooks = [ "./data/books.json", "./data/adventures.json" ]
    srcfound = True
    if source == "TftYP":
        friendly = "Tales from the Yawning Portal"
    elif source == "PSA":
        friendly = "Plane Shift: Amonkhet"
    elif source == "PSD":
        friendly = "Plane Shift: Dominaria"
    elif source == "PSI":
        friendly = "Plane Shift: Innistrad"
    elif source == "PSK":
        friendly = "Plane Shift: Kaladesh"
    elif source == "PSX":
        friendly = "Plane Shift: Ixalan"
    elif source == "PSZ":
        friendly = "Plane Shift: Zendikar"
    elif source == "Mag":
        friendly = "Dragon Magazine"
    elif source == "MFF":
        friendly = "Mordenkainen’s Fiendish Folio"
    elif source == "Stream":
        friendly = "Livestream"
    elif source == "EEPC":
        friendly = "Elemental Evil Player's Companion"
    elif source == "RoTOS":
        friendly = "The Rise of Tiamat Online Supplement"
    elif source == "EET":
        friendly = "Elemental Evil: Trinkets"
    elif source == "UAWGE":
        friendly = "Wayfinder's Guide to Eberron"
    elif source == "SADS":
        friendly = "Sapphire Anniversary Dice Set"
    elif source == "AWM":
        friendly = "Adventure with Muk"
    elif source == "OGA":
        friendly = "One Grung Above"
    elif source == "Twitter":
        friendly = "Twitter"
    elif source == "ESK":
        friendly = "Essentials Kit"
    elif source == "TCE":
        friendly = "Tasha's Cauldron of Everything"
    elif source.startswith("UA"):
        friendly = re.sub(r"(\w)([A-Z])", r"\1 \2", friendly)
        friendly = re.sub(r"U A", r"Unearthed Arcana: ", friendly)
    elif source.startswith("AL"):
        friendly = re.sub(r"(\w)([A-Z])", r"\1 \2", friendly)
        friendly = re.sub(r"A L", r"Adventurers League: ", friendly)
    else:
        srcfound = False
    if args and args.filemeta and 'sources' in args.filemeta:
        for metasource in args.filemeta['sources']:
            if metasource['json'] == source:
                friendly = metasource['full']
                srcfound = True
                break
    for books in allbooks:
        if srcfound:
            break
        try:
            with open(books,encoding='utf-8') as f:
                bks = json.load(f)
                f.close()
            key = list(bks.keys())[0]
            for bk in bks[key]:
                if bk['source'] == source:
                    friendly = bk['name']
                    srcfound = True
                    break
        except IOError as e:
            print ("Could not determine source friendly names ({}): {}".format(e.errno, e.strerror))
    if not srcfound:
        print("Could not find source: " + source)
    return friendly

def getPublishedSources():
    officialsources = []
    for books in [ "./data/books.json", "./data/adventures.json" ]:
        with open(books,encoding='utf-8') as f:
            bks = json.load(f)
            f.close()
        key = list(bks.keys())[0]
        for bk in bks[key]:
            officialsources.append(bk['source'])
    return officialsources

def getEntryString(e,m,args):
    if type(e) == dict:
        text = ""
        if 'name' in e:
            if e["type"] == "section":
                if args.nohtml:
                    text += "{}\n".format(fixTags(e['name'],m,args.nohtml))
                else:
                    text += "<b>{}</b>\n".format(fixTags(e['name'],m,args.nohtml))
            elif e["type"] != "item":
                if args.nohtml:
                    text += "{}. ".format(fixTags(e['name'],m,args.nohtml))
                else:
                    text += "<i>{}.</i> ".format(fixTags(e['name'],m,args.nohtml))
        if e["type"] == "entries" or e["type"] == "section" or e["type"] == "variantSub":
            text += getEntryString(e["entries"],m,args)
        elif e["type"] == "variantInner":
            text += "\n"+getEntryString(e["entries"],m,args)
        elif e['type'] == 'table':
            if 'caption' in e:
                if args.nohtml:
                    text += "{}\n".format(e['caption'])
                else:
                    text += "<i>{}</i>\n".format(e['caption'])
            text += " | ".join(
                [fixTags(x,m,args.nohtml) for x in e['colLabels']]) + "\n"
            for row in e['rows']:
                rowthing = []
                for r in row:
                    if isinstance(r, dict) and 'roll' in r:
                        rowthing.append(
                            "{}-{}".format(
                                r['roll']['min'],
                                r['roll']['max']) if 'min' in r['roll'] else str(
                                r['roll']['exact']))
                    else:
                        rowthing.append(getEntryString(r,m,args))
                text += " | ".join(rowthing) + "\n"
        elif e["type"] == "item" or e["type"] == "itemSub":
            if "entry" not in e and "entries" in e:
                e["entry"] = getEntryString(e["entries"],m,args)
            if args.nohtml:
                text += "• {} {}".format(e["name"]+(":" if e["name"][-1:] not in ".:" else ""),getEntryString(e["entry"],m,args))
            else:
                text += "• <b>{}</b> {}".format(e["name"]+(":" if e["name"][-1:] not in ".:" else ""),getEntryString(e["entry"],m,args))
        elif e["type"] == "list":
            if "style" in e and e["style"] == "list-hang-notitle":
                text += getEntryString(e["items"],m,args)
            elif "style" in e and e["style"] == "no-bullets":
                text += getEntryString(e["items"],m,args)
            else:
                text += "\n".join(["• {}".format(getEntryString(x,m,args)) for x in e["items"]])
        elif e["type"] == "inset":
            if "name" in e:
                text += "\n"
            if args.nohtml:
                text += "------\n{}\n------".format(getEntryString(e["entries"],m,args))
            else:
                text += "------\n{}\n------".format(getEntryString(e["entries"],m,args))
        elif e["type"] == "insetReadaloud":
            if args.nohtml:
                text += "------\n{}\n------".format(getEntryString(e["entries"],m,args))
            else:
                text += "------\n<i>{}</i>\n------".format(getEntryString(e["entries"],m,args))
        elif e["type"] == "quote":
            if args.nohtml:
                text += "\n{}\n".format(getEntryString(e["entries"],m,args))
                if "by" in e:
                    text += " — {}\n".format(fixTags(e["by"],m,args.nohtml))
            else:
                text += "\n<i>{}</i>\n".format(getEntryString(e["entries"],m,args))
                if "by" in e:
                    text += "<i> — {}</i>\n".format(fixTags(e["by"],m,args.nohtml))
        elif e["type"] == "spellcasting":
            text += "\n".join(fixTags(x,m,args.nohtml) for x in e["headerEntries"])
            if "will" in e:
                text += "\n• At will: " + ", ".join(fixTags(x,m,args.nohtml) for x in e["will"])
            if "daily" in e:
                for k in e["daily"]:
                    if k.endswith("e"):
                        text += "\n• {}/day each: {}".format(k[:-1],", ".join(fixTags(x,m,args.nohtml) for x in e["daily"][k]))
                    else:
                        text += "\n• {}/day: {}".format(k,", ".join(fixTags(x,m,args.nohtml) for x in e["daily"][k]))
            if "footerEntries" in e:
                text += "\n".join(fixTags(x,m,args.nohtml) for x in e["footerEntries"])
        elif e["type"] == "inline":
            text += "".join([getEntryString(x,m,args) for x in e["entries"]])
        elif e["type"] == "link":
            if args.nohtml or e["href"]["type"] == "internal":
                return e["text"]
            else:
                return "<a href=\"{}\">{}</a>".format(e["href"]["url"],e["text"])
        else:
            print("dont know type",e["type"])
            print(e)
        return text
    elif type(e) == list:
        return "\n".join([getEntryString(x,m,args) for x in e])
    else:
        return fixTags(str(e),m,args.nohtml)