Adding Files to repository

Author: samshuster

.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path=""/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path=""/>
+</classpath>

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>TEMP</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

practice/AutomataDisplay$1.class

@@ -0,0 +1,173 @@
+package practice;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JLayeredPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+import javax.swing.WindowConstants;
+
+
+public class AutomataDisplay extends JFrame{
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -4650371836502914232L;
+	//final Constant Values
+	final int GAMEWIDTH = 700;
+	final int GAMEHEIGHT = 750;
+	final int BOARDWIDTH = 700;
+	final int BOARDHEIGHT = 600;
+	private JPanel BoardDisplay;
+	private JPanel Board;
+	private JScrollPane BoardScroll;
+	//The Engine
+	private AutomataEngine engine;
+	//A mimic board
+	private Square[][] fBoard;
+	//The rule container
+	private Rules rules;
+	//The number of tiles to be used
+	private int numTiles;
+	//Field that displays curGen
+	private JTextField curGen;
+	//Square length of display
+	private int squareLength;
+	
+	/**
+	 * Constructor
+	 * @param numTiles
+	 * @param name
+	 * @param rule
+	 */
+	public AutomataDisplay(int numTiles, String name, Rules rule)
+	{
+		super(name);
+		setSize(new Dimension(GAMEWIDTH, GAMEHEIGHT));
+		setFocusable(true);
+		setVisible(true);
+		setResizable(false);
+		setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+		//Sets class variables
+		this.numTiles = numTiles;
+		this.rules = rule;
+		squareLength = this.BOARDHEIGHT;
+		BuildBoard();
+	}
+	/**
+	 * Will build a new Automata board
+	 */
+	private void BuildBoard()
+	{
+		//Builds the Cellular Automata Board
+		Board = new JPanel();
+		BoardScroll = new JScrollPane(Board);
+		this.add(BoardScroll, BorderLayout.NORTH, JLayeredPane.DEFAULT_LAYER);
+		Board.setLayout(new FullyJustifiedGridLayout(numTiles,numTiles));
+		Board.setPreferredSize(new Dimension(squareLength, squareLength));
+		BoardScroll.setPreferredSize(new Dimension(BOARDWIDTH, BOARDHEIGHT));
+		fBoard = new Square[numTiles][numTiles];
+		for (int i = 0; i < numTiles; i++) {
+			for(int j = 0; j<numTiles; j++){
+	            Square square = new Square(rules.getColorSet());
+	            fBoard[i][j] = square;
+	            square.addMouseListener(square);
+	            Board.add(square);
+			}
+        }
+		//Configures the Board Display which holds the buttons
+		configureButtons();
+		//Create the engine
+		this.engine = new AutomataEngine(rules, fBoard, curGen);
+	}
+	/**
+	 * Helper method that will configure the buttons
+	 */
+	private void configureButtons(){
+		BoardDisplay = new JPanel(new GridBagLayout());
+		BoardDisplay.setBorder(BorderFactory.createLineBorder(Color.BLACK));
+		BoardDisplay.setBackground(Color.white);
+		this.add(BoardDisplay, null, JLayeredPane.DEFAULT_LAYER);
+		final JButton startStop = new JButton("Start Simulation");
+		startStop.setActionCommand("Start");
+		ActionListener startSim = new ActionListener(){
+			public void actionPerformed(ActionEvent e) {
+				if(e.getActionCommand().equals("Start")){
+					engine.start();
+					startStop.setText("Stop Simulation");
+					startStop.setActionCommand("Stop");
+				} else {
+					engine.stop();
+					startStop.setText("Start Simulation");
+					startStop.setActionCommand("Start");
+				}
+			}
+		};
+		startStop.addActionListener(startSim);
+		JButton finish = new JButton("Finish");
+		finish.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent e){
+				engine.finish();
+				finish();
+			}
+		});
+		curGen = new JTextField("0",5);
+		curGen.setEditable(false);
+		//Labels
+		JLabel generation = new JLabel("Current Generation:");
+		JLabel speedText = new JLabel("Current Speed:");
+		final JTextField speedField = new JTextField(AutomataEngine.DEFAULT_DELAY+"",6);
+		JButton changeSpeed = new JButton("Change Speed");
+		changeSpeed.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent e){
+				engine.changeSpeed(Integer.parseInt(speedField.getText()));
+			}
+		});
+		JButton resetScreen = new JButton("Reset Screen");
+		resetScreen.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent e){
+				engine.resetScreen();
+			}
+		});
+		JLabel displayText = new JLabel("Set size of Display");
+		final JTextField displayField = new JTextField(""+this.squareLength,6);
+		JButton changeDisplay = new JButton("Change Display");
+		changeDisplay.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent e){
+				squareLength = Integer.parseInt(displayField.getText());
+				Board.setPreferredSize(new Dimension(squareLength, squareLength));
+				BoardScroll.revalidate();
+				BoardScroll.repaint();
+			}
+		});
+		//Add stuff to BoardDisplay at bottom of screen
+		GridBagConstraints c = new GridBagConstraints();
+		c.gridy = 0;
+		c.gridx = GridBagConstraints.RELATIVE;
+		BoardDisplay.add(startStop,c);
+		BoardDisplay.add(speedText,c);
+		BoardDisplay.add(speedField,c);
+		BoardDisplay.add(changeSpeed,c);
+		BoardDisplay.add(generation,c);
+		BoardDisplay.add(curGen,c);
+		BoardDisplay.add(finish,c);
+		c.gridy = 1;
+		BoardDisplay.add(displayText,c);
+		BoardDisplay.add(displayField,c);
+		BoardDisplay.add(changeDisplay,c);
+		BoardDisplay.add(resetScreen,c);
+	}
+	
+	private void finish(){
+		this.dispose();
+	}
+}

practice/AutomataDisplay$2.class

@@ -0,0 +1,137 @@
+package practice;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.HashMap;
+
+import javax.swing.JTextField;
+import javax.swing.Timer;
+
+public class AutomataEngine {
+	//Default time delay
+	public final static int DEFAULT_DELAY = 500;
+	//Rules object containing all necessary rule information
+	private Rules rules;
+	//Fake board to hold squares
+	private Square[][] fBoard;
+	//Timer object
+	private Timer time;
+	private JTextField curGen;
+	private int[][] template;
+	private HashMap<Integer,int[]> answerSet;
+	
+	/**
+	 * Constructor
+	 * @param rule - the rule set to be used
+	 * @param fBoard - the mimic board to be used for data
+	 * @param curGen - the curGen container
+	 */
+	public AutomataEngine(Rules rule, Square[][] fBoard, JTextField curGen){
+		rules = rule;
+		this.fBoard = fBoard;
+		this.curGen = curGen;
+		this.time = new Timer(DEFAULT_DELAY, new ActionListener() {
+		    public void actionPerformed(ActionEvent evt) {
+		        tick();
+		    }
+		});
+		template = rules.getTemplate();
+		answerSet = rules.getAnswerSet();
+	}
+	/**
+	 * Start the Simulation
+	 */
+	public void start(){
+		if(time.isRunning()) return;
+		for(Square[] sl:fBoard){
+			for(Square s:sl){
+				s.removeMouseListener(s);
+			}
+		}
+		time.start();
+	}
+	
+	/**
+	 * Stops the simulation
+	 */
+	public void stop(){
+		if(!time.isRunning()) return;
+		time.stop();
+		for(Square[] sl:fBoard){
+			for(Square s:sl){
+				s.addMouseListener(s);
+			}
+		}
+	}
+	
+	/**
+	 * One tick of the simulation
+	 */
+	private void tick(){
+		int[][] tempBoard = new int[fBoard.length][fBoard.length];
+		int colorLength = rules.getColorSet().length;
+		//Iterate through every square where the square will serve as top
+		//left position for template
+		for(int i = 0; i<fBoard.length; i++){
+			for(int j = 0; j<fBoard[i].length; j++){
+				//chunkState will determine which rule will be used
+				//curMultiplier helps performance
+				int chunkState = 0;
+				int curMultiplier = 1;
+				//This is iterating through template at position i,j
+				for(int k = i; k<i+template.length; k++){
+					for(int p = j; p<j+template[0].length; p++){
+						//If the template actually contains something lets see if real thing does
+						if(template[k-i][p-j] != 0){
+							chunkState += fBoard[k%fBoard.length][p%fBoard.length].getType()*curMultiplier;
+							curMultiplier = curMultiplier*colorLength;
+						}
+					}
+				}
+				int[] newDig = rules.calculateRule(chunkState);
+				for(int k = 0; k<newDig.length; k++){
+					//need to generalize to cover multiple centers
+					tempBoard[(i+rules.getYAnswerSet().get(k))%tempBoard.length]
+						     [(j+rules.getXAnswerSet().get(k))%tempBoard.length] = newDig[k];
+				}
+			}
+		}
+		//Transfer changes to the actual board
+		for(int i = 0; i<tempBoard.length; i++){
+			for(int j = 0; j<tempBoard.length; j++){
+				fBoard[i][j].setType(tempBoard[i][j]);
+			}
+		}
+		Integer cGen = Integer.parseInt(curGen.getText());
+		cGen++;
+		curGen.setText(cGen.toString());
+	}
+	
+	/**
+	 * Finishes the current simulation while giving option to save initial settings
+	 */
+	public void finish(){
+		// TODO need to add saving function
+	}
+	/**
+	 * @return the isRunning
+	 */
+	public boolean isRunning() {
+		return time.isRunning();
+	}
+	
+	public void changeSpeed(int speed){
+		time.setDelay(speed);
+	}
+	
+	public void resetScreen(){
+		this.stop();
+		this.curGen.setText("0");
+		for(int i = 0; i<fBoard.length; i++){
+			for(int j = 0; j<fBoard[i].length; j++){
+				fBoard[i][j].setType(0);
+			}
+		}
+		
+	}
+}