Onboarding Project: Breakout Game

If children can build, play and understand games that work, it's possible that someday they will understand and design systems that work. And the world is full of complicated systems. —Sara Corbett

Submitting Your Work

You will be provided a GIT repository, breakout_NETID, hosted in the course's Gitlab group to work on this project (do not fork this repository, just clone it directly). All project submissions for this course will be based on only the version of your files in the provided Gitlab repository by 3:08am in the morning on the day after that given on the course Calendar (effectively a few extra hours grace time past midnight).

As your submission for this project, use GIT to add, commit, and push the following

• doc folder: Markdown files representing your plans and design goals
• src/main/java folder: project code
• src/main/resources folder: images and block configuration files
• top-level (no separate folder): project README (the content of this file is closer to the real-world, so it is different from other CompSci classes)

Deliverables

You will submit this project in stages:

• Plan and Starting Code: prepare for and plan your work for the project
• Complete: implement your plan

Specification

Individually, write a Java program using OpenJFX that allows someone to play a multi-level game of Breakout, a game originally designed by Steve Jobs and Steve Wozniak (the founders of Apple, Inc.). The basic game displays a ball bouncing around the window destroying blocks as it hits them. The player controls a paddle to keep the ball from exiting the window, causing the player to lose a life and reseting the ball to its starting position. If the player misses the ball too many times, the player loses. If all the blocks are cleared from the screen, the level ends and a new one loaded. If the player clears all the levels, the game ends and the player wins.

You are expected to go beyond creating a basic version of the game (a common CompSci 101 level assignment), with multiple levels, multiple lives, and unique behaviors that make the game more complete. However, your game should not be so complex to require any buttons, menus, toolbars, or multiple "threads". Drawing and interacting with shapes, images, and text in fixed positions within the scene is completely sufficient for all the requirements. No level needs to be the greatest version created or even have sophisticated graphics — so everyone should be able to create a complete program by picking less complex variations if necessary.

The full list of requirements is given here.

CompSci Context

This project highlights the following interesting and foundational Computer Science concepts. You are not expected to write a general or complete version of any of these concepts, but learning about them may help provide a context to begin thinking about some design issues or connect your work in this course to the broader computing community.

• Real-world connection: It is a very common requirement to learn a new coding package primarily on your own. While some basic OpenJFX code will be discussed in class, it is expected you will learn most of the details by reading online examples and documentation.
• The Game Loop, which is not a literal loop since OpenJFX is actually calling your code periodically to make changes before it draws items on the screen, is the heart of a game because it manages the entire game logic from responding to input, to updating the state of the game items, to enforcing the game's rules, to checking if the game's goals are met, to potentially much more. It is called a loop because it is responsible for managing the game actions repeatedly until the user quits. Each iteration, or frame, of the game loop is called on between 60 up to 120 times (frames per second, FPS). Game loops are typically organized around Update Methods to make it easier to add new elements — and, in very complex games, the game loop is factored out into a separate Game Engine so new games can be written by focusing just on the new code specific its characters, rules, and goals without modifying the Engine's game loop itself (there are many popular engines like Unity or Unreal (made in NC!)).
• Graphic processing units, GPUs, are specialized processors for performing math operations in parallel. Originally designed for computing the value of each pixel to render in a game by running all the operations at the same time instead of one after another, GPUs have proven very useful in reducing the training time for machine learning, ML, because they deal with complex operations efficiently, such as matrix manipulation. Recently, the demand is so great that there is a GPU shortage leading to price gouging.
• Games themselves are an increasingly important medium in terms of international use, cultural impact, profitability (it is a bigger industry than Hollywood), and now public Esport leagues and tournaments (with significant prizes). Arguably, gaming has also driven many recent advances in computer hardware and are finally gaining acceptance within the academic community as an area worthy of study. And why not? Games contain all of the basic elements taught in computer science and commercial game engines are becoming increasingly complex software systems.

Individual Responsibilities

This project is intended to be a fun introduction to the course's procedures and goals and to give us an understanding of your current coding and design level. It will not impact your final grade (unless you make no effort on it).

Specifically, it is intended as a warm-up to help you get used to the software, tools, and policies used throughout the semester

• code a project from scratch (and determine if the course is at the right level for your abilities)
• learn the basics of the OpenJFX framework (you will learn about more it in successive course projects)
• use the programming tools (IntelliJ and Git Version Control)
• follow the policies (submission requirements and the plan, code, reflect assignment cycle)
• try some basic Clean Code design practices to find areas to refactor your code rather than settling for the first draft just because it works

Resources

Take time now to learn and practice with these tools which will be used throughout the semester

• OpenJFX: Overview slides, Overview and Architecture, Timeline Animation tutorial, and shapes examples
• GIT: getting started tutorial, commands visualization, and best practices (for now you can ignore the last two about working in teams)
• Markdown: getting started tutorial and syntax reference
• IntelliJ: keyboard shortcuts and other useful features

You are welcome to look at the tutorial below (or any other ones you find online to learn about OpenJFX), but it is more complex than required for this project. In any case, your game should be distinctly different from any examples you find (i.e., create your own Breakout game, do not simply copy one).

• Building a OpenJFX/JavaFX Game: Part 1, Part 2, Part 3, and Part 4
• Breaking Down Breakout: System And Level Design For Breakout-style Games by Mark Nelson (a seriously complete analysis with many comprehensive explanations of typical variations)