COMP222 - 2022 - First CA Assignment

Individual coursework

Asteroids-like Game

Assessment Information

Assignment Number 1 (of 2)

Weighting 12%

Assignment Circulated Friday 4 February 2022

Deadline Monday 28 March 2022, 17:00

Submission Mode Electronic

Learning outcome assessed 2. An appreciation of the fundamental concepts associated

with game development: game physics, game arti-

ficial intelligence, content generation;

The ability to implement a simple game using an

existing game engine

Purpose of assessment To implement a simple 3D game using a game engine

library

Marking criteria The marking scheme can be found in Section 3

Submission necessary in order No

to satisfy Module requirements?

Late Submission Penalty Standard UoL Policy

I enforce a “no error policy” in this module: If your code does not compile,

your mark will be capped at 40%. Thus, you may get a higher mark for an

incomplete solution than for an advanced sketch.

1

Figure 1: Before shooting asteroid Figure 2: After shooting asteroid

Objectives

This assignment requires you to implement a simple 3D game using the jMonkeyEngine

library. Optionally, you can use Unity 3D or Unreal Engine.

Basic Game Description

The objective of this assignment is to implement a game inspired by the classic arcade game

“Asteroids”, see, for example,?https://en.wikipedia.org/wiki...(video_game)

and?https://www.youtube.com/watch...

The game is played on a rectangular “field” bounded by walls from above, below, left and

right (the original game has no walls, but your game has). The game objects (“asteroids”)

are positioned inside the field and can “float” in a linear movement (by translation). When

an asteroid collides with a wall or another asteroid, it “bounces” (changes direction according

to Newton Laws without gravity). A player controls a spaceship that is able to “fly” inside

the field and to “shoot” bullets. When a bullet strikes an asteroid, the asteroid “breaks”

into a few smaller asteroids (at least 2 ) that float in directions and speeds different than the

direction and speed of the original (broken) asteroid. An asteroid can break into smaller ones

at most 5 times, i.e. when an asteroid of minimum size gets shot by a bullet, the asteroid

disappears (is removed from the field). The player wins when all asteroids are removed from

the field. The player loses when an asteroid collides with the spaceship.

Figure 1 shows an example of the the game’s setup, i.e. within a field bounded by 4 walls,

there exist 3 asteroids (large green balls) “floating” according to the blue vectors (arrows),

as well as 1 spaceship (blue triangle) shooting towards one asteroid (red dashed line). Figure

shows the effect of the bullet hitting an asteroid, i.e. it is removed from the game and

replaced by two smaller asteroids (smaller red balls) that float towards different directions

and speeds than the removed greed ball.

2

Marking Scheme

The assignment is split in a number of steps. Every step gives you some marks. You do

not have to implement them in any particular order. Also, the steps below describe what

is expected from you in a bit more detail. It is up to you if you implement the following

functionalities using your game engine’s internal functions, or if you write your own functions

to do so. Neither choice will be favored with extra points.

Step 1: Modeling the environment (10%)

Model the playing field (4 walls), the asteroids and the spaceship. You can either use a 3D

modeling tool like Blender or use the shapes of the game engine you implement the game

in. You must put at least 3 asteroids on the field, and exactly one spaceship. Make sure

that the playing field is relatively large, i.e. if the size of the field does not facilitate smooth

gameplay, marks will be removed.

Step 2: Keyboard interaction (20%)

In this step you should implement the control of the spaceship from input given by the human

player. Preferably the player should use the keyboard. However, using other input methods,

such as the mouse, is not disallowed. The step is further divided into smaller sub-steps.

Step 2.1: Implementing “fly” (15% / 20%)

In this step you should implement the “flying” of the spaceship. The spaceship has some

initial direction and has its initial speed equal to 0. Assuming you take input from the

keyboard, you assign 4 buttons: button “forwards” increases the speed of the spaceship

along the current direction; button “backwards” decreases the speed of the spaceship along

the current direction; button “rightwards” rotates clockwise the direction of the spaceship

with some fixed angular speed; button “l(fā)eftwards” rotates counter-clockwise the direction of

the spaceship with some fixed angular speed.

Step 2.2: Implementing “shoot” (5% / 20%)

In this step you should implement the “shooting” of the spaceship. Assuming you take input

from the keyboard, you assign 1 button “shoot” which releases a bullet from the position

of the spaceship and along the current direction of the spaceship. The speed of the bullet

should be relatively fast (at least faster than the spaceship). The amount of bullets is for

you to decide. The interaction of the bullet with the asteroids is described below in Step

3.3.

3

Step 3: Physics 30% total

The purpose of this step is to model the physical interaction of the game entities. The step

is further divided into smaller sub-steps.

Step 3.1: Implementing “float” (5% / 30%)

In this step you should implement the “floating” of the asteroids. They move linearly

according to a given initial direction and speed.

Step 3.2: Implementing “bounce” (10% / 30%)

In this step you should implement the “bouncing” of the asteroids. When an asteroid

collides with a wall, it should reflect off the wall. When two (or more) asteroids collide with

each other, they should reflect off each other. The bouncing should follow Newton’s Laws

and should not take gravity into account, because supposedly the game takes place in outer

space. When an asteroid collides with the spaceship, the player loses.

Step 3.3: Implementing “break” (15% / 30%)

In this step you should implement the “breaking” of the asteroids. An asteroid “breaks” into

smaller ones after it has collided with a bullet. “Breaking” means that the original asteroid

is removed from the game and is replaced by 2 (or more) smaller asteroids. The direction and

speed of the smaller asteroids should be different than that of the removed asteroid. (I don’t

pose any other restriction, it’s up to you how the smaller asteroids behave.) Also, breaking

of an asteroid should be done at most 5 times, otherwise the game will never end. I.e. when

an asteroid of minimum size breaks, it is removed and not replaced by any asteroid(s).

Step 4: Gameplay (20%)

Add a visible points count and some kind of game levels. The point system is up to you to

define, for example every hit of a bullet with some asteroid gives 1 point, or you can have as

points the percentage of bullets used to bullets that have hit asteroids. To get full marks for

this steps, you should have at least 2 levels and it should be clear when the player progresses

to the higher level. Moreover, it is important that the levels have increasing difficulty. How

this is achieved is again up to you, e.g. higher levels can have more asteroids, or faster

asteroids, or break into more asteroids, or can break more times, or combinations of these

options.

Step 5: Creativity (20%)

You can see that the marks for the steps described above add up to 80%. In order to

get 20% extra you need to be creative and implement some nice features. Below are some

ideas: use textures, sound effects, lighting, power-up packs (making the spaceship immune

4

to impact with asteroids, or even able to function as a bullet itself), implement some system

on acquiring bullets, etc. Also, the above specifications do not define what happens if the

spaceship or a bullet hits the wall. Typically, they should simply stop at the point of collision.

However, you can be more creative here, and implement a weird bounce, or that they can

exit the field from the point of collision and re-enter from the opposite side (like the original

game).

Deadlines and How to Submit

Deadline for submitting the first assignment is Monday 28 March 2022, 17:00

Submission is via Canvas accessible from

https://liverpool.instructure...

All submission must contain the source code, the executable, the necessary files for the

runtime execution and a report.

For jMonkeyEngine submissions you are advised to export your project (File →

Export Project → To ZIP) and submit the ZIP file. Please ensure that the files you

submit can be loaded into jMonkeyEngine.

For Unity and Unreal Engine you are advised to build & export your game so that

it runs independently of these platforms; instructions are found online. To submit the

code you have scripted, copy it to a txt file. Please ensure that your submitted game

is playable.https://www.bilibili.com/video/BV1gA4y1f7kx

https://www.bilibili.com/video/BV1XW4y1C7yP

https://www.bilibili.com/video/BV1GY4y1x77y

https://www.bilibili.com/video/BV1AU4y117Gx

https://www.bilibili.com/video/BV1yY411K7BB

https://www.bilibili.com/video/BV15v4y1G7nC

https://www.bilibili.com/video/BV1vY411K7Tm

Please submit the report in the form of document (in pdf-format) containing a

check list indicating whether the above marking points have been implemented successfully.

In the extra features part of the checklist, describe the features you have

implemented.