SIT255 – Assignment #1
Game Development Project Stage 1:
Developing a Software Framework for Agent-based Games
Due Date
Your assignment submission deadline is 5:00 PM AEST, Friday 23rd August 2019. You must upload your submission to the appropriate drop-box on CloudDeakin no later than this deadline. Penalties apply to late submissions. See the section below on Assignment Marking for more information regarding late submissions. Extensions to this deadline will only be granted where documented evidence of hardship or serious illness is provided, in accordance with Faculty guidelines. Extension requests must be made using the appropriate form (available for download from http://www.deakin.edu.au/sebe/students) and submitted via email to the Unit Chair no later than 12:00 noon on Friday 23rd August 2019 You MUST also forward all work completed for this task up to that time. Except in the most extreme cases, failure to demonstrate any progress toward the assessment goals when requesting an extension will result in your request being denied.
This is a group assignment, you will be working in a groups from 3-5 and there will be a single submission per group.
Note: You are also required to submit individual weekly progress report outlining your contribution for every week leading up to the final due date. This is to ensure that there are fair and equal contributions from all members of the group. The weekly report will be used to calculate individual marks for the group assignment.
Grading
This assessment task contributes 30% to your final unit mark.
Introduction
Modern computer games are complex, immersive and engaging entertainment experiences made possible through software that implements complex relationships between and behaviours within the objects and agents we find in these games. Within SIT255 we are investigating the architectural patterns and algorithms used to create agent-based games software. Within this assignment you will be creating a software framework using Unreal Engine that demonstrates several architectural patterns commonly found in agent-based games. To do this you will apply object-oriented design methodologies presented in classes and learning resources, writing C++ code to create a software product that implements entities and entity management, in the context of an agent-based computer game. You will utilise this framework for Assignment #2 (Game Development Project – Stage 2), when you implement intelligent game agents and gameplay to complete your agent-based game.
By completing this assignment satisfactorily, you will have demonstrated competency to at least minimum standards for the following unit learning outcomes:
[ULO1] Apply knowledge of advanced C++ language features, software patterns and game architectures to create complex game software systems
[ULO2] Employ standard algorithms and data structures to design software solutions to game development problems
Please read the remainder of this document thoroughly and ensure that you understand it completely. In particular, pay attention to due dates. Extensions will not be granted simply because you didn’t allocate enough time to this task, start it early enough or pay attention to the submission deadline. If you are unsure about any element of this assessment task, contact the teaching team.
Assignment Tasks
This assignment comprises two elements: (1) a report documenting your software framework design; and, (2) the software project (Unreal Engine) implementing your framework.
Requirements – Report
Your report should accurately document the design of your software framework and clearly identify the classes that represent entities and entity management, as well as service classes, functions and data structures that manage or enable behaviour and relationships between entities (e.g., messaging systems, visualisation, user input, physics simulation, etc.). You are expected to use industry standard techniques to communicate your design, meaning that your report MUST contain appropriate UML diagrams depicting all classes and their relationships, as well as an Entity-Relationship diagram that details the relationships between types expressed in your framework. You must also include in your report appropriate explanation of the diagrams and design, which should include justification of any specific design choices made. This should also include an explanation of how the functional requirements of the demonstration application (described below) are supported by your framework. Finally, your report should detail any user input capabilities of your demonstration (e.g., a key map).
Your report must include the Assignment Cover Sheet as its first page (group assignment). This can be downloaded from the Assessment menu tab on the page: www.deakin.edu.au/sebe/students (the file “Assignment attachment (electronic submission)”).
Your report must be presented professionally: i.e., no hand-drawn diagrams or charts. It should be neatly formatted and use sections with headings as appropriate. You should use appropriate font choices to ensure readability and professional style. Your report should not contain spelling or grammatical errors and should use professional language, rather than casual or conversational language styles. For assistance with report writing, please visit the following page: www.deakin.edu.au/students/study-support. For more information on your report requirements as to how it will be assessed, please read the Assessment Rubric at the end of this document.
Requirements – Software
You are required to write C++ code that implements an object-oriented software framework for an agent-based game in Unreal Engine. A basic framework supporting rendering and user input is available (see the Resources section) and you may extend this framework, or build your own from scratch. Your framework MUST implement appropriate data structures and algorithms to support game entities and entity management, covering a data-driven lifecycle of entities within your game, as well as supporting their interaction, relationships and behaviours (e.g. movement and control). You will also develop an application (executable program) to achieve the functional requirements of a demonstration of your framework capabilities.
Functional Requirements
Your application software MUST compile and execute, demonstrating the following features:
• Create and initialise at least two different Actor types based on initialisation data read from a data file;
• Spawn and de-spawn Actors within a Scene (level) of the game:
• at least one actor must be spawned at the start of the scene and another actor spawned as a result of an event arising from gameplay;
• at least one actor must be de-spawned as a result of an event arising from gameplay and one actor de-spawned at the end of the scene;
• Display an Actor in a visual representation of the scene, at a location specified dynamically (i.e., not hard coded);
• Demonstrate Actor movement constrained by its environment (i.e., a physical boundary of the Scene, or fixed obstacle – this boundary/obstacle must also be visualised);
• Demonstrate an actor observing and responding to an event (for example, a state change in another actor, or a signal raised by another actor, a scene manager, or a user input)
To meet minimum requirements for this assessment task (with respect to the assessment of the software framework criteria), your software framework must demonstrate the implementation and appropriate application of ALL of the design patterns from the Compulsory Patterns list given below. To improve your chances of higher achievement levels in each criteria (i.e., demonstrate achievement beyond minimum requirements) you should attempt some of the patterns from the Optional Patterns list and demonstrate their application within your framework.
Compulsory Patterns
Game Loop
State Decomposition
Actor (aka: GameObject, Entity)
Scene (aka: Stage)
Object Pool
Factory or Abstract Factory
Optional Patterns
Component
Observer
Event Queue
Command
Type Object
Flyweight
Callback
PIMPL
Code Design
Your code must be robust. That is, it must demonstrate handling of reasonable errors that might arise during program execution (e.g., missing files, files with missing data, memory request failures, container/array index errors, etc.).
Your code must be extensible. That is, the patterns you have implemented should permit you to create and manage any number of new entity types, and to easily add additional features to your game. You should minimise coupling and dependencies between classes, where possible (i.e., favour composition over inheritance)
Your code must be maintainable. That is, it should be well documented, clearly laid out and apply modularisation appropriately (including the use of separate files for class definition and implementation, and the use of filters to organise related classes). Data types, functions and methods should have meaningful names and you should apply a consistent coding style throughout your program.
Submission Components
You will submit three components for this assignment.
Report:
The first is your report as a PDF document and the second is your Unreal Engine project including all code files (.cpp and .h), as well as any additional files required to compile and execute your demo application (including data files, resources files, etc.). If you use the work of others (including code, algorithms, designs, images, ideas, etc.) you MUST cite this usage directly within your code at the point of use. You will NOT be marked on code obtained from external sources (but you can receive marks for your own implementation of algorithms or designs you find elsewhere). Failure to appropriately cite your sources and references will be considered plagiarism and will be dealt with as academic misconduct.
One report submission per group.
Game project:
When submitting your Unreal Engine project, you MUST archive your UE project into a ZIP file including a packaged solution for running on Windows (note here). Note that other compression formats, such as RAR, or 7z, are NOT acceptable, as they cannot be extracted using Deakin’s desktop software image. If we cannot extract it, we cannot mark it. Archives that contain executable files (.exe) or are overly large will not upload correctly to CloudDeakin. It is YOUR responsibility to ensure your submission uploads correctly by the due date and meets all submission requirements.
Your final submission should be your ZIP archive, which should include both your UE project AND your report document. This archive should be suitably named to include your surname (family name) and student ID. It is suggested that you use the following naming format:
SIT255-Assignment1-ID-Surname.zip
You must submit this archive to the Assignment 1 DropBox on the SIT255 CloudDeakin site no later than the deadline given at the top of this document.
One game project submission per group.
Weekly Progress Report (Individual):
Each member of the group will need to submit weekly (end of day Sunday every week leading up to the final deadline and by the final deadline for the last week) a progress report outlining their contribution towards the group project for that week. The format of the report is flexible, but must include evidence of the outlined contribution. Evidence of contribution can include code snippets, screenshots of output, description of tasks, or other forms of evidence deemed appropriate for the contribution. The submission should be in a ZIP file containing the report (in PDF or DOCX format) and/or any associated attachment. The submission should be uploaded in the same Assignment 1 folder on CloudDeakin. Each submission will be named LASTNAME_WEEK#.ZIP, replacing # with each week number accordingly.
Formative feedback will be provided, but no mark will be given. The weekly report will be used to calculate individual marks for the group assignment.
IMPORTANT: A 10% penalty will be applied to any submission that does not meet ALL of the above submission requirements.
Resources
Class notes, recordings and practical activities will likely be of use in completing this assignment. However, alone they will not likely be sufficient to enable you to develop sufficient understanding of the architectural patterns required to be demonstrated in this assignment, nor how to implement these in C++. As such, you should make use of the following resources, as well as carrying out independent study (including finding relevant resources) appropriate to your needs. The suggested starting points for this study are:
Game Programming Patterns by Robert Nystrom (gameprogrammingpatterns.com)
Artificial Intelligence for Games, by Millington and Funge (eBook available from Library)
Design Patterns: elements of reusable object-oriented software, by Gamma, Helm, Johnson, & Vlissides (the “Gang of Four”)
Effective C++, by Scott Myers
More Effective C++, by Scott Myers
Effective Modern C++, by Scott Myers (eBook available from Library)
For those looking for a good reference text on C++, I recommend C++ Primer Plus, by Prata. You will also certainly find useful resources listed in this StackOverflow thread: http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list
Assignment Marking
This assignment is marked out of 100 points and contributes 30% toward your unit grade. 60 points are assigned to the assessment of the software submission and 40 points to the assessment of the report. Each component of the submission will be marked with regards to the requirements stated previously and in accordance with the assessment rubric given below. The level of achievement against the criteria given in this rubric will be used to assign a proportionate number of points available for each component.
Getting Help
Students are expected to complete their submission individually and all submitted work must be the work of the respective student. However, students are encouraged to work together to discuss the assignment tasks and to help each other to develop understanding of the provided code and possible solutions to the given problems.
Additionally, students should seek guidance and advice from their respective practical demonstrator (for on-campus students) or through the CloudDeakin discussion forums (for all students). Weekly Bb Collaborate sessions are also available for discussing the assignment with your peers and the Unit Chair. DO NOT expect the teaching team to tell you how to solve a given problem. It is up to you to do the relevant learning that underpins this assignment and to formulate your solutions given your knowledge.
Deakin University provides support services for students that may assist you to undertake and succeed in this assessment task. If you require support beyond that provided by classes and seminars, please review http://www.deakin.edu.au/students/study-support for further information about these services.
Assessment Rubric
Criteria
Level 1
0-25%
Level 2
25-50%
Level 3
50-75%
Level 4
75-100%
Points Awarded
Functional Requirements
Application Features
No required features are supported, or those supported are extremely limited in functionality, or do not contribute to a demonstration of framework capabilities
Supported features are limited in functionality and relevance to agent-based games
Supported features meet most functional requirements and demonstrate the capabilities provided by the underlying software framework
Supported features meet all requirements and their implementation is cohesive, supporting an agent-based gameplay experience
/10
Software Application
The software application contains significant runtime errors, or does not execute to produce an appropriate game application
The software application executes with minimal runtime errors, but does not adequately demonstrate functional requirements of the user experience
The software application runs with no apparent runtime errors and demonstrates minimum functional requirements of the user experience
The software application contains no discernible errors and demonstrates all function requirements of the user experience in an efficient manner
/10
Software Framework
Data Structure Design and Implementation
Data structure design and usage does not meet the requirements for agent-based games.
Data structure design is appropriate to the application however it is either overly complex or too simplistic to facilitate agent-based games.
Data structure design and usage is appropriate to the application and facilitates implementation of agent-based games.
The data structure design and usage represents best practice and facilitates implementation of robust, complex agent-based games.
/10
Software Architecture
The demonstrated framework contains significant gaps or omissions, or is overly simplistic and does not adequately support agent-based games.
The demonstrated framework is inefficient or overly convoluted, however it does support some features of agent-based games.
The demonstrated framework contains elements that combine to support an agent-based game
The demonstrated framework conveys a thorough understanding of the interplay of specific design patterns to create agent-based games
/10
Code Design
Code is not robust, extensible or maintainable
Some attempt has been made to create robust, extensible and maintainable code, however there are significant gaps or omissions.
Code is robust to common errors, is documented and permits extension, although some
Code design applies best practice to handling errors, extensibility and maintainability.
/10
Coding Style
Code layout is poor and documentation is omitted or limited. Readability and understanding is severely hindered.
Code layout and style affects readability and maintainability. Documentation and comments do not adequately support an understanding of the code by the reader.
Code layout and style is neat and appropriate for the given program complexity. Documentation and comments are adequate.
Code layout and style, including documentation, reflects best practice and meets professional standards.
/10
Design Report
Framework Design
Design diagrams are missing or omitted for the supported features
Design diagrams are provided for supported features, but designs are limited in scope and depth and do not demonstrate a clear understanding of the feature requirements
Appropriate design diagrams are presented and they convey an understanding of architectural patterns and requirements.
All appropriate design diagrams are presented and they convey a thorough and clear understanding of the architectural patterns and feature requirements of the framework.
/20
Feature Discussion
Report omits discussion of most content elements required, or contains very limited or relevant information and analysis
Report represents all required elements, but is limited in its scope and depth of discussion of the relevant features
Report contains all required elements and demonstrates understanding of the software features presented. Limited or no understanding of implications of design choices is shown
Report demonstrates a clear understanding of the software features presented, as well as implications of design choices
/10
Format and Presentation (Including diagrams)
Report is well below professional standards for formatting and presentation
Report is below accepted professional standards
Report meets accepted professional standards
Report exceeds accepted professional standards
/10
Overall Assignment Score
Level 1 0-25 marks
Level 2 25-49 marks
Level 3 50-74 or more
Level 4 74 – 100 marks
Well below minimum standards
Below minimum standards
Meets minimum standards
Exceed minimum standards
/100