package visualization.statistics;
public abstract class ModelStatistics extends LineChart{ 
  }
 
package visualization.statistics;
public class GameOfLifeStatistics extends ModelStatistics{ 
      public GameOfLifeStatistics() 
}
 
package visualization.statistics;
public class SegregationStatistics extends ModelStatistics{ 
      public SegregationStatistics() 
}
 
package visualization.statistics;
public class SpreadingFireStatistics extends ModelStatistics{ 
      public SpreadingFireStatistics() 
}
 
package visualization.statistics;
public class WaTorStatistics extends ModelStatistics{ 
      public WaTorStatistics() 
}
 
package visualization.model_controls;
public class GameOfLifeControl extends ModelControl<Integer> { 
      public GameOfLifeControl(Simulator<Integer> sim)  super(sim); }
    public GameOfLifeControl(String shape)  this(GameOfLife.generate(DEFAULT_CELL_NUM, shape)); }
    public void handleStructureChange(int numCell, List<Pair<Integer, Integer>> neighborIndices) 
    public void handleParamChange() 
}
 
package visualization.model_controls;
public class SpreadingFireControl extends ModelControl<Integer> { 
      public static final Label probCatchCaption = new Label("probCatch:");
    public SpreadingFireControl(String shape)  this(SpreadingFire.generate(DEFAULT_CELL_NUM, shape)); }
    public SpreadingFireControl(Simulator<Integer> sim) 
    public void handleStructureChange(int numCell, List<Pair<Integer, Integer>> neighborIndices) 
    public void handleParamChange() 
}
 
package visualization.model_controls;
public class WaTorControl extends ModelControl<Fish> { 
      public static final Label fishBreedCaption = new Label("Fish Breeding Period:");
    public static final Label sharkBreedCaption = new Label("Shark Breeding Period:");
    public static final Label sharkStarveCaption = new Label("Shark Starve Period:");
    public WaTorControl(String shape)  this(WaTor.generate(DEFAULT_CELL_NUM, shape)); }
    public WaTorControl(Simulator<Fish> sim) 
    public void handleStructureChange(int numCell, List<Pair<Integer, Integer>> neighborIndices) 
    public void handleParamChange() 
}
 
package visualization.model_controls;
public abstract class ModelControl<T> extends VBox { 
      public ModelControl(Simulator<T> sim) 
    public abstract void handleStructureChange(int numCell, List<Pair<Integer, Integer>> neighborIndices);
    public abstract void handleParamChange();
    public boolean consumeIsDirty() 
    public SimulationPanel<T> simPanel()  return simPanel; }
    public Simulator<T> simulator()  return simPanel.simulator(); }
}
 
package visualization.model_controls;
public class SegregationControl extends ModelControl<Integer> { 
      public static final Label thresholdCaption = new Label("Threshold:");
    public SegregationControl(String shape) 
    public SegregationControl(Simulator<Integer> sim) 
    public void handleStructureChange(int numCell, List<Pair<Integer, Integer>> neighborIndices) 
    public void handleParamChange() 
}
 
package visualization;
public class SimulationPanel<T> extends VBox { 
      public SimulationPanel(Simulator<T> sim) 
    public Simulator<T> simulator()  return simulator; }
}
 
package visualization.neighbor_chooser;
public class NeighborChooser extends Dialog<List<Pair<Integer, Integer>>> { 
      public NeighborChooser(String shapeType) 
}
 
package visualization.neighbor_chooser;
public class NeighborChooserPane extends DialogPane { 
      public NeighborChooserPane(String shapeType) 
    public List<Pair<Integer, Integer>> getChosenIndices() 
}
 
package visualization.neighbor_chooser;
public class IndexedShape { 
      public IndexedShape(Shape shape_, Integer rowOffset_, Integer columnOffset_) 
    public Shape shape()  return shape; }
    public Pair<Integer, Integer> offset()  return new Pair<>(rowOffset, columnOffset); }
    public boolean selected()  return selected; }
    public void toggleSelection() 
}
 
package visualization;
public class Main extends Application { 
      public void start(Stage primaryStage) 
}
 
package visualization;
public class SimulationControl extends HBox { 
      public SimulationControl(Window window_, ResourceBundle myResources, String myLanguage) 
    public void tick(double duration, ModelStatistics modelChart) 
    public StatusCode consumeStatusCode() 
    public String[] models()  return models; }
}
 
package visualization;
public class GUI { 
      public GUI (String language) 
    public void runGUI (Stage primaryStage) 
    public void step(double duration) 
}
 
package simulation;
public class CellGraph<T> extends HashMap<Cell<T>, List<Cell<T>>> { 
      public Set<Cell<T>> getCells()  return keySet(); }
    public List<Cell<T>> getOrderedCells(SimulationModel<T> model) 
    public Set<Node> getViews()  return getCells().stream().map(Cell::view).collect(Collectors.toSet()); }
    public List<Cell<T>> getNeighbors(Cell<T> cell)  return get(cell); }
    public int shapeCode() 
}
 
package simulation.models;
public class WaTorModel implements SimulationModel<Fish> { 
      public WaTorModel(int fishBreedPeriod_, int sharkBreedPeriod_, int sharkStarvePeriod_) 
    public int updatePriority(Fish myVal) 
    public void localUpdate(Cell<Fish> me, List<Cell<Fish>> neighbors) 
    public void globalUpdate(CellGraph<Fish> graph) 
    public Fish nextValue(Fish myVal) 
    public Color chooseColor(Fish myVal) 
    public String modelName()  return MODEL_NAME; }
    public Map<String, Integer> getStatistics(List<Fish> values) 
    public XMLWriter<Fish> getXMLWriter(CellGraph<Fish> graph, File outFile, String language) 
    public void updateModelParams(Map<String, String> params) 
    public Fish getValFromCode(int code) 
    public List<Integer> getCodes() 
    public int getDefaultCode() 
    public int getFishBreedPeriod()  return fishBreedPeriod; }
    public int getSharkBreedPeriod()  return sharkBreedPeriod; }
    public int getSharkStarvePeriod()  return sharkStarvePeriod; }
}
 
package simulation.models;
 public interface SimulationModel<T> {
  }
 
package simulation.models.wator;
public class Shark extends Fish { 
      public Shark()  this(0, 0); }
    public Shark(int breedingCounter, int starveCounter_) 
    public int tick(int breedPeriod, int starvePeriod) 
    public void eat()  starveCounter = 0; }
    public int kind()  return WaTorModel.SHARK; }
}
 
package simulation.models.wator;
public class Fish { 
      public Fish()  this(0); }
    public Fish(int breedCounter_)  breedCounter = breedCounter_; starveCounter = 0; }
    public int tick(int breedPeriod, int starvePeriod) 
    public void breed()  breedCounter = 0; }
    public void eat() 
    public int kind()  return WaTorModel.FISH; }
    public int breedCounter()  return breedCounter; }
    public int starveCounter()  return starveCounter; }
}
 
package simulation.models;
public class SegregationModel implements SimulationModel<Integer> { 
      public SegregationModel(double threshold)  satisfactionThreshold = threshold; }
    public int updatePriority(Integer myVal)  return 0; }
    public void localUpdate(Cell<Integer> me, List<Cell<Integer>> neighbors) 
    public void globalUpdate(CellGraph<Integer> graph) 
    public Integer nextValue(Integer myVal) 
    public Color chooseColor(Integer myVal) 
    public String modelName()  return MODEL_NAME; }
    public Map<String, Integer> getStatistics(List<Integer> values) 
    public XMLWriter<Integer> getXMLWriter(CellGraph<Integer> graph, File outFile, String language) 
    public void updateModelParams(Map<String, String> params) 
    public Integer getValFromCode(int code) 
    public List<Integer> getCodes() 
    public int getDefaultCode() 
    public double getSatisfactionThreshold()  return satisfactionThreshold; }
}
 
package simulation.models;
public class SpreadingFireModel implements SimulationModel<Integer> { 
      public SpreadingFireModel(double probCatch_) 
    public int updatePriority(Integer myVal)  return 0; }
    public void localUpdate(Cell<Integer> me, List<Cell<Integer>> neighbors) 
    public void globalUpdate(CellGraph<Integer> graph) 
    public Integer nextValue(Integer myVal) 
    public Color chooseColor(Integer myVal) 
    public String modelName()  return MODEL_NAME; }
    public Map<String, Integer> getStatistics(List<Integer> values) 
    public XMLWriter<Integer> getXMLWriter(CellGraph<Integer> graph, File outFile, String language) 
    public void updateModelParams(Map<String, String> params) 
    public Integer getValFromCode(int code) 
    public List<Integer> getCodes() 
    public int getDefaultCode() 
    public double getProbCatch()  return probCatch; }
}
 
package simulation.models;
public class GameOfLifeModel implements SimulationModel<Integer> { 
      public int updatePriority(Integer myVal)  return 0; }
    public void localUpdate(Cell<Integer> me, List<Cell<Integer>> neighbors) 
    public void globalUpdate(CellGraph<Integer> graph) 
    public Integer nextValue(Integer myVal)  return myVal == ALIVE ? DEAD : ALIVE; }
    public Color chooseColor(Integer myVal)  return myVal == DEAD ? Color.WHITE : Color.BLACK; }
    public String modelName()  return MODEL_NAME; }
    public Map<String, Integer> getStatistics(List<Integer> values) 
    public GameOfLifeWriter getXMLWriter(CellGraph<Integer> graph, File outFile, String language) 
    public void updateModelParams(Map<String, String> params) 
    public Integer getValFromCode(int code) 
    public List<Integer> getCodes() 
    public int getDefaultCode() 
}
 
package simulation;
public class Simulator<T> { 
      public Simulator(CellGraph<T> graph_, SimulationModel<T> model_) 
    public void tick() 
    public Node view() 
    public int tickCount()  return tickCount; }
    public String modelName()  return model.modelName(); }
    public XMLWriter<T> getWriter(File outFile, String language)  return model.getXMLWriter(graph, outFile, language); }
    public void updateSimulationModel(Map<String, String> params)  model.updateModelParams(params); }
    public String peekShape() 
    public Map<String, Integer> getStatistics() 
}
 
package simulation;
public class Cell<T> { 
      public Cell(T value_, int shapeCode_, double cx_, double cy_, double width_, double height_) 
    public void commit()  value = next; next = null; }
    public void updateView(SimulationModel<T> model)  view.setFill(model.chooseColor(value)); }
    public void handleClick(SimulationModel<T> model)  value = model.nextValue(value); updateView(model); }
    public T value()  return value; }
    public T next()  return next; }
    public int shapeCode()  return shapeCode; }
    public double cx()  return cx; }
    public double cy()  return cy; }
    public double width()  return width; }
    public double height()  return height; }
    public Shape view()  return view; }
    public void setNext(T next_)  next = next_; }
}
 
package simulation.factory;
public class GameOfLife { 
      public static Simulator<Integer> generateTri(int row, int column,
    public static Simulator<Integer> generateRect(int row, int column,
    public static Simulator<Integer> generate(int n, String shape, List<Pair<Integer, Integer>> indices) 
    public static Simulator<Integer> generate(int n, String shape)  return generate(n, shape, null); }
}
 
package simulation.factory;
public class WaTor { 
      public static Simulator<Fish> generateTri(
    public static Simulator<Fish> generateRect(
    public static Simulator<Fish> generate(int n, String shape, List<Pair<Integer, Integer>> indices) 
    public static Simulator<Fish> generate(int n, String shape)  return generate(n, shape, null); }
}
 
package simulation.factory;
public class NeighborUtils { 
      public static <T> CellGraph<T> triangularGraph(List<Cell<T>> cells,
    public static <T> CellGraph<T> triangularGraphWrap(List<Cell<T>> cells,
    public static <T> CellGraph<T> rectangularGraph(List<Cell<T>> cells,
    public static <T> CellGraph<T> rectangularGraphWrap(List<Cell<T>> cells,
    public static List<Pair<Integer, Integer>> indicesFor12Triangle() 
    public static List<Pair<Integer, Integer>> indicesFor8Rectangle() 
    public static List<Pair<Integer, Integer>> indicesFor4Rectangle() 
}
 
package simulation.factory;
public class Segregation { 
      public static Simulator<Integer> generateTri(
    public static Simulator<Integer> generateRect(
    public static Simulator<Integer> generate(int n, String shape, List<Pair<Integer, Integer>> indices) 
    public static Simulator<Integer> generate(int n, String shape)  return generate(n, shape, null); }
}
 
package simulation.factory;
public class SpreadingFire { 
      public static Simulator<Integer> generateTri(
    public static Simulator<Integer> generateRect(
    public static Simulator<Integer> generate(int n, String shape, List<Pair<Integer, Integer>> indices) 
    public static Simulator<Integer> generate(int n, String shape)  return generate(n, shape, null); }
}
 
package xml.parser;
public class SegregationXMLParser extends ParentXMLParser { 
      public static final Map<String, Map<String, Object>> VAL_TAG_TO_RANGE_MAP = Map.ofEntries(
    public SegregationXMLParser(String language) 
    public Simulator<Integer> getSimulator(File datafile) 
}
 
package xml.parser;
public class GameOfLifeXMLParser extends ParentXMLParser { 
      public static final Map<String, Map<String, Object>> VAL_TAG_TO_RANGE_MAP = Map.ofEntries(
    public GameOfLifeXMLParser(String language) 
    public Simulator<Integer> getSimulator(File datafile) 
}
 
package xml.parser;
public class SpreadingFireXMLParser extends ParentXMLParser { 
      public static final Map<String, Map<String, Object>> VAL_TAG_TO_RANGE_MAP = Map.ofEntries(
    public SpreadingFireXMLParser(String language) 
    public Simulator<Integer> getSimulator(File datafile) 
}
 
package xml.parser;
public class WaTorXMLParser extends ParentXMLParser { 
      public static final Map<String, Map<String, Object>> VAL_TAG_TO_RANGE_MAP = Map.ofEntries(
    public WaTorXMLParser(String language) 
    public Simulator<Fish> getSimulator(File datafile) 
}
 
package xml.parser;
public abstract class ParentXMLParser<T> { 
      public ParentXMLParser(String language) 
    public abstract Simulator<T> getSimulator(File datafile);
    public CellGraph<T> getCellGraph(Element root, SimulationModel<T> model) 
    public ArrayList<ArrayList<T>> cellValsFromList(Element root, SimulationModel<T> model, int n) 
    public ArrayList<ArrayList<T>> cellValsFromProbs(Element root, SimulationModel<T> model, int n) 
    public Map<T, Double> getValToProbMap(Element root, SimulationModel<T> model) 
    public CellGraph<T> generateRect(int row, int column, ArrayList<ArrayList<T>> vals) 
    public CellGraph<T> generateTri(int row, int column, ArrayList<ArrayList<T>> vals) 
    public static String getTextValue(Element e, String tagName) 
    public static int getIntValue(Element e, String tagName, int min, int max, int def) 
    public static double getDoubleValue(Element e, String tagName, double min, double max, double def) 
    public static Element getRootElement(File xmlFile) 
    public static String peekModelName(File xmlFile) 
    public static DocumentBuilder getDocumentBuilder() 
}
 
package xml.writer;
public class SegregationWriter extends XMLWriter<Integer> { 
      public SegregationWriter(SegregationModel model_, CellGraph<Integer> graph_, File outFile_, String language) 
}
 
package xml.writer;
public class GameOfLifeWriter extends XMLWriter<Integer> { 
      public GameOfLifeWriter(CellGraph<Integer> graph_, File outFile_, String language) 
}
 
package xml.writer;
public class WaTorWriter extends XMLWriter<Fish> { 
      public WaTorWriter(WaTorModel model_, CellGraph<Fish> graph_, File outFile_, String language) 
}
 
package xml.writer;
public abstract class XMLWriter<T> { 
      public XMLWriter(CellGraph<T> graph_, File outFile_, String language) 
    public void generate() 
}
 
package xml.writer;
public class SpreadingFireWriter extends XMLWriter<Integer> { 
      public SpreadingFireWriter(SpreadingFireModel model_, CellGraph<Integer> graph_, File outFile_, String language) 
}
 
package xml;
public class XMLException extends RuntimeException { 
      public XMLException (String message, Object ... values) 
    public XMLException (Throwable cause, String message, Object ... values) 
    public XMLException (Throwable cause) 
}
 
package utility;
public class ColorUtils { 
      public static Color mix(Color a, Color b, double pA) 
}
 
package utility;
public class ShapeUtils { 
      public static void centerShape(Shape s, double cx, double cy) 
    public static Shape makeShape(int shapeCode, double cx, double cy, double w, double h) 
    public static List<Integer> shapeCodes() 
    public static String[] shapes() 
}