Пример #1
0
  /**
   * Remove a domain from the character.
   *
   * @param pc The character
   * @param domain The domain.
   */
  public static void removeDomain(PlayerCharacter pc, Domain domain) {
    ClassSource source = pc.getDomainSource(domain);
    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) {
        removeSpellsFromClassForLevels(pc, domain, aClass);
      }

      if ((maxLevel > 1) && (aClass.getSafe(IntegerKey.KNOWN_SPELLS_FROM_SPECIALTY) == 0)) {
        DomainSpellList domainSpellList = domain.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.removeDomainSpellCount(aClass);
            break;
          }
        }
      }
    }

    if (!pc.isImporting()) {
      BonusActivation.deactivateBonuses(domain, pc);
    }
  }
Пример #2
0
  public static void addDomainsUpToLevel(PCClass cl, final int aLevel, final PlayerCharacter aPC) {

    // any domains set by level would have already been saved
    // and don't need to be re-set at level up time
    if (aPC.isImporting()) {
      return;
    }

    /*
     * Note this uses ALL of the domains up to and including this level,
     * because there is the possibility (albeit strange) that the PC was not
     * qualified at a previous level change, but the PlayerCharacter is now
     * qualified for the given Domain. Even this has quirks, since it is
     * only applied at the time of level increase, but I think that quirk
     * should be resolved by a CDOM system around 6.0 - thpr 10/23/06
     */
    for (QualifiedObject<CDOMSingleRef<Domain>> qo : cl.getSafeListFor(ListKey.DOMAIN)) {
      CDOMSingleRef<Domain> ref = qo.getObject(aPC, cl);
      if (ref != null) {
        addDomain(aPC, cl, ref.resolvesTo());
      }
    }
    for (int i = 0; i <= aLevel; i++) {
      // TODO This stinks for really high level characters - can this ever
      // get null back?
      PCClassLevel pcl = aPC.getActiveClassLevel(cl, i);
      for (QualifiedObject<CDOMSingleRef<Domain>> qo : pcl.getSafeListFor(ListKey.DOMAIN)) {
        CDOMSingleRef<Domain> ref = qo.getObject(aPC, cl);
        if (ref != null) {
          addDomain(aPC, cl, ref.resolvesTo());
        }
      }
    }
  }
Пример #3
0
 /**
  * Drives the selection of the AgeSet Kit for a Player Character when relevant changes (change to
  * an AgeSet) are made to a Player Character.
  *
  * <p>Triggered when one of the Facets to which AgeSetKitFacet listens fires a
  * DataFacetChangeEvent to indicate a CDOMObject was added to a Player Character.
  *
  * @param dfce The DataFacetChangeEvent containing the information about the change
  * @see
  *     pcgen.cdom.facet.event.DataFacetChangeListener#dataAdded(pcgen.cdom.facet.event.DataFacetChangeEvent)
  */
 @Override
 public void dataAdded(DataFacetChangeEvent<CharID, Integer> dfce) {
   CharID id = dfce.getCharID();
   AgeSet ageSet = ageSetFacet.get(id);
   PlayerCharacter pc = trackingFacet.getPC(id);
   // TODO Is ageSet null check necessary?
   if (ageSet == null || pc.isImporting()) {
     return;
   }
   int ageSetIndex = ageSetFacet.getAgeSetIndex(id);
   /*
    * TODO The method of storing what AgeSets have had kit selections made
    * should be converted to store the actual AgeSet rather than the index,
    * in order to reduce the number of calls to ageSetFacet.getAgeSetIndex.
    * This (of course) drives the move of the AgeSets for which a kit
    * selection has been made into a Facet. It is possible that the
    * CacheInfo of AgeSetKitFacet is actually a good place to store that
    * information (or it may be implicit with the information already
    * stored there??)
    */
   if (!pc.hasMadeKitSelectionForAgeSet(ageSetIndex)) {
     CacheInfo cache = getConstructingClassInfo(id);
     List<Kit> kits = cache.get(ageSet);
     if (kits != null) {
       // Need to do selection
       BioSet bioSet = bioSetFacet.get(id);
       for (TransitionChoice<Kit> kit : ageSet.getKits()) {
         Collection<? extends Kit> choice = kit.driveChoice(pc);
         cache.put(ageSet, choice);
         kit.act(choice, bioSet, pc);
       }
     }
     pc.setHasMadeKitSelectionForAgeSet(ageSetIndex, true);
   }
 }
Пример #4
0
  @Override
  public boolean testApply(Kit aKit, PlayerCharacter aPC, List<String> warnings) {
    skillsToAdd = new ArrayList<KitSkillAdd>();
    List<Skill> skillChoices = getSkillChoices(aPC);

    if (skillChoices == null || skillChoices.size() == 0) {
      // They didn't make a choice so don't add any ranks.
      return false;
    }
    for (Skill skill : skillChoices) {
      BigDecimal ranksLeftToAdd = getRank();
      if (ranksLeftToAdd == null) {
        ranksLeftToAdd = BigDecimal.ONE;
      }
      double ranksLeft = ranksLeftToAdd.doubleValue();
      List<PCClass> classList = new ArrayList<PCClass>();
      if (className != null) {
        String classKey = className.resolvesTo().getKeyName();
        // Make sure if they specified a class to add from we try that
        // class first.
        PCClass pcClass = aPC.getClassKeyed(classKey);
        if (pcClass != null) {
          classList.add(pcClass);
        } else {
          warnings.add(
              "SKILL: Could not find specified class " + classKey + " in PC to add ranks from.");
        }
      }
      for (PCClass pcClass : aPC.getClassSet()) {
        if (!classList.contains(pcClass)) {
          classList.add(pcClass);
        }
      }

      // Try and find a class we can add them from.
      boolean oldImporting = aPC.isImporting();
      aPC.setImporting(true);
      for (PCClass pcClass : classList) {
        final KitSkillAdd sta = addRanks(aPC, pcClass, skill, ranksLeft, isFree(), warnings);
        if (sta != null) {
          skillsToAdd.add(sta);
          ranksLeft -= sta.getRanks();
          if (ranksLeft <= 0.0) {
            break;
          }
        }
      }
      aPC.setImporting(oldImporting);
      if (ranksLeft > 0.0) {
        warnings.add(
            "SKILL: Could not add "
                + ranksLeft
                + " ranks to "
                + skill.getKeyName()
                + ". Not enough points.");
      }
    }
    return true;
  }
Пример #5
0
  /**
   * Needs documentation.
   *
   * @param pc update skills for this PC
   * @param aSkill Skill to update
   * @param aRank Number of ranks to add
   * @param aCost Cost of added ranks
   * @param langList Languages to be selected for a language skill
   * @param pcClass skills apply to this class
   * @return <code>true</code> for success TODO What about throwing on failure?
   */
  private boolean updatePCSkills(
      final PlayerCharacter pc,
      final Skill aSkill,
      final int aRank,
      final double aCost,
      List<Language> langList,
      final PCClass pcClass) {
    pc.addSkill(aSkill);

    boolean oldImporting = pc.isImporting();
    pc.setImporting(true);
    final String aString = SkillRankControl.modRanks(aRank, pcClass, true, pc, aSkill);
    pc.setImporting(oldImporting);

    if (aString.length() > 0) {
      Logging.errorPrint("SKILL: " + aString);
      return false;
    }

    // Add any supplied languages
    ChoiceManagerList<Language> controller =
        ChooserUtilities.getConfiguredController(aSkill, pc, null, new ArrayList<String>());
    for (Language lang : langList) {
      if (!controller.conditionallyApply(pc, lang)) {
        Logging.errorPrint("Failed to apply Language into Skill: " + lang.getLSTformat());
      }
    }

    //
    // Fix up the skill pools to reflect what we just spent.
    //
    double ptsToSpend = aCost;
    if (ptsToSpend >= 0.0) {
      for (PCLevelInfo info : pc.getLevelInfo()) {
        if (info.getClassKeyName().equals(pcClass.getKeyName())) {
          // We are spending this class' points.
          int remaining = info.getSkillPointsRemaining();
          if (remaining == 0) {
            continue;
          }
          int left = remaining - (int) Math.min(remaining, ptsToSpend);
          info.setSkillPointsRemaining(left);
          ptsToSpend -= (remaining - left);
          if (ptsToSpend <= 0) {
            break;
          }
        }
      }
    }
    return true;
  }
Пример #6
0
  @Override
  public void removeChoice(
      PlayerCharacter pc, CDOMObject owner, CategorizedAbilitySelection choice) {
    if (!pc.isImporting()) {
      pc.getSpellList();
    }

    // See if our choice is not auto or virtual
    Ability anAbility =
        pc.getMatchingAbility(AbilityCategory.FEAT, choice.getAbility(), Nature.NORMAL);

    if (anAbility != null) {
      pc.removeRealAbility(AbilityCategory.FEAT, anAbility);
      CDOMObjectUtilities.removeAdds(anAbility, pc);
      CDOMObjectUtilities.restoreRemovals(anAbility, pc);
      pc.adjustMoveRates();
    }
  }
Пример #7
0
  @Override
  public void applyChoice(
      CDOMObject owner, CategorizedAbilitySelection choice, PlayerCharacter pc) {
    if (!pc.isImporting()) {
      pc.getSpellList();
    }

    // See if our choice is not auto or virtual
    Ability anAbility =
        pc.getMatchingAbility(AbilityCategory.FEAT, choice.getAbility(), Nature.NORMAL);

    if (anAbility != null) {
      // how many sub-choices to make
      double abilityCount =
          (pc.getSelectCorrectedAssociationCount(anAbility)
              * anAbility.getSafe(ObjectKey.SELECTION_COST).doubleValue());

      boolean result = false;
      // adjust the associated List
      if (anAbility.getSafe(ObjectKey.MULTIPLE_ALLOWED)) {
        pc.removeAssociation(anAbility, choice.getSelection());
        result = pc.hasAssociations(anAbility);
      }

      boolean removed = false;

      // if no sub choices made (i.e. all of them removed in Chooser box),
      // then remove the Feat
      if (!result) {
        removed = pc.removeRealAbility(AbilityCategory.FEAT, anAbility);
        CDOMObjectUtilities.removeAdds(anAbility, pc);
        CDOMObjectUtilities.restoreRemovals(anAbility, pc);
      }

      AbilityUtilities.adjustPool(anAbility, pc, false, abilityCount, removed);
      pc.adjustMoveRates();
    }
    double cost = choice.getAbility().getSafe(ObjectKey.SELECTION_COST).doubleValue();
    pc.adjustAbilities(AbilityCategory.FEAT, BigDecimal.valueOf(-cost));
  }