From cdbc0c547bb9d9d2aff2087940430f83f15f3aa8 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Sun, 5 Feb 2017 18:14:58 -0500 Subject: Formatting tweaks --- RGens/src/main/java/bjc/RGens/ZadronsPouch.java | 183 ++++++++++++--------- .../java/bjc/RGens/parser/GrammarReaderApp.java | 19 +-- .../java/bjc/RGens/parser/RBGrammarReader.java | 66 +++----- .../main/java/bjc/RGens/parser/ReaderState.java | 12 +- 4 files changed, 140 insertions(+), 140 deletions(-) (limited to 'RGens/src/main/java') diff --git a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java index 5b1615d..5fbc5c8 100644 --- a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java +++ b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java @@ -22,8 +22,7 @@ public class ZadronsPouch { ZadronsPouch zp = new ZadronsPouch(); for (int i = 0; i < 100; i++) { - IList ls = zp.grammar - .generateListValues("", " "); + IList ls = zp.grammar.generateListValues("", " "); StringBuilder sb = new StringBuilder(); @@ -41,150 +40,180 @@ public class ZadronsPouch { public ZadronsPouch() { grammar = new RandomGrammar<>(); - addRule("", "", "", "", "", - "", "", "", "", "", - "", "", ""); + addRule("", + "", "", "", "", + "", "", "", "", + "", "", "", ""); addEggRules(); - addGloveRules(); - addCrysSphereRules(); - addRockRules(); addFigurineRules(); - addVialRules(); - addMiniWeaponRules(); - addBagRules(); addCardRules(); - addRopeRules(); - addBoxRules(); - addWandRules(); } private void addBagRules() { - addRule("", "bag of ", " sack", - " purse"); - addRule("", "holding", "tricks", "useful items", + addRule("", + "bag of ", " sack", " purse"); + addRule("", + "holding", "tricks", "useful items", "devouring", "dwarf-kind", "invisible cloth", "monster summoning"); - addRule("", "lunch", "recursive"); - addRule("", "everfull"); + addRule("", + "lunch", "recursive"); + addRule("", + "everfull"); } private void addBoxRules() { - addRule("", " box", "cube of "); - addRule("", "limited-force", "frost-resisting", - "morphing", "self-destructing", "pandora", "panicking"); + addRule("", + " box", "cube of "); + addRule("", + "limited-force", "frost-resisting", "morphing", + "self-destructing", "pandora", "panicking"); } private void addCardRules() { - addRule("", "card of ", " card"); - addRule("", "fate", "teleporting", "elusive treasure", - "spell-storing", "many-things", "imprisoning", "messaging", - "bounty"); + addRule("", + "card of ", " card"); + addRule("", + "fate", "teleporting", "elusive treasure", "spell-storing", + "many-things", "imprisoning", "messaging", "bounty"); } private void addCrysSphereRules() { - addRule("", " spheres", - " sphere", "lens of ", - " crystal", "crystal of ", - "crystal ball", "crystal ball of "); - addRule("", "microphonic", "seeing-eye"); - addRule("", "detection"); - addRule("", "prison", "radar"); - addRule("", "jumping"); + addRule("", + " spheres", " sphere", + "lens of ", " crystal", + "crystal of ", "crystal ball", + "crystal ball of "); + addRule("", + "microphonic", "seeing-eye"); + addRule("", + "detection"); + addRule("", + "prison", "radar"); + addRule("", + "jumping"); } private void addEggRules() { - addRule("", " egg"); - addRule("", "copper", "stone", "golden", "white", - "white/pink", "glass"); + addRule("", + " egg"); + addRule("", + "copper", "stone", "golden", + "white", "white/pink", "glass"); } private void addFigurineRules() { - addRule("", " "); - addRule("", "golden", "onyx", "serpentine", "ivory", + addRule("", + " "); + addRule("", + "golden", "onyx", "serpentine", "ivory", "marble", "bronze", "jade", "limestone"); - addRule("", "lion", "dog", "owl", "goat", "elephant", - "warrior", "palace", "leprechaun"); + addRule("", + "lion", "dog", "owl", "goat", + "elephant", "warrior", "palace", "leprechaun"); } private void addGloveRules() { - addRule("", "gauntlets of ", - "gloves of ", " gloves"); - addRule("", "dexterity", "power"); - addRule("", "pushing", "choking", "bigby", "stunning"); + addRule("", + "gauntlets of ", + "gloves of ", + " gloves"); + addRule("", + "dexterity", "power"); + addRule("", + "pushing", "choking", "bigby", "stunning"); } private void addMiniWeaponRules() { - addRule("", "minature ", - "small ", "tiny ", - " sling", ""); - addRule("", "boomerang", "arrow", "net", "catapult", - "hammer", "sword", "club"); - addRule("", "seeking"); + addRule("", + "minature ", "small ", + "tiny ", " sling", + ""); + addRule("", + "boomerang", "arrow", "net", + "catapult", "hammer", "sword", "club"); + addRule("", + "seeking"); } private void addRockRules() { - addRule("", " pebble", "stone of ", + addRule("", + " pebble", "stone of ", " stone", "brick of ", " geode"); - addRule("", "inscribed", "elemental control"); - addRule("", "good-luck", "weight", "blind-defense", - "metal-clinging"); - addRule("", "flying"); - addRule("", "ioun"); + addRule("", + "inscribed", "elemental control"); + addRule("", + "good-luck", "weight", + "blind-defense", "metal-clinging"); + addRule("", + "flying"); + addRule("", + "ioun"); } private void addRopeRules() { - addRule("", " rope", "rope of ", + addRule("", + " rope", "rope of ", "ball of "); - addRule("", "trick", "entangling", "climbing", - "dancing", "tripping", "snaring", "levitating", - "self-entangling"); - addRule("", "endless"); - addRule("", "string", "yarn"); + addRule("", + "trick", "entangling", "climbing", "dancing", + "tripping", "snaring", "levitating", "self-entangling"); + addRule("", + "endless"); + addRule("", + "string", "yarn"); } private void addRule(String rule, String... cases) { IList> cses = new FunctionalList<>(); for (String strang : cases) { - cses.add(FunctionalStringTokenizer.fromString(strang) - .toList(s -> s)); + cses.add(FunctionalStringTokenizer.fromString(strang).toList(s -> s)); } grammar.makeRule(rule, cses); } private void addVialRules() { - addRule("", "vial of ", " vial", + addRule("", + "vial of ", " vial", " bottle", " flask"); - addRule("", "holding", "trapping", "experience", - "unnatural regeneration"); - addRule("", "ever-smoking", "wheezing", + addRule("", + "holding", "trapping", + "experience", "unnatural regeneration"); + addRule("", + "ever-smoking", "wheezing", "blank potion"); - addRule("", "iron"); + addRule("", + "iron"); } private void addWandRules() { - addRule("", " wand", "wand of ", + addRule("", + " wand", "wand of ", "canceling wand"); - addRule("", "magic missile", "", "", + addRule("", + "magic missile", "", "", "gusting", "life-detecting", "zadron"); - addRule("", "frost", "fire", "lightning", "fear", - "illumination", "polymorphing", "conjuration", - "paralyzing"); - addRule("", " detecting"); - addRule("", "magic", "enemy", "secret door/trap"); + addRule("", + "frost", "fire", "lightning", "fear", + "illumination", "polymorphing", "conjuration", "paralyzing"); + addRule("", + " detecting"); + addRule("", + "magic", "enemy", "secret door/trap"); } } diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java index 6f96874..1939c5e 100644 --- a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java +++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java @@ -20,7 +20,6 @@ import bjc.utils.gui.awt.SimpleFileDialog; * */ public class GrammarReaderApp { - /** * Main method of class * @@ -29,9 +28,9 @@ public class GrammarReaderApp { */ public static void main(String[] args) { try { - UIManager.setLookAndFeel( - UIManager.getSystemLookAndFeelClassName()); - } catch (ClassNotFoundException | InstantiationException + UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); + } catch (ClassNotFoundException + | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e) { e.printStackTrace(); @@ -43,8 +42,7 @@ public class GrammarReaderApp { @SuppressWarnings("null") private static void doSingleFile() { - File gramFile = SimpleFileDialog.getOpenFile(null, - "Choose Grammar File", ".gram"); + File gramFile = SimpleFileDialog.getOpenFile(null, "Choose Grammar File", ".gram"); WeightedGrammar grammar = null; @@ -63,7 +61,8 @@ public class GrammarReaderApp { return leftString.compareTo(rightString); }); - initRule = SimpleDialogs.getChoice(null, "Pick a initial rule", + initRule = SimpleDialogs.getChoice(null, + "Pick a initial rule", "Pick a initial rule to generate choices from", grammar.getRuleNames().toArray(new String[0])); } else { @@ -74,8 +73,7 @@ public class GrammarReaderApp { "Enter number of repetitions", "Enter the number of items to generate from the rule"); - File outputFile = SimpleFileDialog.getSaveFile(null, - "Choose Grammar File"); + File outputFile = SimpleFileDialog.getSaveFile(null, "Choose Grammar File"); PrintStream outputStream = null; @@ -86,8 +84,7 @@ public class GrammarReaderApp { } for (int i = 0; i < count; i++) { - String ruleResult = ListUtils.collapseTokens( - grammar.generateListValues(initRule, " ")); + String ruleResult = ListUtils.collapseTokens(grammar.generateListValues(initRule, " ")); outputStream.println(ruleResult.replaceAll("\\s+", " ")); } diff --git a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java index af03da0..84fee01 100644 --- a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java +++ b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java @@ -28,22 +28,18 @@ public class RBGrammarReader { state.startNewSubgrammar(); }); - reader.addPragma("load-sub-grammar", - RBGrammarReader::loadSubGrammar); + reader.addPragma("load-sub-grammar", RBGrammarReader::loadSubGrammar); reader.addPragma("save-sub-grammar", RBGrammarReader::saveGrammar); + reader.addPragma("edit-sub-grammar", RBGrammarReader::editSubGrammar); + reader.addPragma("remove-sub-grammar", RBGrammarReader::removeSubGrammar); - reader.addPragma("edit-sub-grammar", - RBGrammarReader::editSubGrammar); reader.addPragma("edit-parent", (tokenizer, state) -> { state.editParent(); }); reader.addPragma("promote", RBGrammarReader::promoteGrammar); - reader.addPragma("subordinate", - RBGrammarReader::subordinateGrammar); + reader.addPragma("subordinate", RBGrammarReader::subordinateGrammar); - reader.addPragma("remove-sub-grammar", - RBGrammarReader::removeSubGrammar); } private static void debugGrammar(ReaderState state) { @@ -56,15 +52,13 @@ public class RBGrammarReader { System.out.println(); } - private static void doCase(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void doCase(FunctionalStringTokenizer tokenizer, ReaderState state) { int ruleProbability = readOptionalProbability(tokenizer, state); state.addCase(ruleProbability, tokenizer.toList()); } - private static void editSubGrammar(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void editSubGrammar(FunctionalStringTokenizer tokenizer, ReaderState state) { String subgrammarName = tokenizer.nextToken(); state.editSubgrammar(subgrammarName); @@ -82,29 +76,24 @@ public class RBGrammarReader { * If something goes wrong during file reading * */ - public static WeightedGrammar fromPath(Path inputPath) - throws IOException { + public static WeightedGrammar fromPath(Path inputPath) throws IOException { ReaderState initialState = new ReaderState(inputPath); - try (FileInputStream inputStream = new FileInputStream( - inputPath.toFile())) { - return reader.fromStream(inputStream, initialState) - .getGrammar(); + try (FileInputStream inputStream = new FileInputStream(inputPath.toFile())) { + return reader.fromStream(inputStream, initialState).getGrammar(); } catch (IOException ioex) { throw ioex; } } - private static void importRule(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void importRule(FunctionalStringTokenizer tokenizer, ReaderState state) { String ruleName = tokenizer.nextToken(); String subgrammarName = tokenizer.nextToken(); state.addGrammarAlias(subgrammarName, ruleName); } - private static void initialRule(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void initialRule(FunctionalStringTokenizer tokenizer, ReaderState state) { String initialRuleName = tokenizer.nextToken(); state.setInitialRule(initialRuleName); @@ -131,35 +120,30 @@ public class RBGrammarReader { reader.addPragma("suffix-with", RBGrammarReader::suffixRule); } - private static void loadSubGrammar(FunctionalStringTokenizer stk, - ReaderState rs) { + private static void loadSubGrammar(FunctionalStringTokenizer stk, ReaderState rs) { String subgrammarName = stk.nextToken(); String subgrammarPath = stk.nextToken(); rs.loadSubgrammar(subgrammarName, subgrammarPath); } - private static void prefixRule(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void prefixRule(FunctionalStringTokenizer tokenizer, ReaderState state) { String ruleName = tokenizer.nextToken(); String prefixToken = tokenizer.nextToken(); - int additionalProbability = readOptionalProbability(tokenizer, - state); + int additionalProbability = readOptionalProbability(tokenizer, state); state.prefixRule(ruleName, prefixToken, additionalProbability); } - private static void promoteGrammar(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void promoteGrammar(FunctionalStringTokenizer tokenizer, ReaderState state) { String subgrammarName = tokenizer.nextToken(); String subordinateName = tokenizer.nextToken(); state.promoteGrammar(subgrammarName, subordinateName); } - private static int readOptionalProbability( - FunctionalStringTokenizer tokenizer, ReaderState state) { + private static int readOptionalProbability(FunctionalStringTokenizer tokenizer, ReaderState state) { if (state.isUniform()) { return 0; } @@ -167,22 +151,19 @@ public class RBGrammarReader { return Integer.parseInt(tokenizer.nextToken()); } - private static void removeRule(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void removeRule(FunctionalStringTokenizer tokenizer, ReaderState state) { String ruleName = tokenizer.nextToken(); state.deleteRule(ruleName); } - private static void removeSubGrammar( - FunctionalStringTokenizer tokenizer, ReaderState state) { + private static void removeSubGrammar(FunctionalStringTokenizer tokenizer, ReaderState state) { String subgrammarName = tokenizer.nextToken(); state.deleteSubgrammar(subgrammarName); } - private static void saveGrammar(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void saveGrammar(FunctionalStringTokenizer tokenizer, ReaderState state) { String subgrammarName = tokenizer.nextToken(); state.saveSubgrammar(subgrammarName); @@ -208,20 +189,17 @@ public class RBGrammarReader { }); } - private static void subordinateGrammar( - FunctionalStringTokenizer tokenizer, ReaderState state) { + private static void subordinateGrammar(FunctionalStringTokenizer tokenizer, ReaderState state) { String grammarName = tokenizer.nextToken(); state.subordinateGrammar(grammarName); } - private static void suffixRule(FunctionalStringTokenizer tokenizer, - ReaderState state) { + private static void suffixRule(FunctionalStringTokenizer tokenizer, ReaderState state) { String ruleName = tokenizer.nextToken(); String suffixToken = tokenizer.nextToken(); - int additionalProbability = readOptionalProbability(tokenizer, - state); + int additionalProbability = readOptionalProbability(tokenizer, state); state.suffixRule(ruleName, suffixToken, additionalProbability); } diff --git a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java index 680f67b..b455844 100644 --- a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java +++ b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java @@ -65,8 +65,7 @@ public class ReaderState { * @param newWorkingGrammar * The new grammar to use */ - public void setCurrentGrammar( - WeightedGrammar newWorkingGrammar) { + public void setCurrentGrammar(WeightedGrammar newWorkingGrammar) { currentGrammar = newWorkingGrammar; } @@ -121,8 +120,7 @@ public class ReaderState { * @param ruleParts * The parts that make up this case */ - public void addCase(int ruleProbability, - IList ruleParts) { + public void addCase(int ruleProbability, IList ruleParts) { currentGrammar.addCase(currentRule, ruleProbability, ruleParts); } @@ -133,8 +131,7 @@ public class ReaderState { * The name of the subgrammar to edit */ public void editSubgrammar(String subgrammarName) { - WeightedGrammar subgrammar = currentGrammar - .getSubgrammar(subgrammarName); + WeightedGrammar subgrammar = currentGrammar.getSubgrammar(subgrammarName); grammarStack.push(currentGrammar); @@ -168,8 +165,7 @@ public class ReaderState { * @param subgrammarAlias * The name of the alias for the subgrammar */ - public void addGrammarAlias(String subgrammarName, - String subgrammarAlias) { + public void addGrammarAlias(String subgrammarName, String subgrammarAlias) { currentGrammar.addGrammarAlias(subgrammarName, subgrammarAlias); } -- cgit v1.2.3