def copy(cls, other: Spellbook): """Makes a copy of a MonsterSpellbook (for adding to init).""" new = other.to_dict() if 'daily' in new: new['daily'] = new['daily'].copy() new['slots'] = new['slots'].copy() return cls.from_dict(new)
def migrate_monster(old_monster): def spaced_to_camel(spaced): return re.sub(r"\s+(\w)", lambda m: m.group(1).upper(), spaced.lower()) for old_key in ('raw_saves', 'raw_skills'): if old_key in old_monster: del old_monster[old_key] if 'spellcasting' in old_monster and old_monster['spellcasting']: old_spellcasting = old_monster.pop('spellcasting') old_monster['spellbook'] = Spellbook( {}, {}, [SpellbookSpell(s) for s in old_spellcasting['spells']], old_spellcasting['dc'], old_spellcasting['attackBonus'], old_spellcasting['casterLevel']).to_dict() else: old_monster['spellbook'] = Spellbook({}, {}, []).to_dict() base_stats = BaseStats(0, old_monster.pop('strength'), old_monster.pop('dexterity'), old_monster.pop('constitution'), old_monster.pop('intelligence'), old_monster.pop('wisdom'), old_monster.pop('charisma')) old_monster['ability_scores'] = base_stats.to_dict() old_saves = old_monster.pop('saves') saves = Saves.default(base_stats) save_updates = {} for save, value in old_saves.items(): if value != saves[save]: save_updates[save] = value saves.update(save_updates) old_monster['saves'] = saves.to_dict() old_skills = old_monster.pop('skills') skills = Skills.default(base_stats) skill_updates = {} for skill, value in old_skills.items(): name = spaced_to_camel(skill) if value != skills[name]: skill_updates[name] = value skills.update(skill_updates) old_monster['skills'] = skills.to_dict() new_monster = Monster.from_bestiary(old_monster) return new_monster
def get_spellbook(self): if self.character_data is None: raise Exception('You must call get_character() first.') # max slots slots = { '1': int(self.character_data.value("AK101") or 0), '2': int(self.character_data.value("E107") or 0), '3': int(self.character_data.value("AK113") or 0), '4': int(self.character_data.value("E119") or 0), '5': int(self.character_data.value("AK124") or 0), '6': int(self.character_data.value("E129") or 0), '7': int(self.character_data.value("AK134") or 0), '8': int(self.character_data.value("E138") or 0), '9': int(self.character_data.value("AK142") or 0) } # spells C96:AH143 potential_spells = self.character_data.value_range("D96:AH143") if self.additional: potential_spells.extend(self.additional.value_range("D17:AH64")) spells = [] for value in potential_spells: value = value.strip() if len(value) > 2 and value not in IGNORED_SPELL_VALUES: log.debug(f"Searching for spell {value}") result, strict = search(compendium.spells, value, lambda sp: sp.name, strict=True) if result and strict: spells.append(SpellbookSpell(result.name, True)) else: spells.append(SpellbookSpell(value.strip())) # dc try: dc = int(self.character_data.value("AB91") or 0) except ValueError: dc = None # sab try: sab = int(self.character_data.value("AI91") or 0) except ValueError: sab = None # spellcasting mod spell_mod_value = self.character_data.value("U91") spell_mod = None if spell_mod_value: # it might be in the form of a ability name, or an int, wjdk try: spell_mod = self.get_stats().get_mod(spell_mod_value) except ValueError: try: spell_mod = int(spell_mod_value) except (TypeError, ValueError): spell_mod = None spellbook = Spellbook(slots, slots, spells, dc, sab, self.total_level, spell_mod) return spellbook
def __init__(self, name: str, stats: BaseStats = None, levels: Levels = None, attacks: AttackList = None, skills: Skills = None, saves: Saves = None, resistances: Resistances = None, spellbook: Spellbook = None, ac: int = None, max_hp: int = None, hp: int = None, temp_hp: int = 0, creature_type: str = None): if stats is None: stats = BaseStats.default() if levels is None: levels = Levels() if attacks is None: attacks = AttackList() if skills is None: skills = Skills.default(stats) if saves is None: saves = Saves.default(stats) if resistances is None: resistances = Resistances() if spellbook is None: spellbook = Spellbook() if hp is None: hp = max_hp # ===== static ===== # all actors have a name self._name = name # ability scores self._stats = stats # at least a total level self._levels = levels # attacks - list of automation actions self._attacks = attacks # skill profs/saving throws self._skills = skills self._saves = saves # defensive resistances self._resistances = resistances # assigned by combatant type self._creature_type = creature_type # ===== dynamic ===== # hp/ac self._ac = ac self._max_hp = max_hp self._hp = hp self._temp_hp = temp_hp # spellbook self._spellbook = spellbook
def from_dict(cls, raw, ctx, combat): if raw['saves']: saves = Saves.from_dict(raw['saves']) else: saves = None inst = cls(raw['name'], raw['controller'], raw['init'], raw['mod'], raw['hpMax'], raw['hp'], raw['ac'], raw['private'], raw['resists'], raw['attacks'], saves, ctx, combat, index=raw['index'], notes=raw['notes'], effects=[], group=raw['group'], # begin backwards compatibility temphp=raw.get('temphp'), spellbook=Spellbook.from_dict(raw.get('spellbook', {}))) inst._effects = [Effect.from_dict(e, combat, inst) for e in raw['effects']] return inst
def from_bestiary(cls, data): for key in ('traits', 'actions', 'reactions', 'legactions'): data[key] = [Trait(**t) for t in data.pop(key)] data['spellcasting'] = Spellbook.from_dict(data.pop('spellbook')) data['saves'] = Saves.from_dict(data['saves']) data['skills'] = Skills.from_dict(data['skills']) data['ability_scores'] = BaseStats.from_dict(data['ability_scores']) data['attacks'] = AttackList.from_dict(data['attacks']) if 'display_resists' in data: data['display_resists'] = Resistances.from_dict( data['display_resists']) return cls(**data)
def get_spellbook(self): if self.character_data is None: raise Exception('You must call get_character() first.') potential_spells = [s for s in self.character_data.get('spells', []) if not s.get('removed', False)] slots = {} for lvl in range(1, 10): num_slots = int(self.calculate_stat(f"level{lvl}SpellSlots")) slots[str(lvl)] = num_slots spell_lists = {} # list_id: (ab, dc, scam) for sl in self.character_data.get('spellLists', []): try: ab_calc = sl.get('attackBonus') ab = int(self.evaluator.eval(ab_calc)) dc = int(self.evaluator.eval(sl.get('saveDC'))) try: scam = self.get_stats().get_mod(next(m for m in STAT_NAMES if m in ab_calc)) except StopIteration: scam = 0 spell_lists[sl['_id']] = (ab, dc, scam) except: pass sab, dc, scam = sorted(spell_lists.values(), key=lambda k: k[0], reverse=True)[0] if spell_lists else (0, 0, 0) spells = [] for spell in potential_spells: spell_list_id = spell['parent']['id'] spell_ab, spell_dc, spell_mod = spell_lists.get(spell_list_id, (None, None, None)) if spell_ab == sab: spell_ab = None if spell_dc == dc: spell_dc = None if spell_mod == scam: spell_mod = None result, strict = search(compendium.spells, spell['name'].strip(), lambda sp: sp.name, strict=True) if result and strict: spells.append(SpellbookSpell.from_spell(result, sab=spell_ab, dc=spell_dc, mod=spell_mod)) else: spells.append(SpellbookSpell(spell['name'].strip(), sab=spell_ab, dc=spell_dc, mod=spell_mod)) spellbook = Spellbook(slots, slots, spells, dc, sab, self.get_levels().total_level, scam) log.debug(f"Completed parsing spellbook: {spellbook.to_dict()}") return spellbook
def get_spellbook(self): if self.character_data is None: raise Exception('You must call get_character() first.') spellnames = [ s.get('name', '') for s in self.character_data.get('spells', []) if not s.get('removed', False) ] slots = {} for lvl in range(1, 10): num_slots = int(self.calculate_stat(f"level{lvl}SpellSlots")) slots[str(lvl)] = num_slots spells = [] for spell in spellnames: result = search(compendium.spells, spell.strip(), lambda sp: sp.name) if result and result[0] and result[1]: spells.append(SpellbookSpell.from_spell(result[0])) else: spells.append(SpellbookSpell(spell.strip())) spell_lists = [(0, 0, 0)] # ab, dc, scam for sl in self.character_data.get('spellLists', []): try: ab_calc = sl.get('attackBonus') ab = int(self.evaluator.eval(ab_calc)) dc = int(self.evaluator.eval(sl.get('saveDC'))) scam = self.get_stats().get_mod( next(m for m in STAT_NAMES if m in ab_calc)) spell_lists.append((ab, dc, scam)) except: pass sab, dc, scam = sorted(spell_lists, key=lambda k: k[0], reverse=True)[0] spellbook = Spellbook(slots, slots, spells, dc, sab, self.get_levels().total_level, scam) log.debug(f"Completed parsing spellbook: {spellbook.to_dict()}") return spellbook
def _get_spellbook(self): spellbook = self.character_data['spellbook'] max_slots = {'1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0} slots = {'1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0} for slot in spellbook['slots']: slots[str(slot['level'])] = slot['remaining'] max_slots[str(slot['level'])] = slot['available'] dcs = [] sabs = [] mods = [] spells = [] for spell in spellbook['spells']: spell_ab = spell['sab'] spell_dc = spell['dc'] spell_mod = spell['mod'] if spell_ab is not None: sabs.append(spell_ab) if spell_dc is not None: dcs.append(spell_dc) if spell_mod is not None: mods.append(spell_mod) result = next((s for s in compendium.spells if s.entity_id == spell['id']), None) if result: spells.append(SpellbookSpell.from_spell(result, sab=spell_ab, dc=spell_dc, mod=spell_mod)) else: spells.append(SpellbookSpell(spell['name'].strip(), sab=spell_ab, dc=spell_dc, mod=spell_mod)) dc = max(dcs, key=dcs.count, default=None) sab = max(sabs, key=sabs.count, default=None) smod = max(mods, key=mods.count, default=None) return Spellbook(slots, max_slots, spells, dc, sab, self._get_levels().total_level, smod)
def parse_critterdb_spellcasting(traits): known_spells = [] usual_dc = (0, 0) # dc, number of spells using dc usual_sab = (0, 0) # same thing caster_level = 1 for trait in traits: if not 'Spellcasting' in trait.name: continue desc = trait.desc level_match = re.search(r"is a (\d+)[stndrh]{2}-level", desc) ab_dc_match = re.search(r"spell save DC (\d+), [+-](\d+) to hit", desc) spells = [] for spell_match in re.finditer( r"(?:(?:(?:\d[stndrh]{2}\slevel)|(?:Cantrip))\s(?:\(.+\))|(?:At will)|(?:\d/day)): (.+)$", desc, re.MULTILINE): spell_texts = spell_match.group(1).split(', ') for spell_text in spell_texts: s = spell_text.strip('* _') spells.append(s.lower()) if level_match: caster_level = max(caster_level, int(level_match.group(1))) if ab_dc_match: ab = int(ab_dc_match.group(2)) dc = int(ab_dc_match.group(1)) if len(spells) > usual_dc[1]: usual_dc = (dc, len(spells)) if len(spells) > usual_sab[1]: usual_sab = (ab, len(spells)) known_spells.extend(s for s in spells if s not in known_spells) dc = usual_dc[0] sab = usual_sab[0] log.debug( f"Lvl {caster_level}; DC: {dc}; SAB: {sab}; Spells: {known_spells}") spells = [SpellbookSpell(s) for s in known_spells] spellbook = Spellbook({}, {}, spells, dc, sab, caster_level) return spellbook
def _get_spellbook(self): spellbook = self.character_data['spellbook'] max_slots = { '1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0 } slots = { '1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0 } for slot in spellbook['slots']: slots[str(slot['level'])] = slot['remaining'] max_slots[str(slot['level'])] = slot['available'] dcs = [] sabs = [] mods = [] spells = [] for spell in spellbook['spells']: spell_ab = spell['sab'] spell_dc = spell['dc'] spell_mod = spell['mod'] spell_prepared = spell['prepared'] or 'noprep' in self.args if spell_ab is not None: sabs.append(spell_ab) if spell_dc is not None: dcs.append(spell_dc) if spell_mod is not None: mods.append(spell_mod) result = compendium.lookup_entity(gamedata.Spell.entity_type, spell['id']) if result: spells.append( SpellbookSpell.from_spell(result, sab=spell_ab, dc=spell_dc, mod=spell_mod, prepared=spell_prepared)) else: spells.append( SpellbookSpell(spell['name'].strip(), sab=spell_ab, dc=spell_dc, mod=spell_mod, prepared=spell_prepared)) dc = max(dcs, key=dcs.count, default=None) sab = max(sabs, key=sabs.count, default=None) smod = max(mods, key=mods.count, default=None) # assumption: a character will only ever have one pact slot level, with a given number of slots of that level pact_slot_level = None num_pact_slots = None max_pact_slots = None if spellbook['pactSlots']: pact_info = spellbook['pactSlots'][0] pact_slot_level = pact_info['level'] max_pact_slots = pact_info['available'] num_pact_slots = max_pact_slots - pact_info['used'] return Spellbook(slots, max_slots, spells, dc, sab, self._get_levels().total_level, smod, pact_slot_level=pact_slot_level, num_pact_slots=num_pact_slots, max_pact_slots=max_pact_slots)
def __init__(self, name: str, size: str, race: str, alignment: str, ac: int, armortype: str, hp: int, hitdice: str, speed: str, ability_scores: BaseStats, cr: str, xp: int, passiveperc: int = None, senses: str = '', vuln: list = None, resist: list = None, immune: list = None, condition_immune: list = None, saves: Saves = None, skills: Skills = None, languages: list = None, traits: list = None, actions: list = None, reactions: list = None, legactions: list = None, la_per_round=3, srd=True, source='homebrew', attacks: AttackList = None, proper: bool = False, image_url: str = None, spellcasting=None, page=None, display_resists: Resistances = None, **_): if vuln is None: vuln = [] if resist is None: resist = [] if immune is None: immune = [] if condition_immune is None: condition_immune = [] if saves is None: saves = Saves.default(ability_scores) if skills is None: skills = Skills.default(ability_scores) if languages is None: languages = [] if traits is None: traits = [] if actions is None: actions = [] if reactions is None: reactions = [] if legactions is None: legactions = [] if attacks is None: attacks = AttackList() if spellcasting is None: spellcasting = Spellbook({}, {}, []) if passiveperc is None: passiveperc = 10 + skills.perception.value try: levels = Levels({"Monster": spellcasting.caster_level or int(cr)}) except ValueError: levels = None resistances = Resistances(vuln=vuln, resist=resist, immune=immune) super(Monster, self).__init__(name=name, stats=ability_scores, attacks=attacks, skills=skills, saves=saves, resistances=resistances, spellbook=spellcasting, ac=ac, max_hp=hp, levels=levels) self.size = size self.race = race self.alignment = alignment self.armortype = armortype self.hitdice = hitdice self.speed = speed self.cr = cr self.xp = xp self.passive = passiveperc self.senses = senses self.condition_immune = condition_immune self.languages = languages self.traits = traits self.actions = actions self.reactions = reactions self.legactions = legactions self.la_per_round = la_per_round self.srd = srd self.source = source self.proper = proper self.image_url = image_url self.page = page # this should really be by source, but oh well # resistances including notes, e.g. "Bludgeoning from nonmagical weapons" self._displayed_resistances = display_resists or resistances
def from_data(cls, data): # print(f"Parsing {data['name']}") _type = parse_type(data['type']) alignment = parse_alignment(data['alignment']) speed = parse_speed(data['speed']) ac = data['ac']['ac'] armortype = data['ac'].get('armortype') or None if not 'special' in data['hp']: hp = data['hp']['average'] hitdice = data['hp']['formula'] else: hp = 0 hitdice = data['hp']['special'] scores = BaseStats(0, data['str'] or 10, data['dex'] or 10, data['con'] or 10, data['int'] or 10, data['wis'] or 10, data['cha'] or 10) if isinstance(data['cr'], dict): cr = data['cr']['cr'] else: cr = data['cr'] # resistances vuln = parse_resists(data['vulnerable'], notated=False) if 'vulnerable' in data else None resist = parse_resists(data['resist'], notated=False) if 'resist' in data else None immune = parse_resists(data['immune'], notated=False) if 'immune' in data else None display_resists = Resistances(*[ parse_resists(data.get(r)) for r in ('resist', 'immune', 'vulnerable') ]) condition_immune = data.get('conditionImmune', []) if 'conditionImmune' in data else None languages = data.get('languages', '').split(', ') if 'languages' in data else None traits = [Trait(t['name'], t['text']) for t in data.get('trait', [])] actions = [Trait(t['name'], t['text']) for t in data.get('action', [])] legactions = [ Trait(t['name'], t['text']) for t in data.get('legendary', []) ] reactions = [ Trait(t['name'], t['text']) for t in data.get('reaction', []) ] skills = Skills.default(scores) skills.update(data['skill']) saves = Saves.default(scores) saves.update(data['save']) scores.prof_bonus = _calc_prof(scores, saves, skills) source = data['source'] proper = bool(data.get('isNamedCreature') or data.get('isNPC')) attacks = AttackList.from_dict(data.get('attacks', [])) spellcasting = data.get('spellcasting', {}) spells = [SpellbookSpell(s) for s in spellcasting.get('spells', [])] spellbook = Spellbook({}, {}, spells, spellcasting.get('dc'), spellcasting.get('attackBonus'), spellcasting.get('casterLevel', 1)) return cls(data['name'], parsesize(data['size']), _type, alignment, ac, armortype, hp, hitdice, speed, scores, cr, xp_by_cr(cr), data['passive'], data.get('senses', ''), vuln, resist, immune, condition_immune, saves, skills, languages, traits, actions, reactions, legactions, 3, data.get('srd', False), source, attacks, spellcasting=spellbook, page=data.get('page'), proper=proper, display_resists=display_resists)
def get_spellbook(self): if self.character_data is None: raise Exception('You must call get_character() first.') spellcasterLevel = 0 castingClasses = 0 spell_mod = 0 pactSlots = 0 pactLevel = 1 hasSpells = False for _class in self.character_data['classes']: castingAbility = _class['definition']['spellCastingAbilityId'] or \ (_class['subclassDefinition'] or {}).get('spellCastingAbilityId') if castingAbility: casterMult = CASTER_TYPES.get(_class['definition']['name'], 1) spellcasterLevel += _class['level'] * casterMult castingClasses += 1 if casterMult else 0 # warlock multiclass fix spell_mod = max(spell_mod, self.stat_from_id(castingAbility)) class_features = { cf['name'] for cf in _class['definition']['classFeatures'] if cf['requiredLevel'] <= _class['level'] } if _class['subclassDefinition']: class_features.update({ cf['name'] for cf in _class['subclassDefinition']['classFeatures'] if cf['requiredLevel'] <= _class['level'] }) hasSpells = 'Spellcasting' in class_features or hasSpells if _class['definition']['name'] == 'Warlock': pactSlots = pact_slots_by_level(_class['level']) pactLevel = pact_level_by_level(_class['level']) if castingClasses > 1: spellcasterLevel = floor(spellcasterLevel) else: if hasSpells: spellcasterLevel = ceil(spellcasterLevel) else: spellcasterLevel = 0 log.debug(f"Caster level: {spellcasterLevel}") slots = {} for lvl in range(1, 10): slots[str(lvl)] = SLOTS_PER_LEVEL[lvl](spellcasterLevel) slots[str(pactLevel)] += pactSlots prof = self.get_stats().prof_bonus save_dc_bonus = max(self.get_stat("spell-save-dc"), self.get_stat("warlock-spell-save-dc")) attack_bonus_bonus = max(self.get_stat("spell-attacks"), self.get_stat("warlock-spell-attacks")) dc = 8 + spell_mod + prof + save_dc_bonus sab = spell_mod + prof + attack_bonus_bonus spellnames = [] for src in self.character_data['classSpells']: spellnames.extend(s['definition']['name'].replace('\u2019', "'") for s in src['spells']) for src in self.character_data['spells'].values(): spellnames.extend(s['definition']['name'].replace('\u2019', "'") for s in src) spells = [] for value in spellnames: result = search(compendium.spells, value, lambda sp: sp.name, strict=True) if result and result[0] and result[1]: spells.append(SpellbookSpell(result[0].name, True)) elif len(value) > 2: spells.append(SpellbookSpell(value)) spellbook = Spellbook(slots, slots, spells, dc, sab, self.get_levels().total_level, spell_mod or None) return spellbook