FIT2096 - Games Programming

ASSIGNMENT 2a [20%] - Individual Assessment

Game Prototype
SUBMISSION DUE: Friday Week 10, 11:55 PM
Covers Topics from Weeks 1 - 9

Late Penalty: 10% of total marks per day late

Learning Outcomes
Completion of this assignment demonstrates the following learning outcomes:
● Create game programs that demonstrate an understanding of the programming game loop
and how to set it up
● Create game programs that demonstrate an understanding of DirectX, including textures,
displaying sprites, animation, text, and rendering
● Create game programs that demonstrate an understanding of physics in the games
programming context, including basic movement and interaction
● Create game programs that demonstrate an understanding of Direct 3D rendering, including
geometry, models, cameras, textures and lighting

Brief
Across the semester you will be building a game prototype for a 3D “Beat ‘Em Up” style game. This
will be based on the labs from weeks 6 - 12, with significant custom components created by you
across the semester. With discussion from your demonstrators, you have freedom to decide what
mechanics you will develop as long as they meet the assignment requirements.

Submission Requirements
Upload the link to your Git repository via Moodle. You will be assessed based on your most recent
commit prior to the due date.

Make sure the following people have maintainer access:

● josh.olsen@monash.edu
● nic.pallant@monash.edu
● jason.free@monash.edu
● jordan.lequesne@monash.edu

Readme
As part of your Git repository, you will need to include a Readme text file that contains the following:
● The controls for your game, including what inputs are needed with a brief description of
what they do
● The mechanics/features you would like to be assessed, which includes
○ Core Mechanics
○ Physics Mechanics
○ UI Elements
○ AI Elements

1
FIT2096 - Games Programming

Use of Generative AI in Assessment

In this assessment, you can use generative artificial intelligence (AI) in order to create
backgrounds for your main menu and any billboards within the game, Any use of generative AI must
be appropriately acknowledged (see Learn HQ).

Where used a readme text file MUST be included that contains the following information about
each generative AI asset
● Name of asset
● The prompt used to generate the asset
● Use in game (background, etc.)
● The tool used to create the assets (Dall-e, Stable Diffusion, MidJourney, etc.)
● The model used if known (e.g. SDv1.5 https://huggingface.co/runwayml/stable-diffusion-v1-5)

Task: Core Gameplay

For this first submission you are creating the start of your game, including a core mechanic, physics
interactions, user interfaces and the foundations of the games artificial intelligence systems. These
will be built upon the lab tasks completed weekly, with check-ins on progress done as part of
Assignment 2c.

All tasks must be completed in C++ unless explicitly stated otherwise. These tasks must also be
unique and different from what has been covered in the lab classes and workshops (i.e. Brimstone
Molotov).

The submission of this prototype must include the following components:

● Version Control via Git & GitLab
● Core Mechanic
● Physics Interactions
● User Interface Design
● Initial AI with Behaviour Tree

Version Control via Git & GitLab:

Suggested Completion Date: End of Week 6
When building your prototype you must store your work within a Git Repository using the Monash
FIT GitLab server (https://git.infotech.monash.edu).

This repository should use GitLFS for all files within the Content folder (game assets).
.gitignore File
The repository must use a .gitignore file to exclude the following folders from the repository:
● .vs
● Binaries
● Build
● DerivedDataCache
● Intermediate
● Saved

Instructions for setting up this repository can be found in the week 1 lab tasks and week 6 lab tasks
on Moodle. Additional material is also available in the software installation guide under week 1.

Commits to the repository are to be at least once a week with meaningful commit names.

2
FIT2096 - Games Programming

Core Mechanic
Suggested Completion Date: Week 8
Your prototype must include a major core mechanic that helps define the gameplay in the project.

You have freedom to choose what mechanics you would like to create for your prototype, however
they must be approved by your demonstrator. This process is to ensure you do not choose to create
a mechanic that is too trivial or too difficult.

What is a core mechanic?

A core mechanic is a mechanic that has a major impact on the gameplay and is recurring
throughout the game. Examples of core mechanics include:
● Being able to build structures in Fortnite to hide or trap non-player characters (NPC)
● The ability to attack or disrupt an NPC
● Using a magic spell to remove an obstacle
● Reversing time to give yourself a second chance

Physics Interactions
Suggested Completion Date: End of Week 7
Your prototype must include two additional physics based mechanics. One of these mechanics
must demonstrate the use of impulses or other forces being applied. The second mechanic must
demonstrate the use of the physics constraint component such as hinges, pulleys, motors, etc. You
should discuss this with your demonstrator to ensure that they are of the appropriate complexity.

User Interface
Suggested Completion Date: End of Week 8
Your prototype must include two different user interfaces (UI); a main menu and an in-game UI.
Each of these UIs must be created with a combination of C++ classes and UI blueprints as
demonstrated in the week 7 lab.

Main Menu
The main menu UI must be created inside of its own level with its own GameMode class written in
C++. At minimum the UI must contain the following in addition to what is created in the week 7 lab:
● A background colour / image that matches the theme of your game
● A title for your game

In-Game UI
The in-game UI must be modified from the week 7 lab to include new information relating to your
custom mechanics. This UI should provide relevant information to the player based upon your game
mechanics and design. This should also be completed in C++ making use of bindings. Examples for
this include:
● Visibility
● Currently held items
● Current weapon

3
FIT2096 - Games Programming

Artificial Intelligence
Suggested Completion Date: End of Week 10
Your prototype must contain a custom navigation mesh and at least one agent type within your
game. You should discuss this with your demonstrator to ensure that they are of the appropriate
complexity.

Navigation Mesh
A navigation mesh that is significantly different from the week 8 lab must be created and
demonstrated with a different level design of your own design. This should include custom
connections and jump points for agent movement across the level.

Agent Types
You must include at least one agent type within your game that makes use of the Navigation Mesh
as well as, a Behaviour Tree, Blackboard, and Senses (Sight, Sound, or Touch). This behaviour tree
must include an additional behaviour beyond what has been created for the week 9 lab

4
FIT2096 - Games Programming

Code Quality
Suggested Completion Date: Continual Updates Weekly
Your prototype must be created with code quality as a major consideration. As part of this, you must
ensure that proper indentation is used along with consistent naming conventions for classes,
functions and variables. The use of the Tick function within Actors should be carefully managed to
ensure that only critical elements are updated each frame.

Comments
All code should be commented where not immediately obvious as to what the block of code is
doing. Each function should contain at least some amount of commenting. Use of in-line comments
is perfectly acceptable. You do not need to comment the code from the lab tasks.

Proper Indentation
All code should be properly formatted to ensure correct indentation is used. You must use a tab or
4 spaces for each step of indentation.

Consistent Naming Conventions

All code within the project should use the following conventions:
● Variable names must use PascalCase
● Function names must use PascalCase
● Boolean values must include a b prefix (e.g. bIsObjectFalling)
● All functions that return a boolean must ask a true/false question (e.g. IsObjectAboutToFall)
● Code should be self-documenting. All functions and variables must indicate their function by
name

More information on coding conventions can be found in the Unreal Documentation

Appropriate Use of Tick

The Tick function inside of Actors should have its use minimised to ensure that unnecessary
calculations are not done every single frame. Your code should consider the following:
● The Tick function should be disabled in Actors where updates are not needed every frame
● Where possible timers should be used for actions that are required at set intervals that are
not each frame

Appropriate use of Folders in Content Browser

Assets contained within the Content Browser must be neatly maintained and stored using a folder
structure to keep assets organised. At minimum the folder structure should include the following:
● Blueprints
● Textures
● Materials
● Meshes
● Levels
● Characters
○ Player
○ NPC
● Effects
● UI
● Input

5
FIT2096 - Games Programming

Assessment Criteria
Your assignment will be marked on the following criteria listed below.

● Git Repository Setup - 5 marks

○ Setup of git repository with GitLFS and gitignore being utilised
○ Weekly commits from week 5 onwards
● Completion of Weeks 6 to 9 Labs - 20 marks
○ Full completion of lab tasks is present and forms the base code for the assignment
● Implementation of Core Gameplay Mechanic - 15 marks
● Physics Interactions - 20 marks
○ One physics mechanic with forces/impulses has been created
○ One physics mechanic with constraints has been created
● User Interface - 15 marks
○ Main Menu UI
○ In-Game UI
● Artificial Intelligence - 15 marks
○ Custom navigation mesh implemented
○ Additional agent behaviour implemented
● Code Quality & Optimisation - 10 marks
○ Comments
○ Proper Indentation
○ Consistent Naming Conventions
○ Appropriate use of Tick
○ Appropriate use of folders in Content Browser

A detailed marking rubric is provided on Moodle.

Feedback Information
You will receive a mix of formal and informal feedback for this assessment. Demonstrators will
provide feedback in your scheduled lab sessions informally the week after submission. Formal
feedback will be provided within 10 business days of submission

6
FIT2096 - Games Programming

Where to get help

If you are struggling with anything or need additional support please do not hesitate to reach out
using any of the following support services:

English language skills

if you don’t feel confident with your English.

● Talk to English Connect: https://www.monash.edu/english-connect

Study skills
If you feel like you just don’t have enough time to do everything you need to, maybe you just need a
new approach

● Talk to an academic skills advisor: https://www.monash.edu/learnhq/consultations

Things are just really scary right now

Everyone needs to talk to someone at some point in their life, no judgement here.

● Talk to a counsellor: https://www.monash.edu/health/counselling/appointments

(friendly, approachable, confidential, free)

Things in the unit don’t make sense

Even if you’re not quite sure what to ask about, if you’re not sure you won’t be alone, it’s always
better to ask.

Ask in the forums, book / attend a consultation or email your demonstrator

● Forums Link: https://edstem.org/au/courses/14450/discussion/

● Consultation Schedule: https://learning.monash.edu/course/view.php?id=10732&section=1
● Tutor Contact Information:
https://learning.monash.edu/course/view.php?id=10732&section=1

I don’t know what I need

Everyone at Monash University is here to help you. If things are tough now they won’t magically get
better by themselves. Even if you don’t exactly know, come and talk with us and we’ll figure it out.
We can either help you ourselves or at least point you in the right direction.