From: <nu...@us...> - 2011-05-15 22:29:17
|
Revision: 14993 http://pcgen.svn.sourceforge.net/pcgen/?rev=14993&view=rev Author: nuance Date: 2011-05-15 22:29:09 +0000 (Sun, 15 May 2011) Log Message: ----------- Checkstyle updates. Sis some refactoring on the Prerequisite stuff. Modified Paths: -------------- Trunk/pcgen/code/src/java/pcgen/cdom/base/Constants.java Trunk/pcgen/code/src/java/pcgen/core/prereq/PrereqHandler.java Trunk/pcgen/code/src/java/pcgen/core/prereq/Prerequisite.java Trunk/pcgen/code/src/java/pcgen/core/prereq/PrerequisiteUtilities.java Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteListParser.java Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteParser.java Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWeaponProfParser.java Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWieldParser.java Trunk/pcgen/code/src/java/plugin/pretokens/test/PreAbilityTester.java Trunk/pcgen/code/src/java/plugin/pretokens/test/PreFeatTester.java Modified: Trunk/pcgen/code/src/java/pcgen/cdom/base/Constants.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/cdom/base/Constants.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/cdom/base/Constants.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -590,7 +590,11 @@ * sorted list. The moved items are sorted in their new position. */ int ARBITRARY_END_SKILL_INDEX = 999; + /** + * The length of both the LST_TYPE and LST_TYPE_OLD constants. */ + int LENGTH_OF_TYPE_SUBSTRING = 5; + /** * The default for whether to print the weapon proficiencies. * */ Modified: Trunk/pcgen/code/src/java/pcgen/core/prereq/PrereqHandler.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/core/prereq/PrereqHandler.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/core/prereq/PrereqHandler.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -31,6 +31,7 @@ import java.util.Collection; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.Constants; import pcgen.core.Ability; import pcgen.core.Equipment; import pcgen.core.Globals; @@ -41,25 +42,32 @@ import pcgen.util.PropertyFactory; /** - * @author wardc - * - * To change the template for this generated type comment go to - * Window>Preferences>Java>Code Generation>Code and Comments + * This class tests if the character passes the prerequisites for the caller. */ public class PrereqHandler { /** + * empty private constructor prevents instantiation. + */ + private PrereqHandler() + { + } + + /** * Test if the character passes the prerequisites for the caller. The caller * is used to check if prereqs can be bypassed by either preferences or via * Qualifies statements in templates or other objects applied to the * character. * * @param prereqList The list of prerequisites to be tested. - * @param character The character to be checked. + * @param aPC The character to be checked. * @param caller The object that we are testing qualification for. * @return True if the character passes all prereqs. */ - public static boolean passesAll(final Collection<Prerequisite> prereqList, final PlayerCharacter character, final Object caller) + public static boolean passesAll( + final Collection<Prerequisite> prereqList, + final PlayerCharacter aPC, + final Object caller) { if (prereqList == null || prereqList.isEmpty()) { @@ -75,10 +83,10 @@ return true; } - if (caller instanceof CDOMObject && character != null) + if (caller instanceof CDOMObject && aPC != null) { // Check for QUALIFY: - if (character.checkQualifyList((CDOMObject) caller)) + if (aPC.checkQualifyList((CDOMObject) caller)) { return true; } @@ -86,7 +94,7 @@ for (Prerequisite prereq : prereqList) { - if (!passes(prereq, character, caller)) + if (!passes(prereq, aPC, caller)) { return false; } @@ -94,7 +102,17 @@ return true; } - public static boolean passesAll(final Collection<Prerequisite> prereqList, final Equipment equip, PlayerCharacter currentPC) + /** + * + * @param prereqList The list of prerequisites to be tested. + * @param equip + * @param aPC The character to be checked. + * @return + */ + public static boolean passesAll( + final Collection<Prerequisite> prereqList, + final Equipment equip, + PlayerCharacter aPC) { if (prereqList == null) { @@ -102,7 +120,7 @@ } for (Prerequisite prereq : prereqList) { - if (!passes(prereq, equip, currentPC)) + if (!passes(prereq, equip, aPC)) { return false; } @@ -111,15 +129,18 @@ } /** - * Returns true if the character passes the prereq - * @param prereq The prerequisite to pass - * @param character The character to test against + * Returns true if the character passes the prereq. + * @param prereq The prerequisite to test. + * @param aPC The character to test against * @param caller The CDOMojbect that is calling this method * @return true if the character passes the prereq */ - public static boolean passes(final Prerequisite prereq, final PlayerCharacter character, final Object caller) + public static boolean passes( + final Prerequisite prereq, + final PlayerCharacter aPC, + final Object caller) { - if (character == null && prereq.isCharacterRequired()) + if (aPC == null && prereq.isCharacterRequired()) { return true; } @@ -128,7 +149,8 @@ if (test == null) { - Logging.errorPrintLocalised("PrereqHandler.Unable_to_find_implementation", prereq.toString()); //$NON-NLS-1$ + Logging.errorPrintLocalised( + "PrereqHandler.Unable_to_find_implementation", prereq.toString()); //$NON-NLS-1$ return false; } @@ -136,8 +158,10 @@ boolean autoQualifies = false; int total = 0; - if (caller instanceof CDOMObject && character != null - && character.checkQualifyList((CDOMObject) caller) && (!overrideQualify)) + if (caller instanceof CDOMObject + && aPC != null + && aPC.checkQualifyList((CDOMObject) caller) + && (!overrideQualify)) { autoQualifies = true; } @@ -147,9 +171,8 @@ } try { - CDOMObject cdomCaller = (caller instanceof CDOMObject) ? (CDOMObject) caller - : null; - total = test.passes(prereq, character, cdomCaller); + CDOMObject cdomCaller = (caller instanceof CDOMObject) ? (CDOMObject) caller : null; + total = test.passes(prereq, aPC, cdomCaller); } catch (PrerequisiteException pe) { @@ -164,61 +187,81 @@ + String.valueOf(caller)) : "") + ". See following trace for details.", e); } - return total>0; + return total > 0; } - public static boolean passes(final Prerequisite prereqList, final Equipment equip, PlayerCharacter currentPC) + /** + * + * @param preReq The prerequisite to test. + * @param equip + * @param aPC The character to be checked. + * @return Whether the prerequisite passes. + */ + public static boolean passes( + final Prerequisite preReq, + final Equipment equip, + PlayerCharacter aPC) { if (equip == null) { return true; } final PrerequisiteTestFactory factory = PrerequisiteTestFactory.getInstance(); - final PrerequisiteTest test = factory.getTest(prereqList.getKind()); + final PrerequisiteTest test = factory.getTest(preReq.getKind()); if (test == null) { - Logging.errorPrintLocalised("PrereqHandler.Unable_to_find_implementation", prereqList.toString()); //$NON-NLS-1$ + final String message = "PrereqHandler.Unable_to_find_implementation"; //$NON-NLS-1$ + Logging.errorPrintLocalised(message, preReq.toString()); return false; } - int total=0; + int total = 0; try { - total = test.passes(prereqList, equip, currentPC); + total = test.passes(preReq, equip, aPC); } catch (PrerequisiteException pe) { - Logging.errorPrintLocalised("PrereqHandler.Exception_in_test", pe); //$NON-NLS-1$ + final String message = "PrereqHandler.Exception_in_test"; //$NON-NLS-1$ + Logging.errorPrintLocalised(message , pe); } return total>0; } - public static final String toHtmlString(final Collection<Prerequisite> anArrayList) + /** + * Generates an HTML representation of a list of PreRequisite objects. + * @param anArrayList the list of PreRequisite objects to be represented. + * @return An HTML representation of the input. + */ + public static String toHtmlString(final Collection<Prerequisite> anArrayList) { if (anArrayList==null || anArrayList.isEmpty()) { - return ""; //$NON-NLS-1$ + return Constants.EMPTY_STRING; } final PrerequisiteTestFactory factory = PrerequisiteTestFactory.getInstance(); final StringBuffer pString = new StringBuffer(anArrayList.size() * 20); - String delimiter = ""; //$NON-NLS-1$ + String delimiter = Constants.EMPTY_STRING; - for (Prerequisite prereq : anArrayList) + for (Prerequisite preReq : anArrayList) { - final PrerequisiteTest preHtml = factory.getTest(prereq.getKind()); - if (preHtml==null) + final PrerequisiteTest preReqTest = factory.getTest(preReq.getKind()); + + if (preReqTest == null) { - Logging.errorPrintLocalised("PrereqHandler.No_known_formatter", prereq.getKind()); //$NON-NLS-1$ + final String message = "PrereqHandler.No_known_formatter"; //$NON-NLS-1$ + Logging.errorPrintLocalised(message, preReq.getKind()); } else { pString.append(delimiter); - pString.append(preHtml.toHtmlString(prereq) ); + pString.append(preReqTest.toHtmlString(preReq)); - delimiter = PropertyFactory.getString("PrereqHandler.HTML_prerequisite_delimiter"); //$NON-NLS-1$ + final String property = "PrereqHandler.HTML_prerequisite_delimiter"; //$NON-NLS-1$ + delimiter = PropertyFactory.getString(property); } } Modified: Trunk/pcgen/code/src/java/pcgen/core/prereq/Prerequisite.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/core/prereq/Prerequisite.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/core/prereq/Prerequisite.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -60,8 +60,10 @@ /** Indicates that the number of qualifying objects should be tallied when checking for a value. */ private boolean countMultiples; private boolean overrideQualify = false; - private String categoryName; // used for abilities only - category to restrict matches to. + /** Used for abilities only - the category to restrict matches to. */ + private String categoryName; + /** * Instantiates a new prerequisite. */ @@ -308,12 +310,13 @@ } /** - * @param overrideQualify - * The overrideQualify to set. + * Setter for the overrideQualify field. + * @param override + * Whether the override the qualifications. */ - public void setOverrideQualify(final boolean overrideQualify) + public void setOverrideQualify(final boolean override) { - this.overrideQualify = overrideQualify; + this.overrideQualify = override; } /* Modified: Trunk/pcgen/code/src/java/pcgen/core/prereq/PrerequisiteUtilities.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/core/prereq/PrerequisiteUtilities.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/core/prereq/PrerequisiteUtilities.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -24,14 +24,13 @@ */ package pcgen.core.prereq; -import java.io.StringWriter; import java.util.ArrayList; import java.util.Collection; -import java.util.Iterator; import java.util.List; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.Constants; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.ObjectKey; import pcgen.cdom.enumeration.StringKey; @@ -46,9 +45,6 @@ import pcgen.core.Skill; import pcgen.core.WeaponProf; import pcgen.core.spell.Spell; -import pcgen.persistence.PersistenceLayerException; -import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; -import pcgen.util.Logging; /** * @author Tom Parker <th...@so...> @@ -58,14 +54,27 @@ public final class PrerequisiteUtilities { /** - * Private Constructor + * Private Constructor, prevents instantiation. */ private PrerequisiteUtilities() { // Don't allow instantiation of utility class } - public static final String preReqHTMLStringsForList(final PlayerCharacter aPC, final PObject aObj, final Collection<Prerequisite> aList, final boolean includeHeader) + /** + * Tests a list of prerequisites against a given PC and a given Source. It then + * generates an HTML representation of whether they passed. + * @param aPC The PC to test the prerequisites against. + * @param aObj The source of the PreRequisite. + * @param aList A list of prerequisite objects. + * @param includeHeader Whether to wrap the generated string in html tags. + * @return An HTML representation of whether a set of PreRequisites passed for a given PC and Source. + */ + public static String preReqHTMLStringsForList( + final PlayerCharacter aPC, + final PObject aObj, + final Collection<Prerequisite> aList, + final boolean includeHeader) { if ((aList == null) || aList.isEmpty()) { @@ -75,16 +84,20 @@ final StringBuffer pString = new StringBuffer(aList.size() * 20); final List<Prerequisite> newList = new ArrayList<Prerequisite>(); - int iter = 0; + boolean first = true; - for ( Prerequisite prereq : aList ) + for (Prerequisite prereq : aList) { newList.clear(); newList.add(prereq); - if (iter++ > 0) + if (first) { + first = false; + } + else + { pString.append(" and "); } @@ -159,115 +172,94 @@ return pString.toString(); } - /** - * Build the LST syntax to represent the list of prerequisites. - * - * @param preReqs The list of prerequisites. - * @param separator The character to separate each prereq from each other. - */ - public static String getPrerequisitePCCText(final List preReqs, final String separator) - { - final StringBuffer sBuff = new StringBuffer(); - if ((preReqs != null) && (preReqs.size() > 0)) { - final StringWriter writer = new StringWriter(); - final PrerequisiteWriter preReqWriter = new PrerequisiteWriter(); - for (Iterator preReqIter = preReqs.iterator(); preReqIter.hasNext();) { - final Prerequisite preReq = (Prerequisite) preReqIter.next(); - try { - preReqWriter.write(writer, preReq); - } catch (PersistenceLayerException e) { - Logging.errorPrint("Failed to encode prereq: ", e); - } - if (preReqIter.hasNext()) { - writer.write(separator); - } - } - sBuff.append(separator); - sBuff.append(writer.toString()); - } - return sBuff.toString(); - } - - - /** * Check if the character passes the ability prerequisite. Refactored here * for use by both PREFEAT and PREABILITY. - * + * * @param prereq The prerequisite to be run. * @param character The character to be checked. - * @param countMults Should multiple occurrences be counted. * @param numMatches The number of matches required. - * @param key The key that needs to be matched - * @param subKey The sub key that needs to be matched. * @param categoryName The name of the required category, null if any category will be matched. - * @param category The category to be matched * @return The number of matches made, 0 if not enough matches were made. */ - public static int passesAbilityTest(final Prerequisite prereq, - final PlayerCharacter character, final boolean countMults, - final int numMatches, String key, String subKey, String categoryName, - AbilityCategory category) + public static int passesAbilityTest( + final Prerequisite prereq, + final PlayerCharacter character, + final int numMatches, + String categoryName) { - final boolean keyIsAny = - key.equalsIgnoreCase("ANY"); //$NON-NLS-1$ - final boolean keyIsType = - key.startsWith("TYPE=") || key.startsWith("TYPE."); //$NON-NLS-1$ //$NON-NLS-2$ - final boolean subKeyIsType = - subKey != null - && (subKey.startsWith("TYPE=") || subKey.startsWith("TYPE.")); //$NON-NLS-1$ //$NON-NLS-2$ - if (keyIsType) - { - key = key.substring(5); - } - if (subKeyIsType) - { - subKey = subKey.substring(5); - } + final boolean countMults = prereq.isCountMultiples(); + + final boolean keyIsAny = prereq.getKey().equalsIgnoreCase(Constants.LST_ANY); + final boolean keyIsType = isTypeTest(prereq.getKey()); + + final String strippedKey = keyIsType + ? prereq.getKey().substring(Constants.LENGTH_OF_TYPE_SUBSTRING) + : prereq.getKey(); + int runningTotal = 0; - final List<Ability> abilityList = - buildAbilityList(character, categoryName, category); + + final List<Ability> abilityList = buildAbilityList(character, categoryName); + if (!abilityList.isEmpty()) { for (Ability ability : abilityList) { final String abilityKey = ability.getKeyName(); - if (keyIsAny || (!keyIsType && abilityKey.equalsIgnoreCase(key)) - || (keyIsType && ability.isType(key))) + + if (keyIsAny + || (!keyIsType && abilityKey.equalsIgnoreCase(strippedKey)) + || (keyIsType && ability.isType(strippedKey))) { // either this feat has matched on the name, or the type - if (subKey != null) + if (prereq.getSubKey() != null) { - runningTotal += - checkForSubKeyMatch(character, countMults, key, - subKey, subKeyIsType, ability); + runningTotal += dealWithSubKey( + prereq, + character, + strippedKey, + ability); } else { - // Subkey == null + // subKey == null runningTotal++; if (ability.getSafe(ObjectKey.MULTIPLE_ALLOWED) && countMults) { - // SERVESAS occurrences might mean this is less than zero, in which case ignore it - // This still leaves the instance where more than one of an item is desired - // and one instance is a SERVESAS, but that is a high cost corner case. - int numOccurs = character.getSelectCorrectedAssociationCount(ability) - 1; - if (numOccurs > 0) + + /* + * SERVESAS occurrences might mean this is less than zero, + * in which case ignore it. This still leaves the instance + * where more than one of an item is desired, and one + * instance is a SERVESAS, but that is a high cost corner case. + */ + + final int num = + character.getSelectCorrectedAssociationCount(ability) - 1; + if (num > 0) { - runningTotal += numOccurs; + runningTotal += num; } } } } else { - if (subKey != null) + + if (prereq.getSubKey() != null) { - final String s1 = key + " (" + subKey + ")"; - final String s2 = key + "(" + subKey + ")"; + final int len = Constants.LENGTH_OF_TYPE_SUBSTRING; + + final boolean subKeyIsType = isTypeTest(prereq.getSubKey()); + final String subKey = subKeyIsType + ? prereq.getSubKey().substring(len) + : prereq.getSubKey(); + + final String s1 = strippedKey + " (" + subKey + ")"; + final String s2 = strippedKey + "(" + subKey + ")"; if (abilityKey.equalsIgnoreCase(s1) || ability.getKeyName().equalsIgnoreCase(s2)) { @@ -286,102 +278,170 @@ return runningTotal; } + + + /** - * Having matched the ability on the other criteria, check for a match - * against the sub-key. - * - * @param character The character being tested. - * @param countMults Should multiple occurrences be counted? - * @param key The key that needs to be matched - * @param subKey The sub key that needs to be matched. - * @param subKeyIsType Does the subkey refer to a type? - * @param aFeat The ability being checked for a match. - * @return The number of matches made + * This operation deals with matching subKeys against abilities where the the main key + * has already matched. + + * The subKey may be prefixed with TYPE(=|.) in which case the Choice string from the + * ability will be used to check for the type of chooser. Possibilities are SKILL, + * WEAPONPROFS, DOMAIN, or SPELL. A list of keys will be retrieved from the ability's + * associated object list. The objects matching these keys are retrieved and checked + * for type against subKey. A count is returned (respects countMults). + * + * If the subKey is not specifying a type, then the key of the prerequisite is checked + * against the key of the ability, if they match and the ability object is associated + * with the character via the subkey, then a count of the number of instances is returned. + * + * Finally,the subkey may specify a wildcard. If it does, the list of associations + * between the ability object and the PC are checked. A count is returned of teh number + * that begin with the wildcard string. + * + * @param prereq The prerequisite to be checked. + * @param character The character to be checked. + * @param key the Key from the prerequisite which has been stripped the prefixes TYPE= abd TYPE. + * @param ability The ability being checked for a match. + * @return A count which respects countMults. */ - private static int checkForSubKeyMatch(final PlayerCharacter character, final boolean countMults, String key, String subKey, final boolean subKeyIsType, Ability aFeat) + private static int dealWithSubKey( + Prerequisite prereq, + PlayerCharacter character, + String key, + Ability ability) { - final String cType = subKey; - final List selectedList = new ArrayList(); - final String aChoiceString = aFeat.getSafe(StringKey.CHOICE_STRING); + final boolean countMults = prereq.isCountMultiples(); int runningTotal = 0; - selectedList.addAll(character.getAssociationList(aFeat)); + final String subKey = prereq.getSubKey(); + final boolean subKeyIsType = isTypeTest(subKey); - if (subKeyIsType) // TYPE syntax + final int wildCardPos = subKey.indexOf('%'); + + if (subKeyIsType) { - if (aChoiceString.startsWith("SKILL")) //$NON-NLS-1$ + final String type = prereq.getSubKey().substring(Constants.LENGTH_OF_TYPE_SUBSTRING); + runningTotal = countSubKeyType(character, ability, type, countMults); + } + + else if (ability.getKeyName().equalsIgnoreCase(key) + && character.containsAssociated(ability, subKey)) + { + + if (countMults && ability.getSafe(ObjectKey.MULTIPLE_ALLOWED)) { - runningTotal = - subKeySkill(countMults, runningTotal, - cType, selectedList); + runningTotal = character.getSelectCorrectedAssociationCount(ability); } - else if (aChoiceString.startsWith("WEAPONPROFS")) //$NON-NLS-1$ + else { - runningTotal = - subKeyWeaponProf(countMults, - runningTotal, cType, selectedList); + runningTotal = 1; } - else if (aChoiceString.startsWith("DOMAIN")) //$NON-NLS-1$ - { - runningTotal = - subKeyDomain(countMults, runningTotal, - cType, selectedList); - } - else if (aChoiceString.startsWith("SPELL")) //$NON-NLS-1$ - { - runningTotal = - subKeySpell(countMults, runningTotal, - cType, selectedList); - } - // End. subKeyIsType } - else + + else if (wildCardPos > -1) { - if (aFeat.getKeyName().equalsIgnoreCase(key) - && character.containsAssociated(aFeat, subKey)) + String preWildcard = (wildCardPos == 0) + ? Constants.EMPTY_STRING + : subKey.substring(0, wildCardPos).toUpperCase(); + runningTotal = countSubKeyWildcardMatch( + character, + countMults, + preWildcard, + ability); + } + + return runningTotal; + } + + /** + * Is this string a Type selector? + * @param key the string to test + * @return true if key begins with TYPE= or TYPE. + */ + private static boolean isTypeTest(String key) + { + return key.startsWith(Constants.LST_TYPE) || key.startsWith(Constants.LST_TYPE_OLD); + } + + /** + * Having matched the ability on the other criteria, check for a match + * against the subKey. + * + * @param character + * The character being tested. + * @param countMults + * Should multiple occurrences be counted? + * @param preWilcard + * The portion of the prerequisite's subkey that appears + * before the wilcard character '%' + * @param ability + * The ability being checked for a match. + * @return The number of matches made + */ + private static int countSubKeyWildcardMatch( + final PlayerCharacter character, + final boolean countMults, + String preWilcard, + Ability ability) + { + + int runningTotal = 0; + + for (String assoc : character.getAssociationList(ability)) + { + final String fString = assoc.toUpperCase(); + + if (preWilcard.length() == 0 || fString.startsWith(preWilcard)) { runningTotal++; - if (aFeat.getSafe(ObjectKey.MULTIPLE_ALLOWED) && countMults) + if (!countMults) { - runningTotal += - (character.getSelectCorrectedAssociationCount(aFeat) - 1); + break; } } - else - { - final int wildCardPos = subKey.indexOf('%'); - - if (wildCardPos > -1) - { - for (String assoc : character.getAssociationList(aFeat)) - { - final String fString = assoc.toUpperCase(); - if (wildCardPos == 0 - || fString.startsWith(subKey - .substring(0, wildCardPos - 1) - .toUpperCase())) - { - runningTotal++; - if (!countMults) - { - break; - } - } - } - } - } } return runningTotal; } + private static int countSubKeyType( + PlayerCharacter aPC, + Ability ability, String type, boolean countMults) + { + final List<String> selectedList = aPC.getAssociationList(ability); + + final String aChoiceString = ability.getSafe(StringKey.CHOICE_STRING); + + if (aChoiceString.startsWith("SKILL")) //$NON-NLS-1$ + { + return subKeySkill(countMults, type, selectedList); + } + else if (aChoiceString.startsWith("WEAPONPROFS")) //$NON-NLS-1$ + { + return subKeyWeaponProf(countMults, type, selectedList); + } + else if (aChoiceString.startsWith("DOMAIN")) //$NON-NLS-1$ + { + return subKeyDomain(countMults, type, selectedList); + } + else if (aChoiceString.startsWith("SPELL")) //$NON-NLS-1$ + { + return subKeySpell(countMults, type, selectedList); + } + + return 0; + } + /** * Build up a list of the character's abilities which match the category requirements. + * * @param character The character to be tested. * @param categoryName The name of the required category, null if any category will be matched. - * @param category The category to be matched * @return A list of categories matching. */ - private static List<Ability> buildAbilityList(final PlayerCharacter character, String categoryName, AbilityCategory category) + private static List<Ability> buildAbilityList( + final PlayerCharacter character, + String categoryName) { final List<Ability> abilityList = new ArrayList<Ability>(); if (character != null) @@ -404,17 +464,19 @@ } } } - + // Now scan for relevant SERVESAS occurrences for (AbilityCategory aCat : allCats) { for (Ability ability : character.getAggregateAbilityList(aCat)) { - for(CDOMReference<Ability> ref: ability.getSafeListFor(ListKey.SERVES_AS_ABILITY)) + for(CDOMReference<Ability> ref + : ability.getSafeListFor(ListKey.SERVES_AS_ABILITY)) { for (Ability ab : ref.getContainedObjects()) { - if (categoryName == null || categoryName.equals(ab.getCategory())) + if (categoryName == null + || categoryName.equals(ab.getCategory())) { abilityList.add(ab); } @@ -427,33 +489,32 @@ } /** - * @param countMults - * @param runningTotal - * @param cType - * @param selectedList + * Count the number of spells associated with the ability being tested of types cType. + * + * @param countMults Should multiple occurrences be counted? + * @param cType The type to check for. + * @param selectedList The list of spells associated with the ability being tested. * @return int */ - private static int subKeySpell(final boolean countMults, int runningTotal, - final String cType, final List selectedList) + private static int subKeySpell( + final boolean countMults, + final String cType, + final List selectedList) { - int returnTotal = runningTotal; + int returnTotal = 0; for (Object aObj : selectedList) { - final Spell sp; - String spellKey = null; - if (aObj instanceof PObject) - { - spellKey = ((PObject) aObj).getKeyName(); - } - else - { - spellKey = aObj.toString(); - } - sp = Globals.getSpellKeyed(spellKey); + String spellKey = (aObj instanceof PObject) + ? ((PObject) aObj).getKeyName() + : aObj.toString(); + + final Spell sp = Globals.getSpellKeyed(spellKey); + if (sp == null) { continue; } + if (sp.isType(cType)) { returnTotal++; @@ -467,16 +528,20 @@ } /** - * @param countMults - * @param runningTotal - * @param cType - * @param selectedList + * Count the number of domains associated with the ability being tested of types cType. + * + * @param countMults Should multiple occurrences be counted? + * @param cType The type to check for. + * @param selectedList The list of domains associated with the ability being tested. * @return int */ - private static int subKeyDomain(final boolean countMults, int runningTotal, - final String cType, final List selectedList) + private static int subKeyDomain( + final boolean countMults, + final String cType, + final List selectedList) { - int returnTotal = runningTotal; + int returnTotal = 0; + for (Object aObj : selectedList) { final Domain dom; @@ -494,35 +559,43 @@ } } } + return returnTotal; } /** - * @param countMults - * @param runningTotal - * @param cType - * @param selectedList + * Count the number of weaponprofs associated with the ability being tested of types cType. + * + * @param countMults Should multiple occurrences be counted? + * @param cType The type to check for. + * @param selectedList The list of weaponprofs associated with the ability being tested. * @return int */ - private static int subKeyWeaponProf(final boolean countMults, int runningTotal, - final String cType, final List selectedList) + private static int subKeyWeaponProf( + final boolean countMults, + final String cType, + final List selectedList) { - int returnTotal = runningTotal; + int returnTotal = 0; + for (Object aObj : selectedList) { - final WeaponProf wp; - wp = Globals.getContext().ref.silentlyGetConstructedCDOMObject(WeaponProf.class, aObj.toString()); + final WeaponProf wp = Globals.getContext().ref.silentlyGetConstructedCDOMObject( + WeaponProf.class, aObj.toString()); + if (wp == null) { continue; } - final Equipment eq; - eq = Globals.getContext().ref.silentlyGetConstructedCDOMObject( - Equipment.class, wp.getKeyName()); + + final Equipment eq = Globals.getContext().ref.silentlyGetConstructedCDOMObject( + Equipment.class, wp.getKeyName()); + if (eq == null) { continue; } + if (eq.isType(cType)) { returnTotal++; @@ -532,20 +605,25 @@ } } } + return returnTotal; } /** - * @param countMults - * @param runningTotal - * @param cType - * @param selectedList + * Count the number of skills associated with the ability being tested of types cType. + * + * @param countMults Should multiple occurrences be counted? + * @param cType The type to check for. + * @param selectedList The list of skills associated with the ability being tested. * @return int */ - private static int subKeySkill(final boolean countMults, int runningTotal, - final String cType, final List selectedList) + private static int subKeySkill( + final boolean countMults, + final String cType, + final List selectedList) { - int returnTotal = runningTotal; + int returnTotal = 0; + for (Object aObj : selectedList) { final Skill sk; @@ -563,6 +641,7 @@ } } } + return returnTotal; } @@ -571,9 +650,9 @@ * descendant of the required kind. * @param prereq Prerequisite to be checked * @param matchKind Kind to be checked for. - * @return + * @return true if we got as match. */ - public static final boolean hasPreReqKindOf(final Prerequisite prereq, String matchKind) + public static boolean hasPreReqKindOf(final Prerequisite prereq, String matchKind) { if (prereq == null) { @@ -599,12 +678,18 @@ /** * Identify if the prerequisite is itself of the supplied kind or has a - * descendant of the required kind. + * descendant of the required kind. Kind is either FEAT or ABILITY, the + * key is the name of an ability object. + * * @param prereq Prerequisite to be checked * @param matchKind Kind to be checked for. - * @return + * @param matchKey The name of an ability object. + * @return true if we got a match */ - public static final boolean hasPreReqMatching(final Prerequisite prereq, String matchKind, String matchKey) + public static boolean hasPreReqMatching( + final Prerequisite prereq, + String matchKind, + String matchKey) { if (prereq == null) { Modified: Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteListParser.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteListParser.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteListParser.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -34,12 +34,11 @@ import pcgen.util.Logging; /** - * Abstract PRE parser, provides common parsing for many PRE tokens - * - * @author PCGen Development Team + * Abstract PRE parser, provides common parsing for many PRE tokens. */ -public abstract class AbstractPrerequisiteListParser extends - AbstractPrerequisiteParser implements PrerequisiteParserInterface +public abstract class AbstractPrerequisiteListParser + extends AbstractPrerequisiteParser + implements PrerequisiteParserInterface { /** @@ -80,23 +79,25 @@ } /** - * Parse the pre req list + * Parse the pre req list. * - * @param kind - * @param formula - * @param invertResult + * @param kind The kind of the prerequisite (less the "PRE" prefix) + * @param formula The body of the prerequisite. + * @param invertResult Whether the prerequisite should invert the result. * @param overrideQualify * @return PreReq * @throws PersistenceLayerException */ @Override - public Prerequisite parse(String kind, String formula, - boolean invertResult, boolean overrideQualify) + public Prerequisite parse( + String kind, + String formula, + boolean invertResult, + boolean overrideQualify) throws PersistenceLayerException { - Prerequisite prereq = - super.parse(kind, formula, invertResult, overrideQualify); + Prerequisite prereq = super.parse(kind, formula, invertResult, overrideQualify); parsePrereqListType(prereq, kind, formula); if (invertResult) @@ -141,7 +142,9 @@ * <prereq kind="stat" key="str" operator="gteq" op1="13" /> * </prereq> */ - protected void parsePrereqListType(Prerequisite prereq, String kind, + protected void parsePrereqListType( + Prerequisite prereq, + String kind, String formula) throws PersistenceLayerException { Modified: Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteParser.java =================================================================== --- Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteParser.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/pcgen/persistence/lst/prereq/AbstractPrerequisiteParser.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -37,17 +37,20 @@ PrerequisiteParserInterface { /** - * Parses PreReq + * Parses the PreRequisite. * - * @param kind - * @param formula - * @param invertResult + * @param kind the kind of the prerequisite (less the "PRE" prefix). + * @param formula The body of the prerequisite. + * @param invertResult Whether the prerequisite should invert the result. * @param overrideQualify * @return PreReq * @throws PersistenceLayerException */ - public Prerequisite parse(String kind, String formula, - boolean invertResult, boolean overrideQualify) + public Prerequisite parse( + String kind, + String formula, + boolean invertResult, + boolean overrideQualify) throws PersistenceLayerException { // Check to make sure that this class can parse this token Modified: Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWeaponProfParser.java =================================================================== --- Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWeaponProfParser.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWeaponProfParser.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -34,37 +34,47 @@ import pcgen.persistence.lst.prereq.PrerequisiteParserInterface; /** - * @author wardc + * A prerequisite parser class that handles the parsing of pre weaponprof tokens. * */ -public class PreWeaponProfParser extends AbstractPrerequisiteListParser - implements PrerequisiteParserInterface +public class PreWeaponProfParser extends AbstractPrerequisiteListParser implements PrerequisiteParserInterface { - /* (non-Javadoc) - * @see pcgen.persistence.lst.prereq.PrerequisiteParserInterface#kindsHandled() + /** + * Get the type of prerequisite handled by this token. + * @return the type of prerequisite handled by this token. */ public String[] kindsHandled() { return new String[]{"WEAPONPROF"}; } - /* (non-Javadoc) - * @see pcgen.persistence.lst.prereq.PrerequisiteParserInterface#parse(java.lang.String, java.lang.String, boolean) + /** + * This operation performs the actual parsing. + * @param kind the kind of the prerequisite (less the "PRE" prefix) + * @param formula The body of the prerequisite; + * @param invertResult If the prerequisite should invert the result + * before it is returned + * @param overrideQualify + * + * @return a object for testing the prerequisite + * @throws PersistenceLayerException */ @Override - public Prerequisite parse(String kind, String formula, - boolean invertResult, boolean overrideQualify) + public Prerequisite parse( + String kind, + String formula, + boolean invertResult, + boolean overrideQualify) throws PersistenceLayerException { - Prerequisite prereq = - super.parse(kind, formula, invertResult, overrideQualify); + Prerequisite prereq = super.parse(kind, formula, invertResult, overrideQualify); - doTypeInvertFixup(prereq); + doTypeInvertFixUp(prereq); return prereq; } - private void doTypeInvertFixup(Prerequisite prereq) + private void doTypeInvertFixUp(Prerequisite prereq) { if ("weaponprof".equalsIgnoreCase(prereq.getKind())) { @@ -74,20 +84,25 @@ } else if (prereq.getKey().startsWith("[")) { - prereq.setKey(prereq.getKey().substring( - 1, - Math.max(prereq.getKey().length() - 1, prereq.getKey() - .lastIndexOf(']')))); + final int length = prereq.getKey().length() - 1; + final int rBracket = prereq.getKey().lastIndexOf(']'); + final int endIndex = Math.max(length, rBracket); + + final String key = prereq.getKey().substring(1, endIndex); + + prereq.setKey(key); prereq.setOperator(prereq.getOperator().invert()); } } - // - // In case of PREMULT (e.g 'PREWEAPONPROF:1,TYPE.Martial,Chain (Spiked)', need to check all sub-prereqs - // - for (Prerequisite subreq : prereq.getPrerequisites()) + + /* + * In case of PREMULT (e.g 'PREWEAPONPROF:1,TYPE.Martial,Chain (Spiked)', + * need to check all sub-prereqs + */ + for (Prerequisite subReq : prereq.getPrerequisites()) { - doTypeInvertFixup(subreq); + doTypeInvertFixUp(subReq); } } } Modified: Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWieldParser.java =================================================================== --- Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWieldParser.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/plugin/pretokens/parser/PreWieldParser.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -32,14 +32,14 @@ import pcgen.persistence.lst.prereq.PrerequisiteParserInterface; /** - * @author wardc + * A prerequisite parser class that handles the parsing of pre wield tokens. * */ -public class PreWieldParser extends AbstractPrerequisiteListParser implements - PrerequisiteParserInterface +public class PreWieldParser extends AbstractPrerequisiteListParser implements PrerequisiteParserInterface { - /* (non-Javadoc) - * @see pcgen.persistence.lst.prereq.PrerequisiteParserInterface#kindsHandled() + /** + * Get the type of prerequisite handled by this token. + * @return the type of prerequisite handled by this token. */ public String[] kindsHandled() { Modified: Trunk/pcgen/code/src/java/plugin/pretokens/test/PreAbilityTester.java =================================================================== --- Trunk/pcgen/code/src/java/plugin/pretokens/test/PreAbilityTester.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/plugin/pretokens/test/PreAbilityTester.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -26,11 +26,8 @@ package plugin.pretokens.test; import pcgen.cdom.base.CDOMObject; -import pcgen.core.AbilityCategory; import pcgen.core.Equipment; -import pcgen.core.GameMode; import pcgen.core.PlayerCharacter; -import pcgen.core.SettingsHandler; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; import pcgen.core.prereq.PrerequisiteException; @@ -55,8 +52,11 @@ * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override - public int passes(final Prerequisite prereq, final Equipment equipment, - final PlayerCharacter aPC) throws PrerequisiteException + public int passes( + final Prerequisite prereq, + final Equipment equipment, + final PlayerCharacter aPC) + throws PrerequisiteException { if (aPC == null) { @@ -66,11 +66,12 @@ } @Override - public int passes(final Prerequisite prereq, final PlayerCharacter character, CDOMObject source) + public int passes( + final Prerequisite prereq, + final PlayerCharacter character, + CDOMObject source) throws PrerequisiteException { - final boolean countMults = prereq.isCountMultiples(); - final int number; try { @@ -82,15 +83,14 @@ PropertyFactory.getFormattedString("PreAbility.error", prereq.toString())); //$NON-NLS-1$ } - GameMode gameMode = SettingsHandler.getGame(); - String key = prereq.getKey(); - String subKey = prereq.getSubKey(); String categoryName = prereq.getCategoryName(); - AbilityCategory category = categoryName == null ? null : gameMode - .getAbilityCategory(categoryName); - int runningTotal = - PrerequisiteUtilities.passesAbilityTest(prereq, character, - countMults, number, key, subKey, categoryName, category); + + int runningTotal = PrerequisiteUtilities.passesAbilityTest( + prereq, + character, + number, + categoryName); + return countedTotal(prereq, runningTotal); } Modified: Trunk/pcgen/code/src/java/plugin/pretokens/test/PreFeatTester.java =================================================================== --- Trunk/pcgen/code/src/java/plugin/pretokens/test/PreFeatTester.java 2011-05-15 13:23:29 UTC (rev 14992) +++ Trunk/pcgen/code/src/java/plugin/pretokens/test/PreFeatTester.java 2011-05-15 22:29:09 UTC (rev 14993) @@ -47,11 +47,12 @@ * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override - public int passes(final Prerequisite prereq, final PlayerCharacter character, CDOMObject source) + public int passes( + final Prerequisite prereq, + final PlayerCharacter character, + CDOMObject source) throws PrerequisiteException { - final boolean countMults = prereq.isCountMultiples(); - final int number; try { @@ -63,12 +64,12 @@ "PreFeat.error", prereq.toString())); //$NON-NLS-1$ } - String key = prereq.getKey(); - String subKey = prereq.getSubKey(); - int runningTotal = - PrerequisiteUtilities.passesAbilityTest(prereq, character, - countMults, number, key, subKey, AbilityCategory.FEAT - .getKeyName(), AbilityCategory.FEAT); + int runningTotal = PrerequisiteUtilities.passesAbilityTest( + prereq, + character, + number, + AbilityCategory.FEAT.getKeyName()); + return countedTotal(prereq, runningTotal); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |