Please help me implementing Conway\'s Game of Life for this assignment. The Wiki
ID: 3818115 • Letter: P
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
bundle com.zetcode;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Ellipse2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
class Surface broadens JPanel {
private void doDrawing(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
g2d.setPaint(new Color(150, 150, 150));
RenderingHints rh = new RenderingHints(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
rh.put(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g2d.setRenderingHints(rh);
g2d.fillRect(30, 20, 50, 50);
g2d.fillRect(120, 20, 90, 60);
g2d.fillRoundRect(250, 20, 70, 60, 25, 25);
g2d.fill(new Ellipse2D.Double(10, 100, 80, 100));
g2d.fillArc(120, 130, 110, 100, 5, 150);
g2d.fillOval(270, 130, 50, 50);
}
@Override
open void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
}
open class BasicShapesEx broadens JFrame {
open BasicShapesEx() {
initUI();
}
private void initUI() {
add(new Surface());
setTitle("Basic shapes");
setSize(350, 250);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
open static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
open void run() {
BasicShapesEx ex = new BasicShapesEx();
ex.setVisible(true);
}
});
}
}