Beispiel #1
0
  @Override
  protected ParseResult parseTokenWithSeparator(
      LoadContext context, PCClassLevel obj, String value) {
    boolean first = true;
    boolean foundAny = false;
    boolean foundOther = false;

    StringTokenizer tok = new StringTokenizer(value, Constants.PIPE);
    while (tok.hasMoreTokens()) {
      String tokText = tok.nextToken();
      if (Constants.LST_DOT_CLEAR.equals(tokText)) {
        if (!first) {
          return new ParseResult.Fail(
              "  Non-sensical " + getTokenName() + ": .CLEAR was not the first list item");
        }
        context.getObjectContext().removeList(obj, ListKey.LOCALCCSKILL);
      } else if (tokText.startsWith(Constants.LST_DOT_CLEAR_DOT)) {
        String clearText = tokText.substring(7);
        if (Constants.LST_ALL.equals(clearText)) {
          context
              .getObjectContext()
              .removeFromList(
                  obj, ListKey.LOCALCCSKILL, context.ref.getCDOMAllReference(SKILL_CLASS));
        } else {
          CDOMReference<Skill> ref =
              TokenUtilities.getTypeOrPrimitive(context, SKILL_CLASS, clearText);
          if (ref == null) {
            return new ParseResult.Fail("  Error was encountered while parsing " + getTokenName());
          }
          context.getObjectContext().removeFromList(obj, ListKey.LOCALCCSKILL, ref);
        }
      } else {
        /*
         * Note this HAS to be done one-by-one, because the
         * .clearChildNodeOfClass method above does NOT recognize the
         * C/CC Skill object and therefore doesn't know how to search
         * the sublists
         */
        if (Constants.LST_ALL.equals(tokText)) {
          foundAny = true;
          context
              .getObjectContext()
              .addToList(obj, ListKey.LOCALCCSKILL, context.ref.getCDOMAllReference(SKILL_CLASS));
        } else {
          foundOther = true;
          CDOMReference<Skill> ref = getSkillReference(context, tokText);
          if (ref == null) {
            return new ParseResult.Fail("  Error was encountered while parsing " + getTokenName());
          }
          context.getObjectContext().addToList(obj, ListKey.LOCALCCSKILL, ref);
        }
      }
      first = false;
    }
    if (foundAny && foundOther) {
      return new ParseResult.Fail(
          "Non-sensical " + getTokenName() + ": Contains ANY and a specific reference: " + value);
    }
    return ParseResult.SUCCESS;
  }
Beispiel #2
0
  @Override
  protected ParseResult parseTokenWithSeparator(LoadContext context, PCTemplate pct, String value) {
    context.getObjectContext().removeList(pct, ListKey.FEAT_TOKEN_LIST);

    StringTokenizer tok = new StringTokenizer(value, Constants.PIPE);

    boolean first = true;

    ReferenceManufacturer<Ability> rm =
        context.ref.getManufacturer(ABILITY_CLASS, AbilityCategory.FEAT);
    while (tok.hasMoreTokens()) {
      String token = tok.nextToken();
      if (Constants.LST_DOT_CLEAR.equals(token)) {
        if (!first) {
          return new ParseResult.Fail(
              "  Non-sensical " + getTokenName() + ": .CLEAR was not the first list item: " + value,
              context);
        }
      } else {
        CDOMReference<Ability> ability = TokenUtilities.getTypeOrPrimitive(rm, token);
        if (ability == null) {
          return ParseResult.INTERNAL_ERROR;
        }
        context.getObjectContext().addToList(pct, ListKey.FEAT_TOKEN_LIST, ability);
      }
      first = false;
    }
    return ParseResult.SUCCESS;
  }
Beispiel #3
0
  @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;
  }
  @Override
  protected ParseResult parseTokenWithSeparator(LoadContext context, Race race, String value) {
    StringTokenizer tok = new StringTokenizer(value, Constants.PIPE);
    boolean first = true;

    while (tok.hasMoreTokens()) {
      String tokString = tok.nextToken();
      if (Constants.LST_DOT_CLEAR.equals(tokString)) {
        if (!first) {
          return new ParseResult.Fail(
              "  Non-sensical "
                  + getTokenName()
                  + ": .CLEAR was not the first list item: "
                  + value);
        }
        context.obj.removeList(race, ListKey.RACESUBTYPE);
      } else if (tokString.startsWith(Constants.LST_DOT_CLEAR_DOT)) {
        String clearText = tokString.substring(7);
        context
            .getObjectContext()
            .removeFromList(race, ListKey.RACESUBTYPE, RaceSubType.getConstant(clearText));
      } else {
        context
            .getObjectContext()
            .addToList(race, ListKey.RACESUBTYPE, RaceSubType.getConstant(tokString));
      }
      first = false;
    }
    return ParseResult.SUCCESS;
  }
 /**
  * Report where an issue was encountered.
  *
  * @param context the LoadContext containing the resource
  */
 public static void reportSource(final Level lvl, final LoadContext context) {
   Logger l = getLogger();
   if (l.isLoggable(lvl)) {
     if (context != null
         && context.getObjectContext() != null
         && context.getObjectContext().getSourceURI() != null) {
       l.log(lvl, " (Source: " + context.getObjectContext().getSourceURI() + " )");
     } else {
       l.log(lvl, " (Source unknown)");
     }
   }
 }
Beispiel #6
0
  @Override
  protected ParseResult parseTokenWithSeparator(
      LoadContext context, EquipmentModifier mod, String value) {
    if (Constants.LST_DOT_CLEAR.equals(value)) {
      context.getObjectContext().removeList(mod, ListKey.SPECIAL_PROPERTIES);
      return ParseResult.SUCCESS;
    }

    SpecialProperty sa = SpecialProperty.createFromLst(value);
    if (sa == null) {
      return ParseResult.INTERNAL_ERROR;
    }
    context.getObjectContext().addToList(mod, ListKey.SPECIAL_PROPERTIES, sa);
    return ParseResult.SUCCESS;
  }
Beispiel #7
0
 public String[] unparse(LoadContext context, PCClassLevel obj) {
   Changes<CDOMReference<Skill>> changes =
       context.getObjectContext().getListChanges(obj, ListKey.LOCALCCSKILL);
   List<String> list = new ArrayList<String>();
   Collection<CDOMReference<Skill>> removedItems = changes.getRemoved();
   if (removedItems != null && !removedItems.isEmpty()) {
     if (changes.includesGlobalClear()) {
       context.addWriteMessage(
           "Non-sensical relationship in "
               + getTokenName()
               + ": global .CLEAR and local .CLEAR. performed");
       return null;
     }
     list.add(
         Constants.LST_DOT_CLEAR_DOT + ReferenceUtilities.joinLstFormat(removedItems, "|.CLEAR."));
   }
   if (changes.includesGlobalClear()) {
     list.add(Constants.LST_DOT_CLEAR);
   }
   Collection<CDOMReference<Skill>> added = changes.getAdded();
   if (added != null && !added.isEmpty()) {
     list.add(ReferenceUtilities.joinLstFormat(added, Constants.PIPE));
   }
   if (list.isEmpty()) {
     return null;
   }
   return list.toArray(new String[list.size()]);
 }
Beispiel #8
0
 public String[] unparse(LoadContext context, EquipmentModifier mod) {
   Changes<SpecialProperty> changes =
       context.getObjectContext().getListChanges(mod, ListKey.SPECIAL_PROPERTIES);
   if (changes == null || changes.isEmpty()) {
     return null;
   }
   List<String> list = new ArrayList<String>();
   Collection<SpecialProperty> added = changes.getAdded();
   boolean globalClear = changes.includesGlobalClear();
   if (globalClear) {
     list.add(Constants.LST_DOT_CLEAR);
   }
   if (added != null && !added.isEmpty()) {
     for (SpecialProperty sp : added) {
       StringBuilder sb = new StringBuilder();
       sb.append(sp.getDisplayName());
       if (sp.hasPrerequisites()) {
         sb.append(Constants.PIPE);
         sb.append(getPrerequisiteString(context, sp.getPrerequisiteList()));
       }
       list.add(sb.toString());
     }
   }
   if (list.isEmpty()) {
     context.addWriteMessage(
         getTokenName()
             + " was expecting non-empty changes to include "
             + "added items or global clear");
     return null;
   }
   return list.toArray(new String[list.size()]);
 }
Beispiel #9
0
 @Override
 public String[] unparse(LoadContext context, CDOMObject obj) {
   Changes<PersistentTransitionChoice<?>> grantChanges =
       context.getObjectContext().getListChanges(obj, ListKey.REMOVE);
   Collection<PersistentTransitionChoice<?>> addedItems = grantChanges.getAdded();
   if (addedItems == null || addedItems.isEmpty()) {
     // Zero indicates no Token
     return null;
   }
   List<String> addStrings = new ArrayList<String>();
   for (TransitionChoice<?> container : addedItems) {
     SelectableSet<?> cs = container.getChoices();
     if (getTokenName().equals(cs.getName())
         && CAT_ABILITY_SELECTION_CLASS.equals(cs.getChoiceClass())) {
       Formula f = container.getCount();
       if (f == null) {
         context.addWriteMessage("Unable to find " + getFullName() + " Count");
         return null;
       }
       StringBuilder sb = new StringBuilder();
       if (!FormulaFactory.ONE.equals(f)) {
         sb.append(f).append(Constants.PIPE);
       }
       sb.append(cs.getLSTformat());
       addStrings.add(sb.toString());
     }
   }
   return addStrings.toArray(new String[addStrings.size()]);
 }
Beispiel #10
0
 public String[] unparse(LoadContext context, Campaign campaign) {
   String title = context.getObjectContext().getString(campaign, StringKey.PUB_NAME_WEB);
   if (title == null) {
     return null;
   }
   return new String[] {title};
 }
Beispiel #11
0
  @Override
  protected ParseResult parseTokenWithSeparator(LoadContext context, T obj, String value) {
    FormatManager<F> fmtManager = def.getFormatManager();
    FactSetKey<F> fsk = def.getFactSetKey();
    StringTokenizer st = new StringTokenizer(value, Constants.PIPE);
    boolean firstToken = true;
    AbstractObjectContext objContext = context.getObjectContext();
    while (st.hasMoreTokens()) {
      String token = st.nextToken();
      if (Constants.LST_DOT_CLEAR_ALL.equals(token)) {
        if (!firstToken) {
          return new ParseResult.Fail(
              "Non-sensical situation was "
                  + "encountered while parsing "
                  + getParentToken()
                  + Constants.PIPE
                  + getTokenName()
                  + ": When used, .CLEARALL must be the first argument",
              context);
        }
        objContext.removeSet(obj, fsk);
      }

      ObjectContainer<F> indirect = fmtManager.convertObjectContainer(token);
      objContext.addToSet(obj, fsk, indirect);
    }
    return ParseResult.SUCCESS;
  }
Beispiel #12
0
 @Override
 public String[] unparse(LoadContext context, T obj) {
   FactSetKey<F> fk = def.getFactSetKey();
   Changes<ObjectContainer<F>> changes = context.getObjectContext().getSetChanges(obj, fk);
   Collection<ObjectContainer<F>> removedItems = changes.getRemoved();
   List<String> results = new ArrayList<String>(2);
   if (changes.includesGlobalClear()) {
     results.add(Constants.LST_DOT_CLEAR_ALL);
   }
   if (removedItems != null && !removedItems.isEmpty()) {
     context.addWriteMessage(getTokenName() + " does not support " + Constants.LST_DOT_CLEAR_DOT);
     return null;
   }
   Collection<ObjectContainer<F>> added = changes.getAdded();
   if (added != null && added.size() > 0) {
     StringBuilder sb = new StringBuilder();
     boolean needsPipe = false;
     for (ObjectContainer<F> oc : added) {
       if (needsPipe) {
         sb.append(Constants.PIPE);
       }
       sb.append(oc.getLSTformat(false));
       needsPipe = true;
     }
     results.add(sb.toString());
   }
   return results.toArray(new String[results.size()]);
 }
Beispiel #13
0
 public String[] unparse(LoadContext context, EquipmentModifier mod) {
   Formula f = context.getObjectContext().getFormula(mod, FormulaKey.BASECOST);
   if (f == null) {
     return null;
   }
   return new String[] {f.toString()};
 }
 @Override
 public String[] unparse(LoadContext context, CDOMObject cdo) {
   ChooseInformation<?> tc = context.getObjectContext().getObject(cdo, ObjectKey.CHOOSE_INFO);
   if (tc == null) {
     return null;
   }
   if (!tc.getName().equals(getTokenName())) {
     // Don't unparse anything that isn't owned by this SecondaryToken
     /*
      * TODO Either this really needs to be a check against the subtoken
      * (which thus needs to be stored in the ChooseInfo) or there needs
      * to be a loadtime check that no more than once CHOOSE subtoken
      * uses the same AssociationListKey... :P
      */
     return null;
   }
   if (!tc.getGroupingState().isValid()) {
     context.addWriteMessage(
         "Invalid combination of objects"
             + " was used in: "
             + getParentToken()
             + ":"
             + getTokenName());
     return null;
   }
   StringBuilder sb = new StringBuilder();
   sb.append(tc.getLSTformat());
   String title = tc.getTitle();
   if (!title.equals(getDefaultTitle())) {
     sb.append("|TITLE=");
     sb.append(title);
   }
   return new String[] {sb.toString()};
 }
 public String[] unparse(LoadContext context, Race race) {
   Changes<RaceSubType> changes =
       context.getObjectContext().getListChanges(race, ListKey.RACESUBTYPE);
   if (changes == null || changes.isEmpty()) {
     return null;
   }
   List<String> list = new ArrayList<String>();
   Collection<RaceSubType> removedItems = changes.getRemoved();
   if (changes.includesGlobalClear()) {
     if (removedItems != null && !removedItems.isEmpty()) {
       context.addWriteMessage(
           "Non-sensical relationship in "
               + getTokenName()
               + ": global .CLEAR and local .CLEAR. performed");
       return null;
     }
     list.add(Constants.LST_DOT_CLEAR);
   } else if (removedItems != null && !removedItems.isEmpty()) {
     list.add(Constants.LST_DOT_CLEAR_DOT + StringUtil.join(removedItems, "|.CLEAR."));
   }
   Collection<RaceSubType> added = changes.getAdded();
   if (added != null && !added.isEmpty()) {
     list.add(StringUtil.join(added, Constants.PIPE));
   }
   if (list.isEmpty()) {
     return null;
   }
   return list.toArray(new String[list.size()]);
 }
Beispiel #16
0
 private <CC extends BaseKit> boolean subParse(
     LoadContext context, Kit kit, CDOMSubLineLoader<CC> loader, String line)
     throws PersistenceLayerException {
   CC obj = loader.getCDOMObject();
   context.getObjectContext().addToList(kit, ListKey.KIT_TASKS, obj);
   return loader.parseLine(context, obj, line);
 }
  /**
   * Beep and print error message if PCGen is debugging.
   *
   * @param s String error message
   * @param context the LoadContext containing the deprecated resource
   */
  public static void errorPrint(final String s, final LoadContext context) {
    if (isDebugMode()) {
      s_TOOLKIT.beep();
    }

    Logger l = getLogger();
    if (l.isLoggable(ERROR)) {
      if (context != null
          && context.getObjectContext() != null
          && context.getObjectContext().getSourceURI() != null) {
        l.log(ERROR, s + " (Source: " + context.getObjectContext().getSourceURI() + " )");
      } else {
        l.log(ERROR, s);
      }
    }
  }
  /**
   * Beep and print error message if PCGen is debugging.
   *
   * @param s String error message
   * @param context the LoadContext containing the deprecated resource
   */
  public static void deprecationPrint(final String s, final LoadContext context) {
    if (isDebugMode()) {
      s_TOOLKIT.beep();
    }

    Logger l = getLogger();
    if (l.isLoggable(LST_WARNING) && SettingsHandler.outputDeprecationMessages()) {
      if (context != null
          && context.getObjectContext() != null
          && context.getObjectContext().getSourceURI() != null) {
        l.log(LST_WARNING, s + " (Source: " + context.getObjectContext().getSourceURI() + " )");
      } else {
        l.log(LST_WARNING, s);
      }
    }
  }
Beispiel #19
0
 @Override
 public String[] unparse(LoadContext context, PCTemplate pct) {
   Changes<CDOMReference<Ability>> changes =
       context.getObjectContext().getListChanges(pct, ListKey.FEAT_TOKEN_LIST);
   Collection<CDOMReference<Ability>> added = changes.getAdded();
   Collection<CDOMReference<Ability>> removedItems = changes.getRemoved();
   String returnVal = null;
   if (changes.includesGlobalClear()) {
     if (removedItems != null && !removedItems.isEmpty()) {
       context.addWriteMessage(
           "Non-sensical relationship in "
               + getTokenName()
               + ": global .CLEAR and local .CLEAR. performed");
       return null;
     }
     returnVal = Constants.LST_DOT_CLEAR;
   } else if (removedItems != null && !removedItems.isEmpty()) {
     context.addWriteMessage(getTokenName() + " does not support " + Constants.LST_DOT_CLEAR_DOT);
     return null;
   }
   if (added != null && !added.isEmpty()) {
     returnVal = ReferenceUtilities.joinLstFormat(added, Constants.PIPE);
   }
   if (returnVal == null) {
     return null;
   }
   return new String[] {returnVal};
 }
Beispiel #20
0
 @Override
 public String[] unparse(LoadContext context, PCClass obj) {
   Changes<BonusObj> changes = context.getObjectContext().getListChanges(obj, ListKey.BONUS);
   if (changes == null || changes.isEmpty()) {
     // Empty indicates no token present
     return null;
   }
   // CONSIDER need to deal with removed...
   Collection<BonusObj> added = changes.getAdded();
   String tokenName = getTokenName();
   Set<String> bonusSet = new TreeSet<String>();
   for (BonusObj bonus : added) {
     if (tokenName.equals(bonus.getTokenSource())) {
       StringBuilder sb = new StringBuilder();
       sb.append(bonus.getValue());
       List<Prerequisite> prereqList = new ArrayList<Prerequisite>(bonus.getPrerequisiteList());
       Prerequisite prereq = getPrerequisite("PRELEVELMAX:1");
       prereqList.remove(prereq);
       if (!prereqList.isEmpty()) {
         sb.append('|');
         sb.append(getPrerequisiteString(context, prereqList));
       }
       bonusSet.add(sb.toString());
     }
   }
   if (bonusSet.isEmpty()) {
     // This is okay - just no BONUSes from this token
     return null;
   }
   return bonusSet.toArray(new String[bonusSet.size()]);
 }
Beispiel #21
0
 @Override
 public String[] unparse(LoadContext context, CDOMObject cdo) {
   Changes<Type> changes = context.getObjectContext().getListChanges(cdo, ListKey.TYPE);
   if (changes == null || changes.isEmpty()) {
     return null;
   }
   StringBuilder sb = new StringBuilder();
   Collection<?> added = changes.getAdded();
   boolean globalClear = changes.includesGlobalClear();
   if (globalClear) {
     sb.append(Constants.LST_DOT_CLEAR);
   }
   if (added != null && !added.isEmpty()) {
     if (globalClear) {
       sb.append(Constants.DOT);
     }
     sb.append(StringUtil.join(added, Constants.DOT));
   }
   Collection<Type> removed = changes.getRemoved();
   if (removed != null && !removed.isEmpty()) {
     if (sb.length() > 0) {
       sb.append(Constants.DOT);
     }
     sb.append("REMOVE.");
     sb.append(StringUtil.join(removed, Constants.DOT));
   }
   if (sb.length() == 0) {
     context.addWriteMessage(
         getTokenName()
             + " was expecting non-empty changes to include "
             + "added items or global clear");
     return null;
   }
   return new String[] {sb.toString()};
 }
Beispiel #22
0
 @Override
 public String[] unparse(LoadContext context, CDOMObject obj) {
   String descr = context.getObjectContext().getString(obj, StringKey.TEMP_DESCRIPTION);
   if (descr == null) {
     return null;
   }
   return new String[] {EntityEncoder.encode(descr)};
 }
Beispiel #23
0
 @Override
 protected ParseResult parseNonEmptyToken(LoadContext context, Campaign campaign, String value) {
   ParseResult pr = checkForInvalidXMLChars(value);
   if (pr.passed()) {
     context.getObjectContext().put(campaign, StringKey.DESCRIPTION, value);
   }
   return pr;
 }
Beispiel #24
0
 @Override
 public String[] unparse(LoadContext context, Campaign campaign) {
   String title = context.getObjectContext().getString(campaign, StringKey.DESCRIPTION);
   if (title == null) {
     return null;
   }
   return new String[] {title};
 }
Beispiel #25
0
 @Override
 public String[] unparse(LoadContext context, Spell spell) {
   String target = context.getObjectContext().getString(spell, StringKey.TARGET_AREA);
   if (target == null) {
     return null;
   }
   return new String[] {target};
 }
Beispiel #26
0
 @Override
 public String[] unparse(LoadContext context, Campaign campaign) {
   Boolean isM = context.getObjectContext().getObject(campaign, ObjectKey.IS_D20);
   if (isM == null) {
     return null;
   }
   return new String[] {isM.booleanValue() ? "YES" : "NO"};
 }
Beispiel #27
0
  @Override
  protected ParseResult parseNonEmptyToken(LoadContext context, CDOMObject obj, String value) {
    ParsingSeparator sep = new ParsingSeparator(value, '|');
    String activeValue = sep.next();
    Formula count;
    if (!sep.hasNext()) {
      count = FormulaFactory.ONE;
    } else {
      count = FormulaFactory.getFormulaFor(activeValue);
      if (!count.isValid()) {
        return new ParseResult.Fail(
            "Count in " + getTokenName() + " was not valid: " + count.toString());
      }
      if (count.isStatic() && count.resolve(null, "").doubleValue() <= 0) {
        return new ParseResult.Fail("Count in " + getFullName() + " must be > 0");
      }
      activeValue = sep.next();
    }
    if (sep.hasNext()) {
      return new ParseResult.Fail(getFullName() + " had too many pipe separated items: " + value);
    }
    ParseResult pr = checkSeparatorsAndNonEmpty(',', activeValue);
    if (!pr.passed()) {
      return pr;
    }

    List<CDOMReference<Language>> refs = new ArrayList<CDOMReference<Language>>();
    StringTokenizer tok = new StringTokenizer(activeValue, Constants.COMMA);
    while (tok.hasMoreTokens()) {
      String tokText = tok.nextToken();
      CDOMReference<Language> lang = TokenUtilities.getReference(context, LANGUAGE_CLASS, tokText);
      if (lang == null) {
        return new ParseResult.Fail(
            "  Error was encountered while parsing "
                + getFullName()
                + ": "
                + value
                + " had an invalid reference: "
                + tokText);
      }
      refs.add(lang);
    }

    ReferenceChoiceSet<Language> rcs = new ReferenceChoiceSet<Language>(refs);
    if (!rcs.getGroupingState().isValid()) {
      return new ParseResult.Fail(
          "Non-sensical " + getFullName() + ": Contains ANY and a specific reference: " + value);
    }

    ChoiceSet<Language> cs = new ChoiceSet<Language>(getTokenName(), rcs);
    cs.setTitle("Language Choice");
    PersistentTransitionChoice<Language> tc =
        new ConcretePersistentTransitionChoice<Language>(cs, count);
    context.getObjectContext().addToList(obj, ListKey.ADD, tc);
    tc.setChoiceActor(this);
    return ParseResult.SUCCESS;
  }
Beispiel #28
0
 @Override
 public ParseResult parseToken(LoadContext context, EquipmentModifier obj, String value) {
   if (value == null) {
     // No args - legal
     context.getObjectContext().put(obj, StringKey.CHOICE_STRING, getTokenName());
     return ParseResult.SUCCESS;
   }
   return new ParseResult.Fail(
       "CHOOSE:" + getTokenName() + " must not have arguments: " + value, context);
 }
Beispiel #29
0
  @Override
  public String[] unparse(LoadContext context, CDOMObject obj) {
    Changes<FollowerOption> changes =
        context.getObjectContext().getListChanges(obj, ListKey.COMPANIONLIST);
    Collection<FollowerOption> removedItems = changes.getRemoved();
    if (removedItems != null && !removedItems.isEmpty() || changes.includesGlobalClear()) {
      context.addWriteMessage(getTokenName() + " does not support .CLEAR");
      return null;
    }
    Collection<FollowerOption> added = changes.getAdded();
    if (added == null || added.isEmpty()) {
      // Zero indicates no Token (and no global clear, so nothing to do)
      return null;
    }
    TripleKeyMapToList<
            Set<Prerequisite>, CDOMReference<? extends CDOMList<?>>, Integer, CDOMReference<Race>>
        m = new TripleKeyMapToList<>();
    for (FollowerOption fo : added) {
      m.addToListFor(
          new HashSet<>(fo.getPrerequisiteList()),
          fo.getListRef(),
          fo.getAdjustment(),
          fo.getRaceRef());
    }
    Set<String> set = new TreeSet<>();
    StringBuilder sb = new StringBuilder();
    for (Set<Prerequisite> prereqs : m.getKeySet()) {
      String prereqString = null;
      if (prereqs != null && !prereqs.isEmpty()) {
        prereqString = getPrerequisiteString(context, prereqs);
      }

      for (CDOMReference<? extends CDOMList<?>> cl : m.getSecondaryKeySet(prereqs)) {
        for (Integer fa : m.getTertiaryKeySet(prereqs, cl)) {
          sb.setLength(0);
          sb.append(cl.getLSTformat(false));
          sb.append(Constants.PIPE);
          Set<CDOMReference<Race>> raceSet = new TreeSet<>(ReferenceUtilities.REFERENCE_SORTER);
          raceSet.addAll(m.getListFor(prereqs, cl, fa));
          sb.append(ReferenceUtilities.joinLstFormat(raceSet, Constants.COMMA, true));
          if (fa != null && fa != 0) {
            sb.append(Constants.PIPE);
            sb.append("FOLLOWERADJUSTMENT:");
            sb.append(fa);
          }
          if (prereqString != null) {
            sb.append(Constants.PIPE);
            sb.append(prereqString);
          }
          set.add(sb.toString());
        }
      }
    }
    return set.toArray(new String[set.size()]);
  }
Beispiel #30
0
 @Override
 public String[] unparse(LoadContext context, PCTemplate pct) {
   Changes<CDOMReference<WeaponProf>> changes =
       context.getObjectContext().getListChanges(pct, ListKey.WEAPONBONUS);
   Collection<CDOMReference<WeaponProf>> added = changes.getAdded();
   if (added == null || added.isEmpty()) {
     // Zero indicates no add
     return null;
   }
   return new String[] {ReferenceUtilities.joinLstFormat(added, Constants.PIPE)};
 }