public static void addSpellsToClassForLevels( PlayerCharacter pc, Domain d, PCClass aClass, int minLevel, int maxLevel) { if (aClass == null) { return; } for (int aLevel = minLevel; aLevel <= maxLevel; aLevel++) { Collection<Spell> domainSpells = pc.getSpellsIn(d.get(ObjectKey.DOMAIN_SPELLLIST), aLevel); for (Spell spell : domainSpells) { List<CharacterSpell> slist = pc.getCharacterSpells(aClass, spell, Globals.getDefaultSpellBook(), aLevel); boolean flag = true; for (CharacterSpell cs1 : slist) { flag = !(cs1.getOwner().equals(d)); if (!flag) { break; } } if (flag) { CharacterSpell cs = new CharacterSpell(d, spell); cs.addInfo(aLevel, 1, Globals.getDefaultSpellBook()); pc.addCharacterSpell(aClass, cs); } } } }
/** * Sets the locked flag on a PC * * @param pc */ public static void applyDomain(PlayerCharacter pc, Domain d) { ClassSource source = pc.getDomainSource(d); PCClass aClass = pc.getClassKeyed(source.getPcclass().getKeyName()); if (aClass != null) { int maxLevel; for (maxLevel = 0; maxLevel < 10; maxLevel++) { if (pc.getSpellSupport(aClass).getCastForLevel(maxLevel, pc) == 0) { break; } } if (maxLevel > 0) { addSpellsToClassForLevels(pc, d, aClass, 0, maxLevel - 1); } if ((maxLevel > 1) && (aClass.getSafe(IntegerKey.KNOWN_SPELLS_FROM_SPECIALTY) == 0)) { DomainSpellList domainSpellList = d.get(ObjectKey.DOMAIN_SPELLLIST); final List<Spell> aList = pc.getAllSpellsInLists(Collections.singletonList(domainSpellList)); for (Spell gcs : aList) { if (SpellLevel.getFirstLvlForKey(gcs, domainSpellList, pc) < maxLevel) { pc.setDomainSpellCount(aClass, 1); break; } } } } Collection<CDOMReference<Spell>> mods = d.getSafeListMods(Spell.SPELLS); for (CDOMReference<Spell> ref : mods) { Collection<Spell> spells = ref.getContainedObjects(); Collection<AssociatedPrereqObject> assoc = d.getListAssociations(Spell.SPELLS, ref); for (AssociatedPrereqObject apo : assoc) { if (!PrereqHandler.passesAll(apo.getPrerequisiteList(), pc, d)) { continue; } for (Spell s : spells) { String book = apo.getAssociation(AssociationKey.SPELLBOOK); List<CharacterSpell> aList = pc.getCharacterSpells(aClass, s, book, -1); if (aList.isEmpty()) { Formula times = apo.getAssociation(AssociationKey.TIMES_PER_UNIT); CharacterSpell cs = new CharacterSpell(d, s); int resolvedTimes = times.resolve(pc, d.getQualifiedKey()).intValue(); cs.addInfo(1, resolvedTimes, book); pc.addCharacterSpell(aClass, cs); } } } } }
/** * Remove any spells granted by the domain to the class. * * @param pc The character. * @param domain The domain. * @param aClass The class which would have the spells allocated. */ public static void removeSpellsFromClassForLevels( PlayerCharacter pc, Domain domain, PCClass aClass) { if (aClass == null) { return; } Collection<? extends CharacterSpell> characterSpells = pc.getCharacterSpells(aClass); for (CharacterSpell characterSpell : characterSpells) { if (characterSpell.getOwner() == domain) { pc.removeCharacterSpell(aClass, characterSpell); } } }
private void buildKnownPreparedSpellsForCDOMObject(CDOMObject pObject) { Collection<? extends CharacterSpell> sp = charDisplay.getCharacterSpells(pObject); List<CharacterSpell> cSpells = new ArrayList<>(sp); // Add in the spells granted by objects pc.addBonusKnownSpellsToList(pObject, cSpells); PCClass pcClass = (PCClass) (pObject instanceof PCClass ? pObject : null); for (CharacterSpell charSpell : cSpells) { for (SpellInfo spellInfo : charSpell.getInfoList()) { // Create SpellNodeImpl for each spell String book = spellInfo.getBook(); boolean isKnown = Globals.getDefaultSpellBook().equals(book); SpellFacadeImplem spellImplem = new SpellFacadeImplem(pc, charSpell.getSpell(), charSpell, spellInfo); SpellNodeImpl node; if (pcClass != null) { node = new SpellNodeImpl( spellImplem, pcClass, String.valueOf(spellInfo.getActualLevel()), getRootNode(book)); } else { node = new SpellNodeImpl( spellImplem, String.valueOf(spellInfo.getActualLevel()), getRootNode(book)); } if (spellInfo.getTimes() > 1) { node.addCount(spellInfo.getTimes() - 1); } boolean isSpellBook = charDisplay.getSpellBookByName(book).getType() == SpellBook.TYPE_SPELL_BOOK; // Add to list if (isKnown) { allKnownSpellNodes.addElement(node); knownSpellNodes.addElement(node); } else if (isSpellBook) { bookSpellNodes.addElement(node); } else if (pObject instanceof Race) { allKnownSpellNodes.addElement(node); } else { preparedSpellNodes.addElement(node); } } } }
/** * Add a spell to the named book for the character. The request will be validated and any errors * shown to the user by the UIDelegate. * * @param spell The spell to be added. * @param bookName The book to add the spell to. * @param metamagicFeats List of the metamagic feats that should be applied to this spell. * @return The new SpellNode, or null if the selection was invalid. */ private SpellNode addSpellToCharacter( SpellNode spell, String bookName, List<Ability> metamagicFeats) { if (!(spell.getSpell() instanceof SpellFacadeImplem)) { return null; } if (spell.getSpellcastingClass() == null) { return null; } CharacterSpell charSpell = ((SpellFacadeImplem) spell.getSpell()).getCharSpell(); if (charSpell == null) { return null; } int level = Integer.parseInt(spell.getSpellLevel()); for (Ability ability : metamagicFeats) { level += ability.getSafe(IntegerKey.ADD_SPELL_LEVEL); } String errorMsg = pc.addSpell( charSpell, metamagicFeats, spell.getSpellcastingClass().getKeyName(), bookName, level, level); if (!StringUtils.isEmpty(errorMsg)) { delegate.showErrorMessage(Constants.APPLICATION_NAME, errorMsg); return null; } SpellInfo spellInfo = charSpell.getSpellInfoFor(bookName, level, metamagicFeats); boolean isKnown = Globals.getDefaultSpellBook().equals(bookName); SpellFacadeImplem spellImplem = new SpellFacadeImplem(pc, charSpell.getSpell(), charSpell, spellInfo); SpellNodeImpl node = new SpellNodeImpl( spellImplem, spell.getSpellcastingClass(), String.valueOf(spellInfo.getActualLevel()), getRootNode(bookName)); return node; }