Question
Please help me implementing Conway's Game of Life for this assignment. The Wikipedia article on the Game of Life can be found https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life and a demo of the game can be found https://bitstorm.org/gameoflife/. Use the netbeans and make sure it follows the instructions and skeleton below, make sure it is working correctly. The code should write by JAVA and working on netbeans. Please do not use any other language. Follow the instructions and fill in the skeleton below carefully. Here is the instructions: The game of life takes place on a two dimensional board (a 2D array in Java terms). Each square on the board (element in the array) is cell, either dead or alive. The game progresses in steps. Each step, each cell determines whether it will die or spring to life. It does counting the number of live neighbors it has. Neighbors are the up to 8 adjacent cells, including diagonals. The board does not wrap around, so cells in the corners and sides have fewer than 8 neighbors.1 After counting their living neighbors, if a live cell has < 2 living neighbors, it dies of loneliness. If a live cell has > 3 living neighbors, it dies of overpopulation. If the live cell has 2 or 3 neighbors, it lives on, content. If a dead cell has exactly 3 neighbors, it springs back to life. Each of these status changes happen each step, so if a live cell has 5 neighbors on step n, then its status changes to dead for step n + 1. Using these simple rules, we can create complex and beautiful patterns. Implementing the Game of Life There is a skeleton provided to make things easier. To make our job easier, we are doing a completely text based version of the game of life. We will represent our board as a 2D array. We also have a second 2D array of the same size as a uer," essentially a workspace to create the next step of the game, as we'll explain in a bit. Use the character `X' to represent a live cell and any other character of your choice to represent a dead one (I use the carat character). Let's look at the constructor and each of the functions in turn. 1 The Constructor In the constructor, build a new board of your desired size, and initialize your initial board state. Also initialize the nextBoard variable to be an empty board of the same size. 2 getNeighborCount This method takes in the row and column location of a cell and returns the number of living neighbors. This will most likely be your most challenging method and I recommend writing and testing this method rst. Let me be perfectly clear. Write and test this method before trying to write the whole program at once. If you try to write the whole program in one go, your program will crash and you won't be able to gure out why. The challenge of this function is that each of the 8 neighboring cells you need to check could be out of bounds. 3 generateNextStep This method generates the next step of the board. For each cell in the board, get the number of neighbors and the status of the cell you are currently at. Use this information to gure out whether the cell will be alive or dead in the next iteration of the board. Set the cell at the same row, column location in nextBoard to this status. To reiterate, you want to change the cells in nextBoard, not your current board, because if you changed the cells in board, you would lose your current board state. Once that is done, make set board equal to nextBoard to advance to the next step and create a new 2D for nextBoard. 4 printBoard This one is obvious. Print out the board. 2 5 main Use main to create a GameOfLifeBoard, and then create a while loop. In the while loop do the following Print out the board by calling printBoard() wait for user input if the user puts in quit, stop the game. Otherwise, call generateNextStep() and keep the loop going. 6 Testing To demo your code, create a glider and watch it go across the board. Here is the skeleton. Make sure the codes follows the skelon properly.
import java.util.Scanner;
public class GameOfLifeBoard {
private char[][] board;
private char[][] nextBoard;
public static final char LIVE = 'X';
public static final char DEAD = '^';
public GameOfLifeBoard(){
}
public void generateNextStep(){
}
public int getNeighborCount(int row, int col){
int numNeighbors = 0;
return numNeighbors;
}
public void printBoard(){
}
public static void main(String[] args){
}
}
Explanation / Answer
package org.bitstorm.gameoflife; import java.awt.AWTEvent; import java.awt.Color; import java.awt.Dimension; import java.awt.Event; import java.awt.Frame; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import java.awt.Image; import java.awt.Menu; import java.awt.MenuBar; import java.awt.MenuItem; import java.awt.Point; import java.awt.Toolkit; import java.awt.datatransfer.DataFlavor; import java.awt.datatransfer.Transferable; import java.awt.dnd.DnDConstants; import java.awt.dnd.DropTarget; import java.awt.dnd.DropTargetDragEvent; import java.awt.dnd.DropTargetDropEvent; import java.awt.dnd.DropTargetEvent; import java.awt.dnd.DropTargetListener; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.net.URL; import java.util.Enumeration; import java.util.Properties; import java.util.Vector; import org.bitstorm.util.AboutDialog; import org.bitstorm.util.AlertBox; import org.bitstorm.util.EasyFile; import org.bitstorm.util.LineEnumerator; import org.bitstorm.util.TextFileDialog; /** * Turns GameOfLife applet into application. * It adds a menu, a window, drag-n-drop etc. * It can be run stand alone. * * @author Edwin Martin */ public class StandaloneGameOfLife extends GameOfLife { private Frame appletFrame; private String[] args; private GameOfLifeGridIO gridIO; /** * main() for standalone version. * @param args Not used. */ public static void main(String args[]) { StandaloneGameOfLife gameOfLife = new StandaloneGameOfLife(); gameOfLife.args = args; new AppletFrame( "Game of Life", gameOfLife ); } /** * Initialize UI. * @param parent Parent frame. * @see java.applet.Applet#init() */ public void init( Frame parent ) { appletFrame = parent; getParams(); // set background colour setBackground(new Color(0x999999)); // TODO: casten naar interface // create StandAloneGameOfLifeGrid gameOfLifeGrid = new GameOfLifeGrid( cellCols, cellRows); gridIO = new GameOfLifeGridIO( gameOfLifeGrid ); // create GameOfLifeCanvas gameOfLifeCanvas = new CellGridCanvas(gameOfLifeGrid, cellSize); try { // Make GameOfLifeCanvas a drop target DropTarget dt = new DropTarget( gameOfLifeCanvas, DnDConstants.ACTION_COPY_OR_MOVE, new MyDropListener() ); } catch (NoClassDefFoundError e) { // Ignore. Older Java version don't support dnd } // create GameOfLifeControls controls = new GameOfLifeControls(); controls.addGameOfLifeControlsListener( this ); // put it all together GridBagLayout gridbag = new GridBagLayout(); GridBagConstraints canvasContraints = new GridBagConstraints(); setLayout(gridbag); canvasContraints.fill = GridBagConstraints.BOTH; canvasContraints.weightx = 1; canvasContraints.weighty = 1; canvasContraints.gridx = GridBagConstraints.REMAINDER; canvasContraints.gridy = 0; canvasContraints.anchor = GridBagConstraints.CENTER; gridbag.setConstraints(gameOfLifeCanvas, canvasContraints); add(gameOfLifeCanvas); GridBagConstraints controlsContraints = new GridBagConstraints(); canvasContraints.gridx = GridBagConstraints.REMAINDER; canvasContraints.gridy = 1; controlsContraints.gridx = GridBagConstraints.REMAINDER; gridbag.setConstraints(controls, controlsContraints); add(controls); setVisible(true); validate(); } /** * Set the shape. * * This is not done in init(), because the window resize in GameOfLifeGridIO.setShape(Shape) * needs a fully opened window to do new size calculations. */ public void readShape() { if ( args.length > 0 ) { gridIO.openShape(args[0]); reset(); } else { try { setShape( ShapeCollection.getShapeByName( "Glider" ) ); } catch (ShapeException e) { // Ignore. It's not going to happen here. } } } /** * Override method, called by applet. * @see java.applet.Applet#getParameter(java.lang.String) */ public String getParameter( String parm ) { return System.getProperty( parm ); } /** * Shows an alert * @param s text to show */ public void alert( String s ) { new AlertBox( appletFrame, "Alert", s ); } /** * Do not use showStatus() of the applet. * @see java.applet.Applet#showStatus(java.lang.String) */ public void showStatus( String s ) { // do nothing } /** * get GameOfLifeGridIO * @return GameOfLifeGridIO object */ protected GameOfLifeGridIO getGameOfLifeGridIO() { return gridIO; } /** * Handles drag and drops to the canvas. * * This class does handle the dropping of files and URL's to the canvas. * The code is based on the dnd-code from the book Professional Java Programming by Brett Spell. * * @author Edwin Martin * */ class MyDropListener implements DropTargetListener { private final DataFlavor urlFlavor = new DataFlavor("application/x-java-url; class=java.net.URL", "Game of Life URL"); /** * The canvas only supports Files and URL's * @see java.awt.dnd.DropTargetListener#dragEnter(java.awt.dnd.DropTargetDragEvent) */ public void dragEnter(DropTargetDragEvent event) { if ( event.isDataFlavorSupported( DataFlavor.javaFileListFlavor ) || event.isDataFlavorSupported( urlFlavor ) ) { return; } event.rejectDrag(); } /** * @see java.awt.dnd.DropTargetListener#dragExit(java.awt.dnd.DropTargetEvent) */ public void dragExit(DropTargetEvent event) { } /** * @see java.awt.dnd.DropTargetListener#dragOver(java.awt.dnd.DropTargetDragEvent) */ public void dragOver(DropTargetDragEvent event) { } /** * @see java.awt.dnd.DropTargetListener#dropActionChanged(java.awt.dnd.DropTargetDragEvent) */ public void dropActionChanged(DropTargetDragEvent event) { } /** * The file or URL has been dropped. * @see java.awt.dnd.DropTargetListener#drop(java.awt.dnd.DropTargetDropEvent) */ public void drop(DropTargetDropEvent event) { // important to first try urlFlavor if ( event.isDataFlavorSupported( urlFlavor ) ) { try { event.acceptDrop(DnDConstants.ACTION_COPY); Transferable trans = event.getTransferable(); URL url = (URL)( trans.getTransferData( urlFlavor ) ); String urlStr = url.toString(); gridIO.openShape( url ); reset(); event.dropComplete(true); } catch (Exception e) { event.dropComplete(false); } } else if ( event.isDataFlavorSupported( DataFlavor.javaFileListFlavor ) ) { try { event.acceptDrop(DnDConstants.ACTION_COPY); Transferable trans = event.getTransferable(); java.util.List list = (java.util.List)( trans.getTransferData( DataFlavor.javaFileListFlavor ) ); File droppedFile = (File) list.get(0); // More than one file -> get only first file gridIO.openShape( droppedFile.getPath() ); reset(); event.dropComplete(true); } catch (Exception e) { event.dropComplete(false); } } } } /** * File open and save operations for GameOfLifeGrid. */ class GameOfLifeGridIO { public final String FILE_EXTENSION = ".cells"; private GameOfLifeGrid grid; private String filename; /** * Contructor. * @param grid grid to read/write files from/to */ public GameOfLifeGridIO( GameOfLifeGrid grid ) { this.grid = grid; } /** * Load shape from disk */ public void openShape() { openShape( (String)null ); } /** * Load shape from disk * @param filename filename to load shape from, or null when no filename given. */ public void openShape( String filename ) { int col = 0; int row = 0; boolean cell; // Cope with different line endings (" ", " ", " ") boolean nextLine = false; EasyFile file; try { if ( filename != null ) { file = new EasyFile( filename ); } else { file = new EasyFile( appletFrame, "Open Game of Life file" ); } openShape( file ); } catch (FileNotFoundException e) { new AlertBox( appletFrame, "File not found", "Couldn't open this file. "+e.getMessage()); } catch (IOException e) { new AlertBox( appletFrame, "File read error", "Couldn't read this file. "+e.getMessage()); } } /** * Open shape from URL. * @param url URL pointing to GameOfLife-file */ public void openShape( URL url ) { int col = 0; int row = 0; boolean cell; // Cope with different line endings (" ", " ", " ") boolean nextLine = false; EasyFile file; String text; try { if ( url != null ) { file = new EasyFile( url ); openShape( file ); } } catch (FileNotFoundException e) { new AlertBox( appletFrame, "URL not found", "Couldn't open this URL. "+e.getMessage()); } catch (IOException e) { new AlertBox( appletFrame, "URL read error", "Couldn't read this URL. "+e.getMessage()); } } /** * Use EasyFile object to read GameOfLife-file from. * @param file EasyFile-object * @throws IOException * @see org.bitstorm.util.EasyFile */ public void openShape( EasyFile file ) throws IOException { Shape shape = makeShape( file.getFileName(), file.readText() ); setShape( shape ); } /** * Set a shape and optionally resizes window. * @param shape Shape to set */ public void setShape( Shape shape ) { int width, height; Dimension shapeDim = shape.getDimension(); Dimension gridDim = grid.getDimension(); if ( shapeDim.width > gridDim.width || shapeDim.height > gridDim.height ) { // Window has to be made larger Toolkit toolkit = getToolkit(); Dimension screenDim = toolkit.getScreenSize(); Dimension frameDim = appletFrame.getSize(); int cellSize = getCellSize(); // Calculate new window size width = frameDim.width + cellSize*(shapeDim.width - gridDim.width); height = frameDim.height + cellSize*(shapeDim.height - gridDim.height); // Does it fit on the screen? if ( width > screenDim.width || height > screenDim.height ) { // With current cellSize, it doesn't fit on the screen // GameOfLifeControls.SIZE_SMALL corresponds with GameOfLifeControls.SMALL int newCellSize = GameOfLifeControls.SIZE_SMALL; width = frameDim.width + newCellSize*shapeDim.width - cellSize*gridDim.width; height = frameDim.height + newCellSize*shapeDim.height - cellSize*gridDim.height; // a little kludge to prevent de window from resizing twice // setNewCellSize only has effect at the next resize gameOfLifeCanvas.setAfterWindowResize( shape, newCellSize ); // The UI has to be adjusted, too controls.setZoom( GameOfLifeControls.SMALL ); } else { // Now resize the window (and optionally set the new cellSize) gameOfLifeCanvas.setAfterWindowResize( shape, cellSize ); } if ( width < 400 ) width = 400; appletFrame.setSize( width, height ); return; } try { gameOfLifeCanvas.setShape( shape ); } catch (ShapeException e) { // ignore } } /** * "Draw" the shape on the grid. (Okay, it's not really drawing). * The lines of text represent the cells of the shape. * * @param name name of shape * @param text lines of text */ public Shape makeShape( String name, String text ) { int col = 0; int row = 0; boolean cell; // Cope with different line endings (" ", " ", " ") int[][] cellArray; Vector cells = new Vector(); if ( text.length() == 0 ) return null; grid.clear(); Enumeration enum = new LineEnumerator( text ); while ( enum.hasMoreElements() ) { String line = (String) enum.nextElement(); if ( line.startsWith("#") || line.startsWith("!") ) continue; char[] ca = line.toCharArray(); for ( col=0; col