Reference no: EM132303123

Object-Oriented Programming - Java Programming Assignment

In this assignment, solution must be clearly separated into two separate parts, in separate Java packages:

Part 1: (in package boardgame.engine): your Game Engine classes with Unit Tests.

Part 2: (in package boardgame.gui): a JavaFX GUI that allows users to play your game.

Overview -

Your first task is to choose a simple one-player, two-dimensional (2D) board game, and then implement the 'engine' of that game in Java. You should write some unit tests to check that your game logic works correctly.

You second task is to use JavaFX to add a graphical user interface (GUI) to your game, which displays the 2D board and allows the user to play the game. So you must keep the basic game idea fairly simple, and ensure that it is not too hard to add the GUI to it. You MUST use JavaFX, not any other Java GUI libraries.

Learning Objectives -

1. Learn to use object-oriented design (OOD) to design Java programs;

2. Be able to use inheritance and subtyping relationships between classes;

3. Be able to use association or composition relationships between classes;

4. Be able to develop a comprehensive suite of unit tests for the core logic classes of an application (e.g., for the game engine);

5. Build simple graphical user interfaces using JavaFX.

Choice of Game -

Your game needs to be a simple 2D game that uses a discrete 2D grid for the playing board, like a chessboard, a Tetris board, a Crosswords board, or a maze.

You must choose one of the following games:

 1. Car Champ. A puzzle involving moving cars around to escape.

2. Word Grid. Like crosswords, but with a given set of words.

3. Minesweeper. A well-known logic puzzle.

4. Peggy. A bit like draughts/checkers but simpler.

5. Columns. This is like the classic Tetris game, but simpler. Or you could do ColorLines, which is also similar, but you will have to implement a 'path-finding' algorithm to move the balls around.

6. Raku. A color-flipping puzzle.

7. Sokoban. A block-pushing puzzle.

8. Concentration memory game

Or another simple game of your choice, if approved by the course coordinator.

Part 1: Game Engine

1. Set up your Git Repository. When you click on the Blackboard link for this assignment, you will automatically create your own private GitHub repository containing one module with two packages: boardgame.engine and boardgame.gui.

a. Clone this repository onto your computer using IntelliJ.

b. Make sure you also have Java JDK 11 installed on your computer.

2. Check you can run JavaFX. I have set up this project to use the 'Gradle' build tool, which means that it should automatically download and install the necessary JavaFX and JUnit libraries when you build and run the project on each new computer. To get Gradle to build your project: Open the boardgame-gui folder, right-click on build.gradle and do "Import Gradle project". Set the options as follows:

• Turn on "Use auto-import"
• Select "Use grade 'wrapper' task configuration
• Click 'OK'

This should download JavaFX and build your whole project. Then you can right-click on "boardgame-gui/src/main/java/boardgame/gui/RunGame" and do "Run RunGame.main()". You should see a JavaFX GUI pop up with a single button that says 'game coming soon...' Use this RunGame class every time you want to run your GUI.

3. Data Design Decisions: Think carefully about whether each cell in your board should be a primitive value (like a boolean, an integer, or an enum value), or should it be an object? Using objects is more flexible, since it allows you to use Java subtyping to make different cells have different behaviour. But many of the games suggested above do not require the cells to have fancy behaviour, so a primitive value might be sufficient for your game.

4. Implement and Test Your Game Engine: I strongly suggest that you use TDD to develop your unit tests and game engine at the same time, in parallel. Recall: Write a test for each new feature and check that it fails, then implement that feature in your engine classes and rerun the test to check that it now passes. Repeat... You can refactor (rename and reorganise) your code at any stage, if you see a way of making it simpler and more elegant. By the time you have finished implementing your game engine, one (or several) of your tests should be stepping through a complete game from start to end, calling the methods of your engine API and checking the results, including the game win/lose verdict at the end.

5. Class Relationships: To get high marks, your engine needs to include several Java classes, with some association/composition relationships between them, and if possible, some inheritance relationships. Think about where you can best use these Java features.

Part 2: Game GUI

The goal of this stage is to use JavaFX to add an elegant and fully functional GUI to your game so that it can more easily be played on desktop computers. Your GUI should have the following features:

• event-handling of mouse and/or keyboard events;
• display of bitmap images (I recommend you use some large images for the background of the whole game or each panel, so that the game looks professional and entertaining);
• multiple panels, with a main gaming panel to display the game, plus one or more panels around the edges to display game options, score information, and control and help buttons etc.;
• correct resize behaviour when the user adjusts the main window to different sizes for different devices;
• a clean separation between the back-end (game engine) and front-end (GUI) classes using different Java package names, as described above;
• [optional] use of a timer to have ongoing real-time activity in the game (for example, to make the blocks fall in the Columns game).

Start by drawing one or two paper sketches of the GUI you plan to build. Take a photo of each sketch, as you will need to include these in your final report.

Attachment:- Assignment File.rar