代写data编程、代做Java设计程序

日期：2024-01-28 10:26

Project: Maze Runner

We want you to practice composing multiple classes and files into one larger, functional piece

of software. For that, we ask you to implement a small game in Java.

Game Idea

The core idea of the game is navigating a character through a maze, overcoming various

challenges to reach the exit. The maze contains multiple different elements like traps, enemies,

and keys that the player must interact with or evade to escape. The game unfolds in a maze

enclosed by walls on all sides, featuring an entry point where the player starts and an exit to

reach for completing the game. Within the maze, the player will encounter an intricate

network of interior walls that create not only a challenging path but also various dead-ends.

Randomly scattered throughout the maze are traps and enemies that the player must avoid

or overcome, as well as keys that must be collected to unlock the exit.

Game Logic

Your game must implement the following mechanics:

Walls and Paths

The game world is designed as a maze, consisting of traversable paths and walls. Each maze

has exactly one entrance and at least one, potentially multiple exits. The exit points are

exclusively situated on the outer border of the maze, which is otherwise completely enclosed

by walls without any gaps. The entrance can be anywhere in or on the border of the maze.

When playing the game, it's crucial that the entrance and exit are clearly distinguishable from

walls and each other. The entrance should be uniquely identifiable, as should the exit, but in

a distinct manner.

In this context, 'paths' refer to the free space within the maze. The density of the maze can

vary significantly, ranging from sparse layouts with abundant open space and fewer walls, to

dense configurations characterized by numerous walls and limited walkable paths.

Character

The main character must be able to move through the maze in four directions (up, down, left,

right). Generally, the character can only walk in free spaces; they cannot walk through walls.

The character must have a number of lives. If the character loses all their lives before reaching

and opening the exit (see below), it's game over.

Obstacles

The maze contains at least two kinds of obstacles. Essentially, an obstacle is an additional

object on an otherwise free path within the maze that causes the character to lose a life when

contact occurs. Like the character, obstacles can only exist within free paths and cannot pass

through walls.

The two required kinds of obstacles are:

Traps: Obstacles with a fixed position within the maze.

Enemies: Obstacles that are dynamic. This means their position within the maze changes

regularly in short intervals. For minimal requirements, they must move randomly throughout

the maze but never leave it; however, for bonus points, they can exhibit more intelligent

behavior (see below).

Keys

The ultimate goal for the main character is to exit the maze. However, to open the exit, they

must have collected a key. There will be at least one, but potentially multiple keys in each

maze. The character must collect at least one key to use the exit of the maze. Attempting to

exit without the key should result in the path being blocked (think: the exit behaves like a wall

until you have a key).

HUD

The game must have at least a small, basic HUD that is visible to the player at all times while

navigating the maze. It must at least display the following information:

- Amount of lives remaining

- Whether a key has been collected

Game Menu

There must be a game menu displayed at the launch of the game and any time a player

presses the Esc key during gameplay. If a player presses Esc to access the menu, the game

itself must be paused (i.e., the main characters and all enemies stop moving). In this menu,

players must at least be able to:

- continue the game (if coming from Esc)

- load a new map file and start a new game

- exit the game

ALL UI and MENUS must be libGDX based. No JavaFX or something.

Victory and Game Over

If the player can leave the maze without losing all lives, they achieve a victory. In this case,

display that the user has won, and stop the gameplay.

If the player loses all lives, the game is over. In this case, display that the game is over, and

stop the gameplay.

In both cases, allow to go back to the main menu.

Technical Requirements

Maze files

You should not generate or define a maze yourself within your program code. Instead, your

program must be able to run any arbitrary maze stored in a Java properties file. If the player

chooses the "load map" option in your game menu, your program must open a File Chooser

and allow them to select the file. Then, your program should read the file and start the game

based on the maze defined in this file.

Properties files are a very simple way to store data in files in Java. Essentially, they just store

key-value pairs of Strings; think of it as a Map<String, String>. In our maze files, the key

specifies the x and y coordinates, separated by a comma, for example: 5,6.

The value specifies the type of the object at the given coordinates. The following types exist:

Value | Type

-------------------

0 | Wall

1 | Entry point

2 | Exit

3 | Trap (static obstacle)

4 | Enemy (dynamic obstacle)

5 | Key

The coordinate system starts at the bottom left with 0,0. x coordinates extend to the right,

and y coordinates go upwards.

Check out one of the files in the maps directory to get an idea.

Graphics

Your game must be a 2D game based on libGDX with a top-down view.

Each object must be rendered as a 2D sprite at their respective coordinates as specified by

the map file. Ensure to use proper, open-source 2D assets (images) to render the different

object types. We recommend using simple 16x16 pixel graphics. Recommended sources

include Kenney or OpenGameArt.

Ensure that your animations are fluent and your game runs on a playable, fluid framerate.

We provide you with a skeleton for such a game, so you don't have to start from scratch.

Viewport

Different computers have different screen sizes. Some players may want to play your game

on a very large screen or maybe in a very small window.

Therefore, please make sure to fulfill the following important requirements:

- The maze may be larger than the screen. Implement a camera movement mechanism

that ensures that the player character is always visible within at least the middle 80% of

the screen horizontally and vertically during gameplay. If the window is resized, ensure

to readjust the camera position to adhere to this rule as well.

- Your game must adapt to different sizes of your program window.

- DO NOT scale the game items if the window size changes. If the user scaled up the

window, that means they can now see a larger segment of the maze.

Music and Sounds

Include music and sound effects in your game. Use the Music and Sound classes of libGDX to

achieve this. There is an example of playing music in the template.

Ensure to balance volume of music and sound effects. Choose royalty-free tracks and effects,

for example from OpenGameArt.

https://opengameart.org/art-searchadvanced?keys=&field_art_type_tid%5B%5D=13&sort_by=count&sort_order=DESC

Background Music

- Gameplay: Loop a background track during gameplay, matching the game's intensity

and theme.

- Menu: Play a different, calmer track for the game menu.

-

Sound Effects

Play sound effects if something happens to make the experience more immersive. Play proper

sound effects at least for the following events:

- Life lost

- Key collected

- Victory

- Game over

Code Structure

- Implement your game in an object-oriented manner using concepts presented in the

lecture.

- The different object types like entry, exit, all types of traps, and all types of enemies must

be dedicated classes, inheriting from at least one common superclass, such as a

GameObject that contains shared functionality and properties. Use a class hiearchy that

makes sense for your game. A wall does not necessarily have to be a class, but can be.

- Avoid code duplication using inheritance, delegation, and proper usage of method

extraction.

Documentation

- Your code must be documented properly. Document each class and each method with

proper JavaDoc!

- If you use code from the internet, add the source URLs into your JavaDoc of the method

using the external code.

- Create a README file that documents your project structure so a reviewer can easily

understand:

1. your code structure - how is everything organized, what does the class

hierarchy look like?

2. how to run and use your game?

3. rules for and description of game mechanics that go beyond the minimal

requirements

Checklist

When creating the project, remember the following points:

- Your program must be able to read any maze from a properties file and play it.

- The character must be movable with the arrow keys in four directions.

- The character has a limited number of lives.

- The character must collect a key from the maze and reach the exit before losing all lives.

- Static traps and dynamically moving enemies are obstacles. On contact with any of them,

the player loses one life.

- Camera Movement: Implement a camera movement mechanism that ensures that the

player character is always visible within at least the middle 80% of the screen horizontally

and vertically during gameplay.

- HUD: Display the amount of lives left and key collection status at all times.

- Game Menu: Available on startup and through the Esc button; must allow to continue

playing, choosing a new map, or exiting.

- Victory and Game over: Your game must display that the player has won or lost, stop

the gameplay and allow to return to the main menu afterwards.

- Render the game using libGDX as a 2D game with a top-down view using simple 2D

assets.

- Your game must run fluently.

- Support different screen sizes.

- Play background music during gameplay and in the menu

- Use sound effects when something happens in the game

- Use object-orientation to implement your game. Each object type must be a dedicated

class (except for Wall - this can optionally be a class, but doesn't have to be) in a proper

class hierarchy.

- Document your code and your project properly.

Extension for Bonus Points

You are free to extend the game as you like as long as the minimal requirements are and stay

fulfilled.

Functionality that goes beyond the minimal requirements may result in bonus points.

Some examples follow below. Especially the first one is a cool thing to have in a game like

this and will definitely earn you more than one point ;)

- Enemies move intelligently towards the main character using a path-finding algorithm if

they are within a certain range, instead of moving randomly.

- Point systems: Can players get a score in the end, e.g., based on time?

- Collectable lives.

- More types of obstacles.

- Further abilites for the main character other than walking, such as

- combat with enemies

- collectable power ups (faster running, shield, …)

- Fog of War.

- Movable walls.

- Multiple kinds of things other than a key to exit (remember, having to collect a key is the

minimal requirement; you can require more things before you open the exit).

- …

- Unleash Your Creativity! Treat this project as your experimental playground, a space

where you can try out innovative ideas, apply your acquired knowledge, and

continuously learn along the way. We're excited to see the remarkable game you'll create

and be impressed by your ingenuity!

Organizational considerations

Third party libraries

Third party code libraries that can be installed through Gradle are in general not allowed. We

want you to implement things yourself and avoid relying on third party features. You are free

to use all the various functionality built into libGDX. However, this covers only the base

framework; not all libGDX extensions are allowed. The following libGDX extensions are

approved to use: Box2D, Bullet, FreeTypeFont, Controllers, Tools, Box2DLights. Explicitly

not allowed are: Ashley, AI.

Scores & Grades

This game accounts for 20% of your final grade which can be achieved by scoring 100% in the

project.

You can score 100% in the project by fulfilling the minimal requirements for your project.

On top of that, all functionality that is implemented in addition to the minimal requirements

can result in bonus points.

You can achieve at most 10 bonus points.

By collecting bonus points, you can score up to an additional 10% on your final course score.

In sum, you can contribute up to 30% of your final score by delivering a top-notch project! :)

Troubleshooting

Fix Gradle JVM

On some machines, you run might into this issue:

To resolve it, click Open Gradle settings and select the Project SDK as your Gradle JVM:

Note: You might need to re-run Gradle afterwards. Open the Gradle Tool Window in View >

Tool Windows > Gradle and hit the sync button (two arrows forming a circle).

Fix the classpath

It's important that you use the run configuration that is delivered with the template. You will

have to adapt the classpath setting.

Windows and Linux

If you are on Windows or Linux, please remove the -XstartOnFirstThread VM option in the

run configuration: