Пример #1
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;
  }
Пример #2
0
  /*
   * REFACTOR This is BAD that this is referring to PCLevelInfo - that gets
   * VERY confusing as far as object interaction. Can we get rid of
   * PCLevelInfo altogether?
   */
  public final int getSkillPool(final PlayerCharacter aPC) {
    int returnValue = 0;
    // //////////////////////////////////
    // Using this method will return skills for level 0 even when there is
    // no information
    // Byngl - December 28, 2004
    // for (int i = 0; i <= level; i++)
    // {
    // final PCLevelInfo pcl = aPC.getLevelInfoFor(getKeyName(), i);
    //
    // if ((pcl != null) && pcl.getClassKeyName().equals(getKeyName()))
    // {
    // returnValue += pcl.getSkillPointsRemaining();
    // }
    // }
    for (PCLevelInfo pcl : aPC.getLevelInfo()) {
      if (pcl.getClassKeyName().equals(getKeyName())) {
        returnValue += pcl.getSkillPointsRemaining();
      }
    }
    // //////////////////////////////////

    return returnValue;
  }
Пример #3
0
  void subLevel(final PlayerCharacter aPC) {

    if (aPC != null) {
      int total = aPC.getTotalLevels();

      int oldLevel = aPC.getLevel(this);
      int spMod = 0;
      final PCLevelInfo pcl = aPC.getLevelInfoFor(getKeyName(), oldLevel);

      if (pcl != null) {
        spMod = pcl.getSkillPointsGained(aPC);
      } else {
        Logging.errorPrint(
            "ERROR: could not find class/level info for " + getDisplayName() + "/" + oldLevel);
      }

      final int newLevel = oldLevel - 1;

      if (oldLevel > 0) {
        PCClassLevel classLevel = aPC.getActiveClassLevel(this, oldLevel - 1);
        aPC.removeHP(classLevel);
      }

      //			aPC.adjustFeats(-aPC.getBonusFeatsForNewLevel(this));
      setLevel(newLevel, aPC);
      aPC.removeKnownSpellsForClassLevel(this);

      doMinusLevelMods(aPC, newLevel + 1);

      DomainApplication.removeDomainsForLevel(this, newLevel + 1, aPC);

      if (newLevel == 0) {
        SubClassApplication.setSubClassKey(aPC, this, Constants.NONE);

        //
        // Remove all skills associated with this class
        //
        for (Skill skill : aPC.getSkillSet()) {
          SkillRankControl.setZeroRanks(this, aPC, skill);
        }

        Integer currentPool = aPC.getSkillPool(this);
        spMod = currentPool == null ? 0 : currentPool;
      }

      if (!isMonster() && (total > aPC.getTotalLevels())) {
        total = aPC.getTotalLevels();

        // Roll back any stat changes that were made as part of the
        // level

        final List<PCLevelInfoStat> moddedStats = new ArrayList<>();
        if (pcl.getModifiedStats(true) != null) {
          moddedStats.addAll(pcl.getModifiedStats(true));
        }
        if (pcl.getModifiedStats(false) != null) {
          moddedStats.addAll(pcl.getModifiedStats(false));
        }
        if (!moddedStats.isEmpty()) {
          for (PCLevelInfoStat statToRollback : moddedStats) {
            for (PCStat aStat : aPC.getStatSet()) {
              if (aStat.equals(statToRollback.getStat())) {
                aPC.setStat(aStat, aPC.getStat(aStat) - statToRollback.getStatMod());
                break;
              }
            }
          }
        }
      }

      aPC.setLevelWithoutConsequence(this, newLevel);

      if (isMonster() || (total != 0)) {
        Integer currentPool = aPC.getSkillPool(this);
        int newSkillPool = (currentPool == null ? 0 : currentPool) - spMod;
        aPC.setSkillPool(this, newSkillPool);
        aPC.setDirty(true);
      }

      if (aPC.getLevel(this) == 0) {
        aPC.removeClass(this);
      }

      aPC.validateCharacterDomains();

      if (!aPC.isImporting()) {
        final int maxxp = aPC.minXPForNextECL();
        if (aPC.getXP() >= maxxp) {
          aPC.setXP(Math.max(maxxp - 1, 0));
        }
      }
    } else {
      Logging.errorPrint("No current pc in subLevel()? How did this happen?");

      return;
    }
  }
Пример #4
0
  /*
   * REFACTOR Clearly this is part of the PCClass factory method that produces
   * PCClassLevels combined with some other work that will need to be done to
   * extract some of the complicated gunk out of here that goes out and puts
   * information into PCLevelInfo and PlayerCharacter.
   */
  public boolean addLevel(
      final boolean argLevelMax,
      final boolean bSilent,
      final PlayerCharacter aPC,
      final boolean ignorePrereqs) {

    // Check to see if we can add a level of this class to the
    // current character
    final int newLevel = aPC.getLevel(this) + 1;
    boolean levelMax = argLevelMax;

    aPC.setAllowInteraction(false);
    aPC.setLevelWithoutConsequence(this, newLevel);
    if (!ignorePrereqs) {
      // When loading a character, classes are added before feats, so
      // this test would always fail on loading if feats are required
      boolean doReturn = false;
      if (!qualifies(aPC, this)) {
        doReturn = true;
        if (!bSilent) {
          ShowMessageDelegate.showMessageDialog(
              "This character does not qualify for level " + newLevel,
              Constants.APPLICATION_NAME,
              MessageType.ERROR);
        }
      }
      aPC.setLevelWithoutConsequence(this, newLevel - 1);
      if (doReturn) {
        return false;
      }
    }
    aPC.setAllowInteraction(true);

    if (isMonster()) {
      levelMax = false;
    }

    if (hasMaxLevel() && (newLevel > getSafe(IntegerKey.LEVEL_LIMIT)) && levelMax) {
      if (!bSilent) {
        ShowMessageDelegate.showMessageDialog(
            "This class cannot be raised above level "
                + Integer.toString(getSafe(IntegerKey.LEVEL_LIMIT)),
            Constants.APPLICATION_NAME,
            MessageType.ERROR);
      }

      return false;
    }

    // Add the level to the current character
    int total = aPC.getTotalLevels();

    // No longer need this since the race now sets a bonus itself and Templates
    // are not able to reassign their feats.  There was nothing else returned in
    // this number
    //		if (total == 0) {
    //			aPC.setFeats(aPC.getInitialFeats());
    //		}
    setLevel(newLevel, aPC);

    // the level has now been added to the character,
    // so now assign the attributes of this class level to the
    // character...
    PCClassLevel classLevel = aPC.getActiveClassLevel(this, newLevel);

    // Make sure that if this Class adds a new domain that
    // we record where that domain came from
    final int dnum = aPC.getMaxCharacterDomains(this, aPC) - aPC.getDomainCount();

    if (dnum > 0 && !aPC.hasDefaultDomainSource()) {
      aPC.setDefaultDomainSource(new ClassSource(this, newLevel));
    }

    // Don't roll the hit points if the gui is not being used.
    // This is so GMGen can add classes to a person without pcgen flipping
    // out
    if (Globals.getUseGUI()) {
      final int levels =
          SettingsHandler.isHPMaxAtFirstClassLevel()
              ? aPC.totalNonMonsterLevels()
              : aPC.getTotalLevels();
      final boolean isFirst = levels == 1;

      aPC.rollHP(this, aPC.getLevel(this), isFirst);
    }

    if (!aPC.isImporting()) {
      DomainApplication.addDomainsUpToLevel(this, newLevel, aPC);
    }

    int levelUpStats = 0;

    // Add any bonus feats or stats that will be gained from this level
    // i.e. a bonus feat every 3 levels
    if (aPC.getTotalLevels() > total) {
      boolean processBonusStats = true;
      total = aPC.getTotalLevels();

      if (isMonster()) {
        // If we have less levels that the races monster levels
        // then we can not give a stat bonus (i.e. an Ogre has
        // 4 levels of Giant, so it does not get a stat increase at
        // 4th level because that is already taken into account in
        // its racial stat modifiers, but it will get one at 8th
        LevelCommandFactory lcf = aPC.getRace().get(ObjectKey.MONSTER_CLASS);
        int monLevels = 0;
        if (lcf != null) {
          monLevels = lcf.getLevelCount().resolve(aPC, "").intValue();
        }

        if (total <= monLevels) {
          processBonusStats = false;
        }
      }

      if (!aPC.isImporting()) {
        // We do not want to do these
        // calculations a second time when are
        // importing a character. The feat
        // number and the stat point pool are
        // already saved in the import file.

        // if (processBonusFeats) {
        //	final double bonusFeats = aPC.getBonusFeatsForNewLevel(this);
        //	if (bonusFeats > 0) {
        //		aPC.adjustFeats(bonusFeats);
        //	}
        // }

        if (processBonusStats) {
          final int bonusStats = Globals.getBonusStatsForLevel(total, aPC);
          if (bonusStats > 0) {
            aPC.setPoolAmount(aPC.getPoolAmount() + bonusStats);

            if (!bSilent && SettingsHandler.getShowStatDialogAtLevelUp()) {
              levelUpStats = StatApplication.askForStatIncrease(aPC, bonusStats, true);
            }
          }
        }
      }
    }

    int spMod = getSkillPointsForLevel(aPC, classLevel, total);

    PCLevelInfo pcl;

    if (aPC.getLevelInfoSize() > 0) {
      pcl = aPC.getLevelInfo(aPC.getLevelInfoSize() - 1);

      if (pcl != null) {
        pcl.setClassLevel(aPC.getLevel(this));
        pcl.setSkillPointsGained(aPC, spMod);
        pcl.setSkillPointsRemaining(pcl.getSkillPointsGained(aPC));
      }
    }

    Integer currentPool = aPC.getSkillPool(this);
    int newSkillPool = spMod + (currentPool == null ? 0 : currentPool);
    aPC.setSkillPool(this, newSkillPool);

    if (!aPC.isImporting()) {
      //
      // Ask for stat increase after skill points have been calculated
      //
      if (levelUpStats > 0) {
        StatApplication.askForStatIncrease(aPC, levelUpStats, false);
      }

      if (newLevel == 1) {
        AddObjectActions.doBaseChecks(this, aPC);
        CDOMObjectUtilities.addAdds(this, aPC);
        CDOMObjectUtilities.checkRemovals(this, aPC);
      }

      for (TransitionChoice<Kit> kit : classLevel.getSafeListFor(ListKey.KIT_CHOICE)) {
        kit.act(kit.driveChoice(aPC), classLevel, aPC);
      }
      TransitionChoice<Region> region = classLevel.get(ObjectKey.REGION_CHOICE);
      if (region != null) {
        region.act(region.driveChoice(aPC), classLevel, aPC);
      }
    }

    // this is a monster class, so don't worry about experience
    if (isMonster()) {
      return true;
    }

    if (!aPC.isImporting()) {
      CDOMObjectUtilities.checkRemovals(this, aPC);
      final int minxp = aPC.minXPForECL();
      if (aPC.getXP() < minxp) {
        aPC.setXP(minxp);
      } else if (aPC.getXP() >= aPC.minXPForNextECL()) {
        if (!bSilent) {
          ShowMessageDelegate.showMessageDialog(
              SettingsHandler.getGame().getLevelUpMessage(),
              Constants.APPLICATION_NAME,
              MessageType.INFORMATION);
        }
      }
    }

    //
    // Allow exchange of classes only when assign 1st level
    //
    if (containsKey(ObjectKey.EXCHANGE_LEVEL) && (aPC.getLevel(this) == 1) && !aPC.isImporting()) {
      ExchangeLevelApplication.exchangeLevels(aPC, this);
    }
    return true;
  }
Пример #5
0
  private KitSkillAdd addRanks(
      PlayerCharacter pc,
      PCClass pcClass,
      Skill aSkill,
      double ranksLeftToAdd,
      boolean isFree,
      List<String> warnings) {
    if (!isFree && pcClass.getSkillPool(pc) == 0) {
      return null;
    }

    double curRank = 0.0;
    if (pc.hasSkill(aSkill)) {
      curRank = pc.getRank(aSkill).doubleValue();
    }
    double ranksToAdd = ranksLeftToAdd;
    if (!Globals.checkRule(RuleConstants.SKILLMAX) && (ranksToAdd > 0.0)) {
      ranksToAdd = Math.min(pc.getMaxRank(aSkill, pcClass).doubleValue(), curRank + ranksLeftToAdd);
      ranksToAdd -= curRank;
      if (!CoreUtility.doublesEqual(ranksToAdd, ranksLeftToAdd)) {
        warnings.add(
            "SKILL: Could not add "
                + (ranksLeftToAdd - ranksToAdd)
                + " to "
                + aSkill.getDisplayName()
                + ". Exceeds MAXRANK of "
                + pc.getMaxRank(aSkill, pcClass)
                + ".");
      }
    }
    int ptsToSpend = 0;
    int[] points = new int[pc.getLevelInfoSize()];
    if (!isFree) {
      double ranksAdded = 0.0;
      int skillCost = pc.getSkillCostForClass(aSkill, pcClass).getCost();
      ptsToSpend = (int) (ranksToAdd * skillCost);
      for (int i = 0; i < pc.getLevelInfoSize(); i++) {
        PCLevelInfo info = pc.getLevelInfo(i);
        if (info.getClassKeyName().equals(pcClass.getKeyName())) {
          // We are spending this class' points.
          points[i] = info.getSkillPointsRemaining();
        } else {
          points[i] = -1;
        }
      }
      for (int i = 0; i < points.length; i++) {
        int remaining = points[i];
        if (remaining <= 0) {
          continue;
        }
        int left = remaining - Math.min(remaining, ptsToSpend);
        points[i] = left;
        int spent = (remaining - left);
        ptsToSpend -= spent;
        ranksAdded += ((double) spent / (double) skillCost);
        if (ranksAdded == ranksToAdd || ptsToSpend <= 0) {
          break;
        }
      }

      ranksToAdd = ranksAdded;
      ptsToSpend = (int) (ranksToAdd * skillCost);
    }
    pc.addSkill(aSkill);

    String ret = SkillRankControl.modRanks(ranksToAdd, pcClass, false, pc, aSkill);
    if (ret.length() > 0) {
      if (isFree && ret.indexOf("You do not have enough skill points.") != -1) {
        SkillRankControl.modRanks(ranksToAdd, pcClass, true, pc, aSkill);
      } else {
        warnings.add(ret);
        return null;
      }
    }
    if (!isFree) {
      for (int i = 0; i < pc.getLevelInfoSize(); i++) {
        PCLevelInfo info = pc.getLevelInfo(i);
        if (points[i] >= 0) {
          info.setSkillPointsRemaining(points[i]);
        }
      }
    }
    List<Language> langList = new ArrayList<Language>();
    if (ChooseActivation.hasChooseToken(aSkill) && !selection.isEmpty()) {
      ChoiceManagerList<Language> controller =
          ChooserUtilities.getConfiguredController(aSkill, pc, null, new ArrayList<String>());
      int limit = (int) ranksToAdd;
      for (CDOMSingleRef<Language> ref : selection) {
        Language lang = ref.resolvesTo();
        if (controller.conditionallyApply(pc, lang)) {
          langList.add(lang);
          limit--;
        }
        if (limit <= 0) {
          break;
        }
      }
    }
    return new KitSkillAdd(aSkill, ranksToAdd, ptsToSpend, langList, pcClass);
  }