package cellsociety.utils;
public record ReflectionArgument(Class<?>[] classes, Object[] objects) {
}
 
package cellsociety.utils;
public class ReflectionHandler {
 public static <T> T getInstance(Class<T> clazz, String className,
 public static Object invokeDeclaredMethod(Object target, String methodName,
 public static Object invokeDeclaredMethod(Object target, String methodName)
 public static Object invokeStaticMethod(String className, String methodName,
 public static Class<?> getClass(String className) throws ReflectionException 
}
 
package cellsociety.utils;
public class Randoms {
 public static final Random RANDOM_ENGINE 
 public static <I> I randomElement(List<I> list) 
 public static boolean randomChanceTrue(final int chance) 
}
 
package cellsociety.backend;
public abstract class CellManager<I extends CellModel> implements Serializable {
 protected CellManager(
 public void setParams(Map<String, String> params) 
 protected Map<String, String> getParams() 
 public void resetAllCells() 
 public List<I> getAllCells() 
 public I toggleCellStateAt(final CellPosition cellPosition) 
 public I toggleCellStateAt(final int x, final int y) 
 public void addCell(final int x, final int y, final CellState cellState) 
 public void addCell(final CellPosition position, final CellState cellState) 
 public void removeCellAt(final CellPosition cellPosition) 
 public void removeCell(final I cell) 
 public abstract void updateCells();
 public I getCellAtOrNull(final CellPosition cellPosition) 
 public List<I> getNeighborsOf(final I cell) 
 protected CellPositionNeighbors getNeighborsObject() 
 protected abstract I createCell(
 protected List<I> getNeighborsOfState(final I cell, final CellState cellState) 
 protected List<CellPosition> getPositionsAround(final CellPosition cellPosition) 
}
 
package cellsociety.backend;
public class TransitoryCellDominance implements CellDominance, Serializable {
 public TransitoryCellDominance() 
 public TransitoryCellDominance(Map<CellState, CellState> dominanceMap)
 public void reset() 
 public void buildDominanceFromMapping(Map<CellState, CellState> dominanceMap)
 public boolean doesStateWinAgainst(CellState current, CellState other) 
 public boolean doesStateLoseAgainst(CellState current, CellState other) 
 public void addDominance(CellState dominantState, CellState losingState)
}
 
package cellsociety.backend.parser;
public class CellGrid implements Iterable<CellModel>, Serializable {
 public CellGrid(List<CellModel> cellList) 
 public Iterator<CellModel> iterator() 
}
 
package cellsociety.backend.parser;
public class CellFactory {
 public static CellGenerator generate(String type) 
}
 
package cellsociety.backend.parser;
public class FileLoader {
 public static final String INVALID_PATH 
 public FileLoader(Path path) 
 public CellGrid getGrid() throws ReflectionException 
 public GameInformation getGameInformation() throws ReflectionException 
}
 
package cellsociety.backend.parser;
public class RuleLoader {
 public RuleLoader(Path path) 
 public int getNewState(int oldState, List<Integer> neighbors) 
}
 
package cellsociety.backend.parser;
public class GridParser {
 public static int[][] parseFromCSV(String csvPath) 
 public static int[][] parseFromEncoding(String encoding) 
 public static int[][] parseFromRandom(String random) 
}
 
package cellsociety.backend.exceptions;
public class ExistingCellException extends RuntimeException {
 public ExistingCellException(final String message) 
}
 
package cellsociety.backend.exceptions;
public class InvalidPositionValuesException extends RuntimeException {
 public InvalidPositionValuesException(final String message) 
}
 
package cellsociety.backend.exceptions;
public class NonexistentCellException extends RuntimeException {
 public NonexistentCellException(final String message) 
}
 
package cellsociety.backend.exceptions;
public class CellDominanceCyclicityException extends Exception {
 public CellDominanceCyclicityException(String message) 
}
 
package cellsociety.backend.exceptions;
public class CellOutOfBoundsException extends RuntimeException {
 public CellOutOfBoundsException(final String message) 
}
 
package cellsociety.backend;
public abstract class TurnCellManager<I extends CellModel> extends CellManager<I> {
 protected TurnCellManager(Container bounds) 
 public void updateCells() 
 protected abstract I updateCell(I cell);
}
 
package cellsociety.backend;
public interface CellState extends Serializable {
 String getStateRepr();
 CellState nextState();
 int ordinal();
}
 
package cellsociety.backend.simulations.langtonloops;
public class LangtonLoopsCellModel extends CellModel {
 public LangtonLoopsCellModel(CellPosition cellPosition, CellState cellState) 
}
 
package cellsociety.backend.simulations.langtonloops;
public class LangtonLoopsCellManager extends TurnCellManager<LangtonLoopsCellModel> {
 public LangtonLoopsCellManager(final Container container) 
 protected LangtonLoopsCellModel createCell(CellPosition cellPosition, CellState cellState) 
 public LangtonLoopsCellModel updateCell(LangtonLoopsCellModel cell) 
}
 
package cellsociety.backend.simulations.wator;
public class WatorCellManager extends CellManager<WatorCellModel> {
 public WatorCellManager(final Container bounds) 
 public void setFishStartingBreedingTime(int fishStartingBreedingTime) 
 public void setFishBreedingTime(int fishBreedingTime) 
 public void setSharkStartingEnergy(int sharkStartingEnergy) 
 public void setSharkEnergyGain(int sharkEnergyGain) 
 public void setSharkEnergyLoss(int sharkEnergyLoss) 
 public void setSharkEnergyToBreed(int sharkEnergyToBreed) 
 public void updateCells() 
 protected WatorCellModel createCell(CellPosition cellPosition, CellState cellState) 
}
 
package cellsociety.backend.simulations.wator;
public class WatorCellModel extends CellModel {
 public WatorCellModel(
 public WatorCellModel(
 public void incrementTime() 
 public int getTime() 
 public void resetTime() 
 public void incrementEnergyBy(int energy) 
 public void decrementEnergyBy(int energy) 
 public int getEnergy() 
}
 
package cellsociety.backend.simulations.percolation;
public class PercolationCellModel extends CellModel {
 public PercolationCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.percolation;
public class PercolationCellManager extends TurnCellManager<PercolationCellModel> {
 public PercolationCellManager(Container bounds) 
 protected PercolationCellModel createCell(CellPosition cellPosition,
 public PercolationCellModel updateCell(PercolationCellModel cell) 
}
 
package cellsociety.backend.simulations.fallingsand;
public class FallingSandCellManager extends TurnCellManager<FallingSandCellModel> {
 public FallingSandCellManager(Container bounds) 
 protected FallingSandCellModel createCell(CellPosition cellPosition, CellState cellState) 
 public void updateCells() 
 protected FallingSandCellModel updateCell(FallingSandCellModel cell) 
}
 
package cellsociety.backend.simulations.fallingsand;
public class FallingSandCellModel extends CellModel {
 public FallingSandCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.rockpaperscissors;
public class RockPaperScissorsCellModel extends CellModel {
 public RockPaperScissorsCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.rockpaperscissors;
public class RockPaperScissorsCellManager extends TurnCellManager<RockPaperScissorsCellModel> {
 public RockPaperScissorsCellManager(
 public void setRockPaperScissorsDominanceThreshold(int rockPaperScissorsDominanceThreshold) 
 protected RockPaperScissorsCellModel updateCell(RockPaperScissorsCellModel cell) 
 protected RockPaperScissorsCellModel createCell(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.gameoflife;
public class GameOfLifeCellManager extends TurnCellManager<GameOfLifeCellModel> {
 public GameOfLifeCellManager(final Container container) 
 protected GameOfLifeCellModel createCell(CellPosition cellPosition,
 public GameOfLifeCellModel updateCell(GameOfLifeCellModel cell) 
}
 
package cellsociety.backend.simulations.gameoflife;
public class GameOfLifeCellModel extends CellModel {
 public GameOfLifeCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.segregation;
public class SegregationCellModel extends CellModel {
 public SegregationCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.segregation;
public class SegregationCellManager extends CellManager<SegregationCellModel> {
 public SegregationCellManager(Container bounds) 
 public void setSatisfactionThreshold(int satisfactionThreshold) 
 public void updateCells() 
 protected SegregationCellModel createCell(CellPosition cellPosition,
}
 
package cellsociety.backend.simulations.spreadingfire;
public class SpreadingOfFireCellManager extends TurnCellManager<SpreadingOfFireCellModel> {
 public void setChanceOfFireSpreading(int chanceOfFireSpreading) 
 public SpreadingOfFireCellManager(
 protected SpreadingOfFireCellModel createCell(CellPosition cellPosition,
 public SpreadingOfFireCellModel updateCell(SpreadingOfFireCellModel cell) 
}
 
package cellsociety.backend.simulations.spreadingfire;
public class SpreadingOfFireCellModel extends CellModel {
 public SpreadingOfFireCellModel(CellPosition cellPosition,
}
 
package cellsociety.backend;
public abstract class CellModel implements Serializable {
 public CellModel(
 public CellPosition getCellPosition() 
 public CellState getCellState() 
 public void setCellPosition(CellPosition cellPosition) 
 public void setCellState(CellState cellState) 
 public String toString() 
}
 
package cellsociety.backend.positions;
public record CellPosition(int x, int y) implements Serializable {
public record CellPosition(int x, int y) implements Serializable 
}
 
package cellsociety.backend.containers;
public class UnboundedContainer extends Container {
 public UnboundedContainer(CellPositionNeighbors neighbors) 
 public boolean withinBounds(CellPosition cellPosition) 
 public CellPosition transformPos(CellPosition cellPosition) 
}
 
package cellsociety.backend.containers;
public abstract class Container implements Serializable {
 public Container(
 public abstract boolean withinBounds(final CellPosition cellPosition);
 public abstract CellPosition transformPos(final CellPosition cellPosition);
 public List<CellPosition> positionsAround(final CellPosition cellPosition) 
 public CellPositionNeighbors getNeighbors() 
}
 
package cellsociety.backend.containers;
public class FiniteContainer extends Container {
 public FiniteContainer(
 public FiniteContainer(
 public boolean withinBounds(final CellPosition cellPosition)
 public CellPosition transformPos(CellPosition cellPosition) 
}
 
package cellsociety.backend.containers;
public class ToroidalContainer extends Container {
 public ToroidalContainer(
 public boolean withinBounds(final CellPosition cellPosition)
 public CellPosition transformPos(CellPosition cellPosition) 
}
 
package cellsociety.backend;
public interface CellDominance {
 boolean doesStateWinAgainst(CellState current, CellState other);
 boolean doesStateLoseAgainst(CellState current, CellState other);
 void addDominance(CellState dominantState, CellState losingState)
 void reset();
 void buildDominanceFromMapping(Map<CellState, CellState> dominanceMap)
}
 
package cellsociety.backend.neighbors;
public interface GravityCellPositionNeighbors extends CellPositionNeighbors {
 default List<CellPosition> getNeighbors(CellPosition cellPosition)
}
 
package cellsociety.backend.neighbors;
public class RectanglePositionNeighbors implements CellPositionNeighbors {
 public List<CellPosition> getNeighbors(CellPosition cellPosition) 
}
 
package cellsociety.backend.neighbors;
public class GravityRectanglePositionNeighbors implements GravityCellPositionNeighbors {
 public CellPosition getLowerNeighbors(CellPosition cellPosition) 
 public List<CellPosition> getSideNeighbors(CellPosition cellPosition) 
 public List<CellPosition> getUpperNeighbors(CellPosition cellPosition) 
}
 
package cellsociety.backend.neighbors;
public interface CellPositionNeighbors extends Serializable {
 List<CellPosition> getNeighbors(CellPosition cellPosition);
}
 
package cellsociety.backend.neighbors;
public class CompletePositionNeighbors implements CellPositionNeighbors {
 public List<CellPosition> getNeighbors(CellPosition cellPosition) 
}
 
package cellsociety.controller;
public class GameController implements GameEventListener {
 public GameController(Path path, GameEventHandler gameEventHandler) 
 public void loadSimulation() 
 public void onGameEvent(GameEvent event) 
 public void sendGameConfig() 
 public void cellStateUpdate() 
 public void initializeCells() 
 public void sendCellConfig() 
 public void updateCells() 
 public void setNewPathUpdateGame() 
 public void loadStateFromPath() 
 public void saveStateToPath() 
}
 
package cellsociety.controller;
public record GameInformation(String type, String title, String author, String description,
}
 
package cellsociety;
public class Main extends Application {
 public void start(Stage primaryStage) 
}
 
package cellsociety.view.cellviews;
public class FallingSandCellView extends RectangleCellView {
 public FallingSandCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public interface Label {
 void setLabel(String label);
 void addTo(Node node);
}
 
package cellsociety.view.cellviews;
public class LangtonLoopsCellView extends RectangleCellView {
 public LangtonLoopsCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public class CellToolTip implements Label {
 public CellToolTip() 
 public void setLabel(String label) 
 public void addTo(Node node) 
}
 
package cellsociety.view.cellviews;
public class SegregationCellView extends RectangleCellView {
 public SegregationCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public abstract class RectangleCellView implements CellView {
 public RectangleCellView(double xcenter, double ycenter, double boundingRectangleWidth,
 public Node getNode() 
 public void setLabel(Label label) 
 public String getStateRepr() 
 public void updateColorMapping(String cellStateRepr, Color color) 
 protected void fillInitialColorMapping(String resourcesBundleLocation) 
}
 
package cellsociety.view.cellviews;
public class SpreadingOfFireCellView extends RectangleCellView {
 public SpreadingOfFireCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public class PercolationCellView extends RectangleCellView {
 public PercolationCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public class GameOfLifeCellView extends RectangleCellView {
 public GameOfLifeCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.cellviews;
public class WatorCellView extends RectangleCellView {
 public WatorCellView(double xcenter, double ycenter, double boundingRectangleWidth,
}
 
package cellsociety.view.panel;
public class SimulationPane extends Pane implements GameEventListener {
 public SimulationPane(double interval, GameEventHandler gameEventHandler) 
 public void onGameEvent(GameEvent event) 
 public void start() 
 public void stop() 
 public void step() 
 public void delay() 
}
 
package cellsociety.view.panel;
public class ControlPanel extends ScrollPane {
 public ControlPanel(ResourceBundle resources, GameInformation gameInformation,
}
 
package cellsociety.view;
public class GameView {
 public GameView(Stage primaryStage, String language, GameEventHandler gameEventHandler) 
 public void start() 
}
 
package cellsociety.view;
public interface CellView {
 void updateColorMapping(String cellStateRepr, Color color);
 void setLabel(Label label);
 Node getNode();
 String getStateRepr();
}
 
package cellsociety.view.scene;
public class StartScreen {
 public StartScreen() 
 public Scene makeScene() 
 public String getTitle() 
}
 
package cellsociety.view.scene;
public class GamePlayView extends BorderPane implements GameEventListener {
 public GamePlayView(Stage primaryStage, String language, GameInformation gameInformation,
 public void setupGamePlayScene() 
 public void initializeCells() 
 public void onGameEvent(GameEvent event) 
 public void setDividerInitPosition() 
 public void updateCellViews() 
 public void showError(String message) 
 public void showError() 
 public void save() 
 public void load() 
 public void teardown() 
}
 
package cellsociety.view.scene;
public class SceneManager implements GameEventListener {
 public SceneManager(Stage primaryStage, String language, GameEventHandler gameEventHandler) 
 public void setGamePlayScene(GameInformation gameInformation) 
 public void onGameEvent(GameEvent event) 
}
 
package cellsociety.event;
public class GameEventHandler {
 public GameEventHandler() 
 public void addEventListener(GameEventListener subscriber) 
 public void removeEventListener(GameEventListener subscriber) 
 public void publish(GameEvent e) 
 public void publish(GameEventType gameEventType) 
}
 
package cellsociety.event;
public class GameEvent {
 public GameEvent(GameEventType type) 
 public GameEvent(GameEventType type, Command<?> cmd) 
 public String toString() 
 public GameEventType getGameEventType() 
 public Command<?> getGameEventCommand() 
}
 
package cellsociety.event;
public interface GameEventListener {
 void onGameEvent(GameEvent event);
}
 
package cellsociety.event.command;
public class SaveNewSimulationCommand implements Command<Path> {
 public SaveNewSimulationCommand(Path path) 
 public Path getCommandArgument() 
}
 
package cellsociety.event.command;
public class LoadSimulationCommand implements Command<Path> {
 public LoadSimulationCommand(Path path) 
 public Path getCommandArgument() 
}
 
package cellsociety.event.command;
public class StepCommand implements Command<Double> {
 public StepCommand(double delay) 
 public Double getCommandArgument() 
}
 
package cellsociety.event.command;
public interface Command<T> {
 T getCommandArgument();
}
 
package cellsociety.event.command;
public class UpdateCellsCommand implements Command<Iterator<Entry<CellPosition, CellState>>> {
 public UpdateCellsCommand(Iterator<Entry<CellPosition, CellState>> iterator) 
 public Iterator<Entry<CellPosition, CellState>> getCommandArgument() 
}
 
package cellsociety.event.command;
public class DelayCommand implements Command<Double> {
 public DelayCommand(Double delay) 
 public Double getCommandArgument() 
}
 
package cellsociety.event.command;
public class InitializeViewCommand implements Command<GameInformation> {
 public InitializeViewCommand(GameInformation gameInformation) 
 public GameInformation getCommandArgument() 
}
 
package cellsociety.event.command;
public class UpdateCellStateCommand implements Command<CellPosition> {
 public UpdateCellStateCommand(CellPosition cellPosition) 
 public CellPosition getCommandArgument() 
}