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); } } } }
/* * @see TestCase#tearDown() */ @Override protected void tearDown() throws Exception { Globals.getContext().getReferenceContext().forget(divineClass); Globals.getContext().getReferenceContext().forget(arcaneClass); super.tearDown(); }
/* (non-Javadoc) * @see pcgen.AbstractCharacterTestCase#setUp() */ @Override protected void setUp() throws Exception { super.setUp(); dataset = new MockDataSetFacade(); dataset.addEquipmentLocation(new BodyStructure(Constants.EQUIP_LOCATION_EQUIPPED, true)); dataset.addEquipmentLocation(new BodyStructure(LOC_HANDS, false)); dataset.addEquipmentLocation(new BodyStructure(LOC_BODY, false)); if (SystemCollections.getUnmodifiableEquipSlotList().isEmpty()) { EquipSlot equipSlot = new EquipSlot(); equipSlot.setSlotName(SLOT_WEAPON); equipSlot.addContainedType("Weapon"); equipSlot.setContainNum(1); equipSlot.setSlotNumType("HANDS"); SystemCollections.addToEquipSlotsList(equipSlot, SettingsHandler.getGame().getName()); Globals.setEquipSlotTypeCount("HANDS", "2"); equipSlot = new EquipSlot(); equipSlot.setSlotName(SLOT_RING); equipSlot.addContainedType("Ring"); equipSlot.setContainNum(2); equipSlot.setSlotNumType("BODY"); SystemCollections.addToEquipSlotsList(equipSlot, SettingsHandler.getGame().getName()); Globals.setEquipSlotTypeCount("BODY", "1"); } uiDelegate = new MockUIDelegate(); }
/* (non-Javadoc) * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override public int passes(final Prerequisite prereq, final CharacterDisplay display, CDOMObject source) { // // If game mode doesn't support alignment, then pass the prereq // int runningTotal = 0; if (Globals.getGameModeAlignmentText().length() == 0) { runningTotal = 1; } else { CDOMSingleRef<PCAlignment> deityAlign = null; // $NON-NLS-1$ Deity deity = display.getDeity(); if (deity != null) { deityAlign = deity.get(ObjectKey.ALIGNMENT); } if (deityAlign != null) { String desiredAlignIdentifier = prereq.getOperand(); PCAlignment desiredAlign = getPCAlignment(desiredAlignIdentifier); if (desiredAlign.equals(deityAlign.get())) { runningTotal = 1; } } } return countedTotal(prereq, runningTotal); }
/** * Test to ensure that a character will fail a test if it does not have the correct number of * levels in the class. * * @throws Exception */ public void testCharWithMultipleSpellClasses() throws Exception { LoadContext context = Globals.getContext(); final PCClass pcClass = new PCClass(); pcClass.setName("MyClass"); context.unconditionallyProcess(pcClass, "SPELLSTAT", "CHA"); pcClass.put(StringKey.SPELLTYPE, "ARCANE"); context.unconditionallyProcess(pcClass.getOriginalClassLevel(1), "CAST", "5,4"); final PCClass pcClass2 = new PCClass(); pcClass2.setName("Other Class"); context.unconditionallyProcess(pcClass2, "SPELLSTAT", "INT"); pcClass2.put(StringKey.SPELLTYPE, "ARCANE"); context.unconditionallyProcess(pcClass2.getOriginalClassLevel(1), "CAST", "5,4"); final PlayerCharacter character = getCharacter(); setPCStat(character, cha, 12); setPCStat(character, intel, 12); character.incrementClassLevel(1, pcClass); character.incrementClassLevel(2, pcClass2); final PreClassParser producer = new PreClassParser(); final Prerequisite prereq = producer.parse("CLASS", "1,SPELLCASTER.Arcane,SPELLCASTER.Arcane=2", false, false); final PreMult test = new PreMult(); final int passes = test.passes(prereq, character, null); assertEquals(1, passes); }
@Override protected ParseResult parseTokenWithSeparator(LoadContext context, Spell spell, String value) { StringTokenizer aTok = new StringTokenizer(value, Constants.PIPE); boolean first = true; while (aTok.hasMoreTokens()) { String tok = aTok.nextToken(); if (Constants.LST_DOT_CLEAR.equals(tok)) { if (!first) { return new ParseResult.Fail( "Non-sensical use of .CLEAR in " + getTokenName() + ": " + value, context); } context.getObjectContext().removeList(spell, ListKey.RANGE); } else { if (!StringUtil.hasBalancedParens(value)) { return new ParseResult.Fail( "Unbalanced parentheses in " + getTokenName() + " '" + value + "' used in spell " + spell, context); } context.getObjectContext().addToList(spell, ListKey.RANGE, tok); Globals.addSpellRangesSet(tok); } first = false; } return ParseResult.SUCCESS; }
/** @see pcgen.output.base.OutputActor#process(java.lang.Object) */ @Override public TemplateModel process(CDOMObject d) throws TemplateModelException { // TODO Why does a global setting limit the output rather than specifying what is desired? SourceFormat sourceDisplay = Globals.getSourceDisplay(); String sourceString = SourceFormat.getFormattedString(d, sourceDisplay, true); return ObjectWrapper.SIMPLE_WRAPPER.wrap(sourceString); }
/* (non-Javadoc) * @see pcgen.core.facade.SpellSupportFacade#removeSpellList(java.lang.String) */ @Override public void removeSpellList(String spellList) { if (spellList.equalsIgnoreCase(Globals.getDefaultSpellBook())) { Logging.errorPrint( LanguageBundle.getString("InfoSpells.can.not.delete.default.spellbook")); // $NON-NLS-1$ return; } if (pc.delSpellBook(spellList)) { pc.setDirty(true); for (Iterator<SpellNode> iterator = preparedSpellLists.iterator(); iterator.hasNext(); ) { SpellNode listNode = iterator.next(); if (spellList.equals(listNode.getRootNode().getName())) { iterator.remove(); } } for (Iterator<SpellNode> iterator = preparedSpellNodes.iterator(); iterator.hasNext(); ) { SpellNode spell = iterator.next(); if (spellList.equals(spell.getRootNode().getName())) { iterator.remove(); } } } else { Logging.errorPrint("delBookButton:failed "); // $NON-NLS-1$ return; } }
@Override public int getBonus() { String initiativeVar = ControlUtilities.getControlToken(Globals.getContext(), CControl.INITIATIVE); String initiativeStatVar = ControlUtilities.getControlToken(Globals.getContext(), CControl.INITIATIVESTAT); if (initiativeVar == null) { PCStat dex = Globals.getContext() .getReferenceContext() .silentlyGetConstructedCDOMObject(PCStat.class, "DEX"); return display.processOldInitiativeMod() - pc.getStatModFor(dex) + incrementalBonus; } return ((Number) pc.getGlobal(initiativeVar)).intValue() - ((Number) pc.getGlobal(initiativeStatVar)).intValue() + incrementalBonus; }
@Override public SystemAttribute getAttribute() { PCStat stat = Globals.getContext() .getReferenceContext() .silentlyGetConstructedCDOMObject(PCStat.class, "DEX"); return new SystemAttribute("Dexterity", pc.getTotalStatFor(stat)); }
private static String getNumCast(PCClass aClass, int level, PlayerCharacter pc) { String sbook = Globals.getDefaultSpellBook(); final String cast = pc.getSpellSupport(aClass).getCastForLevel(level, sbook, true, false, pc) + pc.getSpellSupport(aClass).getBonusCastForLevelString(level, sbook, pc); return cast; }
@Override public String evaluate(Equipment eq, boolean primary, PlayerCharacter pc) { if (ControlUtilities.hasControlToken(Globals.getContext(), "EQACCHECK")) { Logging.errorPrint( "EQACCHECK term is deprecated (does not function)" + " when ACCHECK CodeControl is used"); } return Integer.toString(eq.getSafe(IntegerKey.AC_CHECK)); }
/** * Returns the unarmed damage String for the Race of the Player Character identified by the given * CharID. * * @param id The CharID identifying the Player Character * @return The unarmed damage String for the Race of the Player Character identified by the given * CharID */ public String getUDamForRace(CharID id) { Race race = raceFacet.get(id); int iSize = formulaResolvingFacet .resolve(id, race.getSafe(FormulaKey.SIZE), race.getQualifiedKey()) .intValue(); SizeAdjustment defAdj = SizeUtilities.getDefaultSizeAdjustment(); SizeAdjustment sizAdj = Globals.getContext() .getReferenceContext() .getSortedList(SizeAdjustment.class, IntegerKey.SIZEORDER) .get(iSize); if (sizAdj != null) { return Globals.adjustDamage("1d3", defAdj, sizAdj); } return "1d3"; }
@Override public String evaluate(PlayerCharacter pc) { Skill skill = Globals.getContext().ref.silentlyGetConstructedCDOMObject(Skill.class, rank); if (skill == null || !pc.hasSkill(skill)) { return "0.0"; } return SkillRankControl.getRank(pc, skill).toString(); }
@Override public int getModifier() { String initiativeVar = ControlUtilities.getControlToken(Globals.getContext(), CControl.INITIATIVE); if (initiativeVar == null) { return pc.getDisplay().processOldInitiativeMod() + incrementalBonus; } return ((Number) pc.getGlobal(initiativeVar)).intValue() + incrementalBonus; }
private PCAlignment getPCAlignment(String desiredAlignIdentifier) { PCAlignment desiredAlign = Globals.getContext() .getReferenceContext() .silentlyGetConstructedCDOMObject(PCAlignment.class, desiredAlignIdentifier); if (desiredAlign == null) { Logging.errorPrint("Unable to find alignment that matches: " + desiredAlignIdentifier); } return desiredAlign; }
/* (non-Javadoc) * @see pcgen.core.facade.SpellSupportFacade#removeKnownSpell(pcgen.core.facade.SpellSupportFacade.SpellNode) */ @Override public void removeKnownSpell(SpellNode spell) { // TODO: This should also remove the spell from books and lists if (removeSpellFromCharacter(spell, Globals.getDefaultSpellBook())) { allKnownSpellNodes.removeElement(spell); knownSpellNodes.removeElement(spell); } updateSpellsTodo(); pcFacade.refreshAvailableTempBonuses(); }
@Override public void setBonus(int bonus) { String initiativeVar = ControlUtilities.getControlToken(Globals.getContext(), CControl.INITIATIVE); if (initiativeVar == null) { this.incrementalBonus = bonus - display.processOldInitiativeMod(); } else { this.incrementalBonus = bonus - ((Number) pc.getGlobal(initiativeVar)).intValue(); } setCurrentInitiative(roll + getModifier() + mod); }
@Override protected void setUp() throws Exception { super.setUp(); Domain goodDomain = new Domain(); goodDomain.setName("Good"); Globals.getContext().ref.importObject(goodDomain); Domain animalDomain = new Domain(); animalDomain.setName("Animal"); Globals.getContext().ref.importObject(animalDomain); deity = new Deity(); deity.setName("Test Deity"); deity.put(ObjectKey.ALIGNMENT, ng); deity.putToList( Deity.DOMAINLIST, CDOMDirectSingleRef.getRef(goodDomain), new SimpleAssociatedObject()); deity.putToList( Deity.DOMAINLIST, CDOMDirectSingleRef.getRef(animalDomain), new SimpleAssociatedObject()); }
public PcgSystemInitiative(PlayerCharacter pc) { this.pc = pc; display = pc.getDisplay(); PCStat stat = Globals.getContext() .getReferenceContext() .silentlyGetConstructedCDOMObject(PCStat.class, "DEX"); this.attribute = new SystemAttribute("Dexterity", pc.getTotalStatFor(stat)); incrementalBonus = 0; die = new Dice(1, 20); }
/** Ensure a character with the requested template correctly passes a wildcard test */ public void test990007_5() { final PlayerCharacter character = getCharacter(); final PCTemplate template = new PCTemplate(); template.setName("Half-Dragon"); Globals.getContext().getReferenceContext().importObject(template); character.addTemplate(template); final PCTemplate template2 = new PCTemplate(); template2.setName("Half-Celestial"); Globals.getContext().getReferenceContext().importObject(template2); character.addTemplate(template2); final Prerequisite prereq = new Prerequisite(); prereq.setKind("template"); prereq.setKey("half%"); prereq.setOperator(PrerequisiteOperator.GTEQ); prereq.setOperand("1"); final boolean passes = PrereqHandler.passes(prereq, character, null); assertTrue(passes); }
/* (non-Javadoc) * @see pcgen.core.facade.SpellSupportFacade#addKnownSpell(pcgen.core.facade.SpellSupportFacade.SpellNode) */ @Override public void addKnownSpell(SpellNode spell) { SpellNode node = addSpellToCharacter(spell, Globals.getDefaultSpellBook(), new ArrayList<>()); if (node != null) { allKnownSpellNodes.addElement(node); knownSpellNodes.addElement(node); if (!StringUtils.isEmpty(charDisplay.getSpellBookNameToAutoAddKnown())) { addToSpellBook(node, charDisplay.getSpellBookNameToAutoAddKnown()); } } updateSpellsTodo(); pcFacade.refreshAvailableTempBonuses(); }
private void updateSpellsTodo() { boolean hasFree = false; for (PCClass aClass : charDisplay.getClassSet()) { if (pc.getSpellSupport(aClass).hasKnownList() || pc.getSpellSupport(aClass).hasKnownSpells(pc)) { int highestSpellLevel = pc.getSpellSupport(aClass).getHighestLevelSpell(pc); for (int i = 0; i <= highestSpellLevel; ++i) { if (pc.availableSpells(i, aClass, Globals.getDefaultSpellBook(), true, false) || pc.availableSpells(i, aClass, Globals.getDefaultSpellBook(), true, true)) { hasFree = true; break; } } } } if (hasFree) { todoManager.addTodo(new TodoFacadeImpl(Tab.SPELLS, "Known", "in_splTodoRemain", 120)); } else { todoManager.removeTodo("in_splTodoRemain"); } }
@Override public Float resolve(PlayerCharacter pc) { if (ControlUtilities.hasControlToken(Globals.getContext(), CControl.EQACCHECK)) { Logging.errorPrint( originalText + " term is deprecated (does not function)" + " when EQACCHECK CodeControl is used"); } if ("".equals(eqKey)) { return 0.0f; } else { final Equipment eq = Globals.getContext() .getReferenceContext() .silentlyGetConstructedCDOMObject(Equipment.class, eqKey); if (eq == null || pc.isProficientWith(eq)) { return 0.0f; } else { return (float) eq.preFormulaAcCheck(pc); } } }
/* (non-Javadoc) * @see junit.framework.TestCase#setUp() */ @Override protected void setUp() throws Exception { super.setUp(); final PlayerCharacter character = getCharacter(); myClass = new PCClass(); myClass.setName("My Class"); knowledge = new Skill(); Globals.getContext().unconditionallyProcess(knowledge, "CLASSES", "My Class"); knowledge.setName("KNOWLEDGE (ARCANA)"); TestHelper.addType(knowledge, "KNOWLEDGE.INT"); character.addSkill(knowledge); SkillRankControl.modRanks(8.0, myClass, true, character, knowledge); }
/* * @see TestCase#setUp() */ @Override protected void setUp() throws Exception { super.setUp(); LoadContext context = Globals.getContext(); SettingsHandler.getGame().setSpellBaseDC("10+SPELLLEVEL+BASESPELLSTAT"); SimpleLoader<BonusSpellInfo> bonusSpellLoader = new SimpleLoader<BonusSpellInfo>(BonusSpellInfo.class); try { URI testURI = new URI("file:/" + getClass().getName() + ".java"); bonusSpellLoader.parseLine(context, "1 BASESTATSCORE:12 STATRANGE:8", testURI); bonusSpellLoader.parseLine(context, "2 BASESTATSCORE:14 STATRANGE:8", testURI); bonusSpellLoader.parseLine(context, "3 BASESTATSCORE:16 STATRANGE:8", testURI); } catch (URISyntaxException e) { throw new UnreachableError(e); } // Human human = new Race(); final BonusObj bon = Bonus.newBonus(context, "FEAT|POOL|2"); human.addToListFor(ListKey.BONUS, bon); arcaneClass = new PCClass(); arcaneClass.setName("TestArcane"); arcaneClass.put(StringKey.SPELLTYPE, "ARCANE"); context.unconditionallyProcess(arcaneClass, "SPELLSTAT", "CHA"); arcaneClass.put(ObjectKey.SPELLBOOK, false); arcaneClass.put(ObjectKey.MEMORIZE_SPELLS, false); context.unconditionallyProcess(arcaneClass.getOriginalClassLevel(1), "KNOWN", "4,2,1"); context.unconditionallyProcess(arcaneClass.getOriginalClassLevel(1), "CAST", "3,1,0"); context.getReferenceContext().importObject(arcaneClass); divineClass = new PCClass(); divineClass.setName("TestDivine"); divineClass.put(StringKey.SPELLTYPE, "DIVINE"); context.unconditionallyProcess(divineClass, "SPELLSTAT", "WIS"); divineClass.put(ObjectKey.SPELLBOOK, false); divineClass.put(ObjectKey.MEMORIZE_SPELLS, true); context.unconditionallyProcess(divineClass.getOriginalClassLevel(1), "CAST", "3,1,0"); context.unconditionallyProcess( divineClass, "SPELLLEVEL", "CLASS|SPELLCASTER.Divine=1|Cure Light Wounds"); context.getReferenceContext().importObject(divineClass); context.resolveDeferredTokens(); context.getReferenceContext().buildDerivedObjects(); context.getReferenceContext().resolveReferences(null); }
@Override public Float resolve(PlayerCharacter pc) { if (ControlUtilities.hasControlToken(Globals.getContext(), "EQACCHECK")) { Logging.errorPrint( originalText + " term is deprecated (does not function)" + " when EQACCHECK CodeControl is used"); } int maxCheck = 0; for (Equipment eq : pc.getEquipmentOfType("Armor", 1)) { maxCheck += eq.preFormulaAcCheck(pc); } return (float) maxCheck; }
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); } } } }
private RootNodeImpl getRootNode(String bookName) { if (Globals.getDefaultSpellBook().equals(bookName)) { return null; } RootNodeImpl rootNode = rootNodeMap.get(bookName); if (rootNode == null) { SpellBook book = charDisplay.getSpellBookByName(bookName); if (book == null) { return null; } rootNode = new RootNodeImpl(book); rootNodeMap.put(bookName, rootNode); } return rootNode; }
private static synchronized void staticSetUp() { if (!staticDone) { SettingsHandler.getGame().clearLoadContext(); AbstractReferenceContext ref = Globals.getContext().getReferenceContext(); t = BuildUtilities.createSize("Tiny", 0); ref.importObject(t); s = BuildUtilities.createSize("Small", 1); ref.importObject(s); m = BuildUtilities.createSize("Medium", 2); m.put(ObjectKey.IS_DEFAULT_SIZE, true); ref.importObject(m); l = BuildUtilities.createSize("Large", 3); ref.importObject(l); h = BuildUtilities.createSize("Huge", 4); ref.importObject(h); staticDone = true; } }