Mini Project 8: PokePixel Simulator

This assignment is due on Monday, June 3rd 11:30PM

This last Mini Project covers everything up through Week 9, and is the third (and final!) OOP assignment, implemented in Java. You will find some similarities to your work in MP7, though you will also practice working with Random and arrays in Java. Other than that, you will be reviewing a cumulation of fundamental concepts we've learned throughout the term, including loops, string processing, and OOP (which we choose to implement in Java). You will not need to write any documentation for this assignment, unless you implement optional Part C features.

This assignment is an apt CS1-variant of the classic "Game of Life". The Game of Life is a simulation where cells follow some heuristics to overcome their neighbors. In this version, cells will represent "PokePixels", of which we will start with 5 types corresponding to a specific Pokemon type (e.g. "Fire"), each represented by a color.

The Game of Life is represented as a 2D grid of pixels (also referred to as cells); we've seen 2D lists in Python (and perhaps numpy!) and you will get just a basic introduction to the analog in Java, which is covered on Monday's lecture and which will be walked through whenever you use them in this assignment. Lab 08 will also be another motivating application of 2D arrays in Java!

How does the Game of Life work? The game first initializes a random board of pixels, each representing a cell type (different variants will define cell types differently; if you really wanted to, you could create a Game of Life variant using Caltech houses for cells). Then, a game loop is started (this is managed in our Game.java, which you won't modify in Parts A/B). For each lifetime "cycle", a the 2D grid is looped through, row by row, cell by cell, and applying an "update rule" for each cell to determine whether its type changes.

Some Game of Life simulations define their heuristics by looking at each pixels neighbors and changing the neighbors depending on the placement of types, but ours will focus on looking at the neighbors to determine whether the pixel of interest is changed.

Example screenshots of the first 3 cycles of the game of life variant, followed by the 35th, are given below:

Winning type: Fire

Example results printed to console after the game finishes 35 lifetime cycles:

Example results printed to console after the game finishes 4 lifetime cycles:

You will be submitting 2 files for this assignment, each of which we have provided starting templates for you in mp8_starter.zip:

• PokePixel.java (Part A)
• PokeLife.java (Part B)
• (Optional extensions from Part C)

You will also see the following files included in the starter code, which you do not need to modify:

• DrawingPanel.java - helper class for graphics
• Game.java - main game program

We encourage you to test your code iteratively, using a client program (with main to test calls to your Part A and B code, using the examples given.

We have provided two testing files for Part A and B in mp8_tests.zip which also include a studentTestArea function if you'd like to use the debugger for your own testing calls. See the file documentation for each test for instructions to run as well as comments for test cases if you are failing something (if you are failing a test, make sure to re-read the spec instructions carefully!).

No Collaboration Policy

This assignment is strictly no collaboration, similar to MP1-MP6. Students who violate the collaboration policy will be subject to 0 and escalated to the BoC. We are making a clear reminder here given recent violations that our grading software has flagged, and want to remind you that the Honor Code is taken very seriously at Caltech. It's not worth the risk, and we would much rather you utilize course resources than disadvantage yourself and your peers.

[10]

Random rand = new Random();
int n = rand.nextInt(2); // 1
n = rand.nextInt(2);     // 1
n = rand.nextInt(2);     // 0
n = rand.nextInt(2);     // 1
n = rand.nextInt(2);     // 1

PokePixel ex = new PokePixel();
// At this point, ex.type should be a valid pokemon type randomly selected from TYPES

[3]

This getter method that should simply return the PokePixel's type (a 1-line solution).

[3]

PokePixel originallyFire = new PokePixel();
// Randomly initialized to "Fire" type
System.out.println(originallyFire.getType()); // Fire
originallyFire.changeType("Grass");
System.out.println(originallyFire.getType()); // Grass

[5]

The string representation of a PokePixel should be the first three letters of its type (this is useful if you want to print out PokePixels!). Use the substring(startIndex, endIndex) String method (remember these are inclusive, exclusive respectively) to implement this as a 1-line solution, returning the first three characters.

[10]

The goal of the PokePixel constructor is to initialize the "board" that the pokemon will be on. Since this requires the advanced two-dimensional array, we have provided you with an initializeBoard helper method, which returns a board for you (note that the provided method is declared private, since it is only intended to be used as a helper method within PokeLife method, not by clients). Internally, this helper method will also check whether or not the isRandom state was set in this constructor; if it was set to false, then the types will be assigned based on a simple heuristic function (which you don't need to worry about).

If either width or height are <= 0, the constructor should throw an IllegalArgumentException with the message, width and height must be > 0.

Otherwise, the PokeLife constructor should first set the width, height. Then, set the isRandom field to the passed isRandom argument so that we can test the game with a random vs. non-random allocation. Finally, assign this.board to the result of calling the initializeBoard helper method, which returns a populated PokePixel[][] based on the fields set (don't over-complicate this; you are only setting four fields on exactly four lines, one assigned to the result of the helper method). For reference, our solution is 7 lines (4 of which are the field-setters).

[5]

These two getter methods should return the width and height of the current PokeLife board, respectively.

[5]

In this exercise, you will implement the getPoke method, which takes a x coordinate and y coordinate and returns the PokePixel at the corresponding grid cell (where the top-left corner of the grid is (0, 0), and x/y increase right/down, respectively).

First check if the given x and y bounds are valid to avoid an undesirable ArrayIndexOutOfBoundsException (a client shouldn't see this internal exception, since its referring to private state and not their arguments). A valid x must be between 0 (inclusive) and the board's width (exclusive). A valid y must be between 0 (inclusive) and the board's height (exclusive). If either is invalid, throw an IllegalArgumentException with the message Invalid x and/or y coordinate.. Otherwise, return the PokePixel at the given position, where (0, 0) is the first element in the first row (using 0-based indexing).

Note that a 2D array in Java works like a 2D list in Python. When we have a 2D array (or list), it's just an array of arrays. So suppose we have a small 2x3 grid. The next two examples show how to construct, access, and modify a 2D list/array in both Python and Java; you will not actually write any code to construct a 2D array in MP8, and while the examples below illustrate 2D arrays, the solution to getPoke is a short solution, first to handle the bounds and then to otherwise return the result of 2D array indexing of this.board.

[10]

This method will get you more practice with basic array processing in Java. The two class constants, TYPES and WEAKNESSES hold the types and their weaknesses (a type with multiple weaknesses has a weakness String separated with ,). In Python, the appropriate way to map types to their weaknesses would be a dictionary. However, this is less straightforward in Java (if you're curious, the data structure for this in Java is called a Map).

For the scope of a small Java project with simple analogs in Python, we have just chosen to represent the 1-1 mapping of types and weaknesses with these two arrays, and each type/weakness(es) pairing is determined by a shared index in both arrays. So the type String TYPES[0] is defined as having a weakness(es) of WEAKNESSES[0], and so on.

Finish this method, which takes a String type as a single argument, to loop through the TYPES array until the matching String is found (use the String's equals method to find the match; don't forget that == doesn't correctly check for String equality in Java!) Once your loop finds the index of the matching type, use that index to get the corresponding weakness string. You can refer to lecture materials on String equality and the provided getTypeIndex method for an example of the .equals method for Strings.

Since we support types which might have more than one weakness, we want to return an array of all of the weaknesses (in our version, there happen to be 1 or 2 weaknesses depending on the type). We have chosen to use "," to separate weaknesses in the same String (e.g. "Electric,Grass" for a single String that represents these two weaknesses for one type). Just like in Python, we can split a String in Java; the String's split method should be used here, which returns an array of Strings (String[]) split by a passed delimiter (in this case, ","). Return that split string array result for the matching index. If the given type isn't found, the method should return null.

For reference, our solution is about 6 lines ignoring inline comments.

[10]

Next, you'll implement the method which determines whether a PokePixel is "overrun" by some minimum number of neighbors sharing one of its weaknesses.

We have provided you with a getNeighborTypes(int x, int y) method, which returns a String[] of the types of the 8 neighbors of the PokePixel at (x, y).

The isSurroundedBy method takes an x and y position, a String type, and a target int count, and should return whether there are at least count neighbors of the given type, to the PokePixel at (x, y).

Finish this method to use the neighborTypes array we've started you with to loop through the array and count how many Strings equal the passed type String.

The method should return true if at least count neighbors have the passed type, else false. For reference, our solution is about 6-7 lines. You do not need to handle the arguments being valid, though you may choose to if you'd like to improve the error-handling for this method (in this case, an IllegalArgumentException would make the most sense if x or y are out of bounds or count is < 1).

In updateType, you will pass 3 as the count argument to this method, but we have parameterized this method to support other counts to allow for possible extensions of the pixel-changing logic (you should not hard-code 3 anywhere in this isSurroundedBy method).

[8]

This method is responsible for checking and updating a given PokePixel. It should look through the PokePixel's weaknesses (use your getWeaknesses method, which will return a String[] holding a String for each weakness), and then check to see if at least 3 neighbors of that type "beat" the PokePixel. If If they do, then the PokePixel's type should be updated to that weakness String, using its changeType method you implemented in Part A.

Note that if a pixel has more than 1 weakness, such as "Water" being weak to both "Grass" and "Electric", then you'll want to consider each weakness separately (use a loop over the weaknesses array returned by your getWeaknesses). The last weakness, if any, that matches 3 or more neighbors should be the updated type (for a type with two weaknesses, if 3 neighbors are of one weakness and 3 are of the other, the second weakness in the tie should be chosen to change the type). Also note that this method is declared public, though in practice, it would best be a private helper method. This is only to make it easier for testing the method in any testing programs.

[10]

At this point, you have everything implemented for the Game.java program to use your PokeLife class (which uses your PokePixel class) to run a game of life simulation! In Game.java, you'll notice a variable called lifetime, which defines the number of times the game loop iterates (each iteration updates the board using the provided PokeLife lifeCycle method).

Currently, when the simulation ends (the game loop has iterated lifetime times), the window will show the final result of the simulation. Of course, we'd like to know which type was considered the winner!

Finish PokeLife's getWinningType method to tally up the counts for each of the types in TYPES. We have started the method for you, which includes a nested loop over the 2D board. We have also provided a getTypeIndex which takes an String type and returns the int index of that type in the TYPES array. There are 2 TODOs in the method, which you should replace as described. For reference, our solution adds no more than 8 lines total when replacing the two TODOs. You should only have 3 loops total, two of which are the nested loop we start you with.

An example of using this method is provided below, where life is the current state of the PokePixel board.