Gameplay Programming (CT5GPROG)

Abstract

This module introduces the practicalities of implementing gameplay for computer game prototypes. Through a mixture of code analysis and guided practical experimentation the students will gain familiarity with common programming patterns and gameplay mechanisms, and examples of approaches to implementing them in code. For their coursework they will be required to present small scale but nonetheless challenging artefacts, demonstrating appropriate implementation skills in suitable programming environments.

Learning Outcomes

On successful completion of this module, students should be able to:

LO 1

Implement common gameplay mechanisms in code.

LO 2

Utilise industry-relevant programming patterns in the creation of a software artefact.

LO 3

Respond effectively to small-scale programming challenges.

LO 4

Critically evaluate high-level options for game prototyping.

Key Dates

Assessment 1 (100%): Mechanics Demo and Presentation

Submit online via Moodle. Check Moodle for due date.

Your final deliverable for this module will consist of a small gameplay prototype and a 15-minute video presentation. The focus of the module and the assessment is gameplay programming, with particular emphasis on code quality, data structures, design patterns, and project structure.

Your prototype must be inspired by the theme “All Dogs Go to Heaven”, the passion project of your studio’s new, eccentric creative director. They envision the game as a series of vignettes or small gameplay loops based on dog activities, aspects of a dog’s life, or how they might manifest in the afterlife. It is your job to prototype ideas for this larger project.

You are free to interpret this theme broadly but remember that the focus should be programming the mechanics, rather than specific game design, visuals or animations. This means your “dog” could be a represented by a random game object. It shouldn’t be fully animated with complex physics, unless that is important to your prototype.

This assessment constitutes 100% of your marks for this module and will assess Learning Outcomes 1, 2, 3, and 4 of the module description.

The Task

Create a small gameplay prototype based on the theme of dogs. Your prototype should include at least two distinct gameplay mechanics, one primary mechanic and at least one mechanic that supports this primary system. The interplay of these mechanics should create a small gameplay loop. Simple mechanics that facilitate interaction (e.g., simple movement of objects, keypresses etc.) do not count.

Most importantly, the prototype should be designed so that it can be extended or integrated into a larger game project, with a focus on creating clean, modular, and maintainable code using good programming techniques. Simply creating a prototype with purely functional gameplay mechanics is not sufficient.

Below are examples of types of mechanics that integrate some of the concepts covered in the module:

● Scent Tracking

o Primary mechanic: A system where the dog follows a scent trail through an environment.

o Secondary mechanic: The trail can dynamically change based on events happening in the environment.

● Play Interactions

o Primary mechanic: A command-based system where the player can issue a series of commands (e.g., “fetch,” “dig,” “guard”) in a sequence. Each command is stored in a queue and executed in the order given. Dogs can unlock new commands through a skill tree.

o Secondary mechanic: Sometimes, the dog doesn’t listen to specific commands and can be trained to ensure they perform the correct command.

● Pack Management

o Primary mechanic: A system where the player manages a pack of dogs, each with different attributes and abilities. The leader can be switched out to access these different abilities to, for example, solve puzzles.

o Secondary mechanic: Swarming and following behaviours for the pack.

● AI Behaviours

o Primary mechanic: A system where the dog's AI dynamically switches between different behaviours or states based on elements in the environment (e.g., idle, chasing, exploring).

o Secondary mechanic: Environmental hazards that broadcast their status into the environment and affect the dog’s behaviour (e.g. birds, rocks)

Programming Requirements

Your gameplay prototype must demonstrate the application of complex programming approaches, such as the gameplay programming patterns and data structures discussed during the module. You may also incorporate other gameplay programming approaches from external research if this is discussed with your lecturer. You may want to incorporate one or a few relevant concepts from the module:

● Programming Patterns: Observer, Command, Memento, State, Singleton, Factory, Template Method, Iterator.

● Data Structures: Linked lists, queues, stacks, hash tables, and graphs.

You may choose any engine, but it must support object-oriented programming (OOP), as this is essential for implementing good class structures and implementing specific gameplay programming patterns.

● Unity is the suggested engine for this module due to its support for integrating OOP through C# scripting, and its ability to quickly create mechanics prototypes.

● Unreal Engine may also be used, but you must use C++ code, not Blueprints.

● If you wish to use an alternative engine, you must discuss it with the lecturer to ensure it is suitable for the assignment.

The Video Presentation

Your 15-minute video presentation should focus on the following areas:

1. Planning (10 marks): Discuss the planning process for your prototype, with specific focus on technical decisions (i.e., project structure, class hierarchy, patterns or structures used). Include relevant UML diagrams, interactivity flowcharts, and other visual aids. Also discuss how you interpreted the theme.

2. Implementation (20 marks): Demonstrate and explain the core mechanics of your prototype by showing both the game at play and some of the underlying mechanics-focused code. Discuss the technical implementation (patterns, structures, algorithms, etc.) rather than the visual or aesthetic elements.

3. Programming practices (20 marks): Discuss how you structured your project, with emphasis on professional programming practices like project structure, class hierarchies, code organisation, and content from the module. Only using comments in your code, while an aspect of professional practice, is not sufficient.

4. Completeness (10 marks): Discuss the adjustments you made to your prototype to ensure it is a fully functional small prototype. This may include polishing assets, adding UI elements or tutorial text, or ensuring the game has good “game feel”.

5. Future development (10 marks): Discuss how your prototype could be extended or integrated into the larger project. How would you adapt the project hierarchy, your code and mechanics for further development?

6. Challenges and problem-solving (10 marks): Reflect on any programming challenges you encountered during the project and how you resolved, or attempted to, resolve them.

7. Personal reflection (10 marks): Reflect on your growth during the module, how you approached the workshops, and any additional research or resources you used to improve your skills.

8. Presented work (10 marks): The use of English in your presentation should be of relevant quality. This includes elements such as clarity, formal and technical tone, structure, pace, and your overall quality of communication.

What you can’t do

The work must be entirely your own. Do not plagiarise others’ reference management entries or their research summaries. You can learn more about plagiarism in the section at the end of this brief.

What you must do

Discuss your gameplay demo idea with your lecturer to ensure it meets the learning outcomes. Your gameplay demo should both demonstrate the skills and techniques you’ve learnt in the module as well as your own independent research on industry-appropriate programming techniques.