Project 01

Due: Multiple Due Dates

Design Due: Wednesday 12/4 10:00am

Feedback Due: Thursday, 12/5 10:00am

V0 Due: Monday, 12/9 10:00am

Final version Due: Friday, 12/13 10:00am

This is a project, as such, it will be graded for correctness. You may work either alone OR in groups of 2 (you can partner with anyone in the class). There will be multiple stages to the project. Use the following link to create a new GitHub classroom repository for your project:

Period 4 Link: https://classroom.github.com/a/tKEUpLiS
Period 5 Link: https://classroom.github.com/a/RFD7jbdm

When making your team, you cannot use a team name you’ve used in the past (even if you are a one person team)

Phase 1 - Feedback

Due: Thursday, 12/5 10:00am

Below, you will find links to all the project repositories. For this phase, I have made them publicly viewable.

Find your project on the list. You will be providing feedback for the three projects below you, wrapping back around to the top (i.e. the last group should look at the first three).
If you find an empty README, just move to the next one, but make sure to still look at 3.
For each project you are reviewing:
- Read the README.md document that has been created.
- Make note of anything that stands out to you. You will be specifically required to provide 2 of each of the following:
  - Things from the design that you really like. Explain why.
  - Clarifying questions, either something that does not quite make sense to you, or something that you think needs further explanation.
  - Suggestions, either things to add or ways to implement things already there.
- You will provide this feedback using the “Issues” section of the project GitHub repository.
  - Title the issue Feedback from followed by your name(s).
  - Use the following markdown template to fill in your responses:
```
Cool things:
-
-

Clarifying Qs:
-
-

Suggestions:
-
-
```
Once you have provided the feedback, look over the issues on your own repository. Create a new document in your project repository called changes.md. The purpose of this file is to track any changes between your design document and your finished project. If you decide to change some parts of your design based on the feedback you received (or from looking at the designs of others), add them to changes.md. It should be a markdown file, but you can organize it however you’d like.
Please leave your issues open until I tell you otherwise so that I can look at them easily.

Period 4 Links:

Period 5 Links:

Overview

The purpose of this project is to demonstrate your ability to use the concepts we’ve covered so far to create a large program. All projects will need to have the following:

Custom classes.
Well organized multi-file design (classes and a driver).
1D arrays.
2D arrays.
Event driven components.

Choices, Choices!

For this project, you have two options, with more details below:

A Cellular automata (like Conway’s Game of Life) simulation.
A Breakout/Arkanoid style game.
Space Invaders/Galaga style game

Life-Like Cellular Automata

You may recall Conway’s Game of Life from NetLogo. To refresh your memory, either open up NetLogo and find Life in the Models library, or use the simulation available on NetLogo Web (note the web version may run slowly). Life is one particular Cellular Automaton, but in general all Life-Like CA have the following:

A world made of distinct “cells”.
“Time” that passes is discrete steps.
Discrete states for each cell, such that a cell can be in one state at any given time (in Life, there are only 2 states, alive and dead).
A set of rules for how cells can change state that are based on the sate of the cell and the state(s) of it “neighbors” (some set of cells nearby, in Life, the neighbors are the 8 cells that surround a cell).

If you choose Cellular Automata, your program must have the following elements:

Successful simulation of Conway’s Game of Life, as well as two other Life-like cellular automata.
Initial setups for each (either random or specific).
The ability to start with a blank world and turn cells on/off with the mouse.
Keyboard controls to switch between simulations, start/stop, and preset/drawing modes.

Breakout/Arkanoid

A classic game, you can check out demo 0 and demo 1 if you need clarification. A breakout style game should have:

A user controlled paddle.
A grid of bricks.
A ball that bounces off the paddle, bricks, and side walls.
Bricks that disappear or are damaged when hit by the ball.
Loss of “life” if the ball gets past the paddle.

In addition to basic gameplay, if you choose breakout your program must have the following:

A set number (more than one) of “lives”.
The ability to play/pause the game.
The ability to reset the game.
Some continuation of the game if all the bricks have been destroyed.

Space Invaders/Galaga

A classic game that we have made pieces of in class. This style game should have:

A grid of “enemies” that move across and down, and also shoot the player.
A user controlled “spaceship” for shooting projectiles.
Projectiles that collide and destroy enemies.

In addition to basic gameplay, if you choose space invaders your program must have the following:

A set number (more than one) of “lives”.
The ability to play/pause the game.
The ability to reset the game.
Some continuation of the game if all the enemies have been destroyed.
Different kinds of enemies (possible differences are movement, health, speed, etc)

Skills

Skill	Minimal Competency	Developing Competency	Competency	Mastery
1. Basic Drawing Functions (line, circle, square, rect, ellipse)	Can use one basic 2D drawing function.	Can use two basic drawing functions.	Can use all the basic drawing functions.	Can use multiple basic drawing functions to draw a complex shape.
2. Controlling Color State	Can set the fill or stroke color of a 2D shape.	Can set the fill and stroke color of a 2D shape.	Can set the fill and stroke color and the stroke weight of a 2D shape.	Can control the fill and stroke colors and the stroke weights of multiple 2D shapes.
3. Using Colors	Can set colors using separate Red, Green, and Blue values.	Can set colors using RGB values or hexcode values.	Can create and work with `color` variable types.	Can explain how the `color` data type represents color values.
4. Primitive Variables and Types	Can declare, initialize, and use `int` variables.	Can declare, initialize, and use `int` and `float` variables.	Can explain the differences and use the different integer and floating point variable types.	Can explain the differences between, use, and explain how the different primitive variables types represent data.
5. Working with Boolean Values	Understands the purpose of boolean values.	Demonstrates the appropriate use of comparison operators.	Demonstrates the appropriate use of comparison and boolean operators.	Writes functions that take in boolean values and/or return boolean values.
6. Working with `setup` and `draw`	Can write a valid `setup` function that sets initial conditions for a processing program.	Can write a valid `setup` function, and can write a valid `draw` function that generates different program output each frame.	Can create global variables that are initialized in `setup` and modified in `draw`.	Can use global variables, custom functions, and `setup` and `draw` to produce a full processing program.
7. Controlling Program Speed	Can set the frame rate for a processing program.	Can set the frame rate based on a specified speed.	Can control program output based on the current frame number.	Can start and stop the action of a processing program.
8. Custom Functions	Can identify the return type, name, parameter list, and body of a function.	Can write a function given a header and description.	Can write a function, including selecting appropriate return and parameter types.	Can write multiple functions and use variable scope accurately.
9. Writing Readable Code	Uses descriptive identifiers.	Uses indentation and newlines to create more readable code, and descriptive identifiers.	Uses inline and block comments when appropriate. Uses indentation and newlines, and descriptive identifiers.	Can take a large programming task and break it up into smaller functions.
10. Debugging Practices	Can use `println` statements to help debug code.	Consistently uses `println` statements while debugging.	Consistently uses `println` statements and commenting while debugging.	Creates visual output in the program window while debugging.
11. Conditional Statements	Can use a single `if` statement correctly.	Can use combined `if` and `else` statements correctly.	Can use `if`, `else if`, and `else` correctly multiples times in a program.	Can use multiple styles of combinations of conditional statements (i.e. nested, sequential) in a single program.
12. Loops	Can use a basic `while` loop.	Can use a basic `for` loop with a variable modified by an increment (`++`) or decrement (`--`) operator.	Can use `for` loops with a variable controlled by `--`, `++`, and other arithmetic operations as appropriate.	Can use both `for` and `while` loops when appropriate, and explain why one is a better choice over another in a given situation.
13. Handling Events	Can modify the state of a running program using the `keyPressed()` method.	Can modify the sate of a running program using multiple keys via the `keyPressed()` method.	Can modify the state of a running program using `mouePressed()`, using the mouse’s coordinates in some way, as well as using `keyPressed()`	Can work with all the keyboard and mouse event handling Processing functions.
14. Using Objects	Can declare and Object variable and instantiate an Object using a constructor.	Can use multiple Objects in a program by calling methods on appropriately declared and instantiated Object variables.	Can use Objects in a program, describe how reference variables work, and how they are different from primitive variables.	Can use Objects and accurately make heap diagrams of Object variables and data.
15. Writing Classes	Can design a class by grouping together ideas that should be encapsulated into a single class.	Can separate out the fields from the methods while designing a class.	Can write a class with fields, a single constructor and methods.	Can write classes with fields, and overloaded methods and constructors.
16. 1D Arrays	Can declare and instantiate a primitive 1D array.	Can declare, instantiate, and use primitive 1D arrays, including iterating though them with loops.	Can declare, instantiate, and use primitive and object 1D arrays.	Can work with 1D arrays in non-sequential ways. Understands the concepts of deep and shallow copies of arrays.
17. 2D Arrays	Can declare and instantiate primitive and object 2D arrays.	Can declare, instantiate, and use primitive and object 2D arrays, including iterating though them with loops.	Can work with both square and rectangular 2D arrays.	Can use 2D arrays to model grid-based structures (i.e. game boards, images, cellular automata)