代做COMP3016、代写C++设计编程

日期：2024-01-08 08:56

Coursework 2023-24 MODULE CODE: COMP3016

COMP3016 IMMERSIVE

GAME TECHNOLOGIES

20 CREDIT MODULE/100% COURSEWORK SUBMISSION

MODULE TUTOR: Sebastian Outram

MODULE AIMS:

- To gain and apply programming concepts and techniques that are used in

demanding real-world industrial settings, e.g. programming in an unmanaged

environment.

- To gain experience in software design and engineering working from concept

to finished prototype.

- To gain experience with different programming languages and environments.

- To establish the mathematical concepts required for the development and

programming of high-performance real-time graphics, such as vector and

matrix maths.

- To provide experience using a graphical API such as OPENGL.

ASSESSED LEARNING OUTCOMES:

1. Apply core programming principles (including mathematical concepts within

a high-performance real-time environment such as graphical

programming/game-engine programming.

2. Design, conceptualise and implement a working prototype with clearly

defined features.

3. Articulate method of approach and rational for solution.

OVERVIEW

This module introduces concepts & programming techniques for working with un‐managed code, i.e.,

using graphical APIs like OpenGL through C++. It provides industry relevant skills for domains such as

high-performance real‐time graphics or closer‐to‐the‐metal programming. The module uses a bottom‐

up approach; it is not about the use of game engines and high‐level prototyping tools. Students will

gain highly transferrable software engineering skills.

Lectures, Seminars and Workshops are integrated into the module to introduce concepts and deepen

the understanding of topics as well as to guide the project work.

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 2 of 9

Coursework elements include an Individual research presentation to inform the development of a

prototype and individual projects with supporting documentation.

100% Coursework Comprising Two Individual Elements

Assignment A: Text-based Game 30% Working individually on a text-based game using OOP design

paradigms and programming skills in C++.

Assignment B: Individual Software Project 70% Working individually on a project, find, defend &

agree a topic with staff. Research and produce a short industry standard portfolio piece (polished

GitHub page) and a video presenting your product/research.

MODULE DELIVERY

Delivery format: Weekly 2hr lecture Thursday from 1pm – 3 pm

Weekly 2hr lab Thursday 11am ‐ 1 pm

Delivery staff: Ji-Jian Chin – ji-jian.chin@plymouth.ac.uk

Sebastian Outram – sebastian@outram.org

Duration: 12 weeks Semester 1

Assessment Offences:

For this assignment you may be using information from differing sources:

? Books, journal articles

? Course/module materials

? Websites

? Existing Open-Source Projects

It is very important for you to note that this assignment is an individual effort. It should make the

contributions from the student and the use of external resources, or an initial start base clear.

Thus, do not simply copy existing sources, i.e., other students work, interspersed with a few lines of

code or words of your own. This is paraphrasing, and it is not encouraged, it is not likely to get you a

good mark and, in some cases, it could be seen as plagiarism. In a similar vein, do not simply copy

material from elsewhere without citing it properly. For more information on how to write texts,

reference source material and plagiarism in general, see:

https://www.plymouth.ac.uk/student-life/your-studies/essential-information/regulations/plagiarism

If you have any doubt as to what constitutes ‘an individual effort and in your own words’ then either

see your student handbook or see me.

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 3 of 9

Coursework Part C1 – Console-based Game using C++ 30%

DESCRIPTION

This is an individual assignment. It will help us to estimate where you currently are in terms of

capabilities.

The ultimate aim is for you to demonstrate that you can understand writing unmanaged code in the

object-oriented paradigm, interacting with different data types and the underlying code for moving

things to and from memory, thus handling some of the complex aspects needed for writing game engine

code, at the same time having a hand at some creativity to develop your own flavour of a text-based

game in the terminal console.

For this assessment, you should use modern C++ without making use of C primitives and procedures

as much as possible (e.g. using string over char*).

Your source code should compile without errors with a working executable file that runs on its own,

accompanied by a suitable UML design document and a simple instruction manual on how it works.

Other than that, the other requirements should be that it is fun and accounts for quality e.g. passes as

many test cases as possible, difficult to crash with improper inputs).

To complement the development, you should write a brief introduction and description which details the

setup, usage and how the code fits together to be used in other cases, including a proper UML design

diagram for your game. For the video you may use this to walk us through your game. As part of the

video, you need to show how the software runs and compiles.

DLE DELIVERABLES

A single zip named “CPPGame.zip” containing:

o An executable version of the game which does not rely on VS. o Include any

resources such as extra assets that your project needs.

o A brief write-up in markdown format (*.md), describing:

o Visual Studio and Operating System version you used to test/write

the code locally?

o How does it play?

o UML design diagram

o Exception handling and test cases

o Further details that help us to understand how your prototype works.

o A link to the Video (unlisted YouTube)

o A link to the game git repository

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 4 of 9

Deadlines:

Part Description Deadline Percentage

C1

Standalone CPP Game:

Demonstrate expertise in

working with unmanaged

code: C++

30%

Console-based game: Implement a game in C++ and

upload to your git repository, then share the link in the

readme. Your game needs to adhere to OOP concepts and

additionally be able to load file content during execution. Do

enough testing that it doesn’t crash upon unexpected input

and document these tests. Lastly, add in as many features

as you can to make it story rich and/or fun!

21

st November

Demo Video: Provide a UML and code walkthrough,

including functional playthrough in a short 10min video.

21

st November

Marking Rubric

Category Fail > 40% > 60% > 80%

CPP Game

(30%)

No submission

on classroom

for

Assessment.

Software does

not compile.

GitHub not

updated.

Plagiarising an

existing project

No Video

Provided.

Game performs as

described in

readme, without

much fun

factor/immersive

story included.

No Object-Oriented

design practised.

Game data loaded

from simple text

files.

Executable file

works on most

cases without

crashing.

Understandable

video with simple

writeup.

Game loads multiple

files with increased

format complexity

Game crashes

minimally with

proper documented

exception handling.

Some ObjectOriented design

practised.

Average fun factor/

mediocre story

presented.

A tidy

repository/DLE

submission without

additional redundant

files.

Comprehensive

readme report and

video walkthrough

Addition of complex

multimedia files and

playback to augment

gameplay.

New experiences and

augmented interactivity

provided with

integration with AI at

every new game

iteration.

Highly efficient OOP

design

High fun factor/

immersive story

Demonstration of high

programming skills in

development

Additional researchproven approaches with

proper references in

instructions.

Please refer to all the lecture content & further study resources on the DLE. A more

comprehensive rubrics will be uploaded on scoring system.

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 5 of 9

Coursework Part C2 – Individual Topic: The Interactive Software Prototype 70%

DESCRIPTION

This is an individual piece of work. "Create something which does something in OpenGL”.

The actual project is negotiated based on the submitted proposal but has two strict additional

requirements:

? Key requirement A for this part is to develop your interactive software in C++

incorporating OpenGL.

? Key requirement B for the assessment is to have a meaningful original contribution of at

least two features to your project.

You must create a working prototype using OpenGL4.X which allows for real-time user interaction.

For the coursework you are required to use an unmanaged language (C++) and are not allowed to

use existing game engines such as Unity3D, UE, Godot or Ogre.

Please see the end of this document regarding the hand-in date, as well as the section on the

demonstration, which is mandatory, not desirable.

As a first step, start by filling in a proposal form. The proposal is giving you formative feedback; it is

intended to concentrate the mind and required for getting your project approved. It is also helpful for

us to know what you intend to do before you get too far into the production process. (Not having

accepted your project will cap the marks.)

You are also tasked with creating another GitHub page illustrating, discussing and presenting your

product as a portfolio piece.

Topics:

Your project must use OpenGL4 (which means you cannot use the fixed function pipeline, so the

software requires at least a fragment and vertex shader) and an unmanaged language as the basis of

your work. You may use other higher-level tools for assistance – for instance you may use

“Photoshop” to produce the textures files, and 3D modelling tools such as “3D Max”, “Blender” to

produce meshes, and ChatGPT for sample templates of code (but be careful do not lift the code in its

entirety!). And you can also use such resources from any legal source you like, but you must mention

it on your GitHub project page.

This is a COMP module, not a 3D modelling module so basic models and textures are fine. You can

also use other classes or frameworks you like (so long as your framework is not of such a high level

that it turns OpenGL into something completely different). See the rules of engagement.

We have done no more than scratch the surface of OpenGL. Almost all the material we have covered

is related to 3D graphics, but there is nothing that says that your assignment must be in 3D space.

You can use this assignment to explore parts of OpenGL including 3D space, sound, networking,

media player etc. We do not expect anybody to produce a product which includes all these elements!

Following suggestions for your prototype topics are by no means exhaustive:

? Build a model loader and renderer that contains a dynamic, moving light source, a way to

move around the model based on user input, utilizes a simple shader and colour rendering.

? An artificial life simulation. Examples might be:

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 6 of 9

o A “boids” simulation (see here). This is probably too easy on its own.

o A variation on the (Artificial Life simulation) herbivores/predators theme (the herbivores

eat grass, which grows when you make it rain, the predators eat the herbivores. Both

reproduce when they meet another of their own kind).

o A game. Mini Counterstrike (CS was written in C++)?

? Experiment with different user interfaces virtually or build and program your own. For example,

using one or multiple phones as input devices or an Arduino/RPi with some sensors.

? Use procedural content generation to either create levels and then play them or dynamically

generate terrain/forests/caves while the player is moving.

? You could also use PCG to generate objects the player can use to interact with, these objects

can also be sounds.

? You can also write and experiment with different shaders and analyse their performance over

different surfaces and when combined but this is not mandatory.

Software Engineering Issues

In addition, you should demonstrate that you have considered some of the more mainstream

computing issues discussed in this module. You are also to work using TDD for making sure the file

loading works as anticipated. Performance (speed) is often the goal in graphics, but that is not always

compatible with conventional good practice in software engineering, such as OO, modularity,

encapsulation etc. You should demonstrate that you have considered this, and you should tell me

what compromises you have made (if any) to reconcile issues of performance against good software

engineering practice.

We would also like you to consider some more advanced performance optimisations, such as the

culling of non-visible objects.

Or, alternatively, if you have sacrificed some performance for the sake of a purer and more

general computing solution, say what you have done and why. Put this in your brief report.

Rules of Engagement

You may use any algorithm from any sources (i.e. “gamedev”, Nvidia) or program code which you can

adapt. But you must tell us what you started with and what you have done to it. If this is not done you

risk failing the assignment.

You can also use a wider range of 3rd party libraries but they must be approved in the pitch.

However, you are not to use any given game engine such as Unity3D, UE, Godot or Ogre. You

could also use a physics library such as a Bullet or PhysX. Be very careful about using 3rd party

libraries and frameworks that abstract you so far away that they make it look as if you are

programming in something completely different. If in doubt, ask!

There must also be a substantial contribution from yourself so plugging code together to create

something is not enough. For example, just taking an existing example demo and changing the

meshes is not enough. You should also integrate a Poly, glTF file reader to load data into your

software. Think carefully about how you incorporate it, though. And finally, during demonstration we

might ask you questions about the program code you submitted.

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 7 of 9

DELIVERABLES

? Create a GitHub repository from the classroom invite (use the provided link) for

your submission which is documented with a markdown file explaining:

? How does the user interact with your executable? How do you open and control

the software you wrote (exe file)?

? How does the program code work? How do the classes and functions fit together

and who does what?

? What makes your program special and how does it compare to similar things?

(Where did you get the idea from? What did you start with? How did you make

yours unique? Did you start with a given project?)

? Include a link to a video report that details the above but also goes into more detail

on:

? The video should be 10 minutes (resolution 1080p).

? Anything else which will help us understand how your prototype works.

? What inspired your prototype?

? What are similar software pieces?

? Are there any software engineering issues, such as the trade-off between

performance and good practice?

? A (brief) evaluation of what you think you have achieved, and what (if

anything) you would do differently, knowing what you now know. Feel free

to blow your trumpet!

? Create a single “.zip” archive (max 150MB) containing a pdf of the GitHub

readme/report, the executable and required libraries to run it. Detail how to run

the executable (put that in the write-up below). Don’t forget to include any other

resources required; meshes, sounds etc. Submit your archive via the DLE

electronic submission system. And don’t forget to remove any unneeded files and

folders. Compress any additional resources or assets to stay within the

space limit.

o Also include in your archive a pdf of your markdown documentation as report detailing

your prototype.

o The report should address:

? How does the user interact with your executable? How do you open and control

the software you wrote (exe file)?

? How does the program code work? How do the classes and functions fit together

and who does what?

? What makes your program special and how does it compare to similar things?

(Where did you get the idea from? What did you start with? How did you make

yours unique? Did you start with a given project?)

? A Link to the video

Please address the “what you started with” point, as without this information it may not be possible

to give your work a grade.

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 8 of 9

Part Description Deadline Percenta

ge

C2 Individual project: Implement an interactive software prototype that

builds upon the content from the lectures and demonstrates the

required skills for game engine development. ALO2.

Document and defend your design decisions through your portfolio

github page and in a 15min pitch and walkthrough video. ALO3.

70%

Interactive Prototype Pitch: Name your project, describe the concept

and how you want to achieve it in the given time.

Thursday,

2 November

Individual Project: Upload your Project to the DLE and have the final

version on the classroom including the report and all required files.

Monday,

8

th of

January

Video Release: Upload and share the walkthrough and pitch video to

YouTube or OneDrive. (The link should be on the GitHub page as

well)

Monday,

8

th of

January

Demo Session: Walk us through your prototype and answer questions

regarding its programming; Get Verbal Feedback regarding your

performance

TBC

between 8th

and 16th

January

Coursework 2023-24 MODULE CODE: COMP3016

P a g e 9 of 9

Marking Rubric

Fail > 40% > 50% > 60% >70%

Software does

not compile or

execute.

OpenGL not

used in project.

Readme

(Report) is

missing/not

updated.

Software is

solely based on

existing code

without clear

distinction.

GitHub not

updated.

No video was

provided or not

linked in

ReadMe(github).

No Viva took

place.

Software

executes &

contains

minor

individual

contribution.

Software

design

involves

little

originality.

The video

contains the

required

elements:

explanation

of the basic

structure of

the

program.

Infrequent

GitHub

commits.

Simple

answers

during Viva.

Software

provides

several simple

features with

minor issues

such as

crashes.

The software is

non-interactive.

Software

design ideas

are original.

The video

gives a basic

summary of

software as

well as issues

with it.

The GitHub

page is concise

and explains

setup and

structure of the

program.

Software pitch

receives

approval.

Software

demonstrates quality

implementation work

with few bugs and

well-managed

exceptions.

A strong design is

visible with multiple

original contributions.

Software provides

some basic user

interaction.

The software utilises

external multimedia

files during runtime.

The video contains

evaluation of project,

code walkthrough and

domain analysis

(similar projects).

The GitHub page uses

images and videos

and present the

project well as a

portfolio piece.

Regular commits

visible on GitHub.

Software

demonstrates highly

skilled programming

techniques.

The software allows

advanced user

interaction or uses

other advanced

features.

Model files can be

loaded from multiple

formats seamlessly.

A UI framework is

used meaningfully.

The prototype is

polished and

including manual

ready for end users.

The Demo video

shows strong project

contribution, a good

understanding of

memory

management, used

libraries and code

integration.

Arguments and

evaluation of the

topic and the

prototype are sound.

Please refer to all the lecture content & further study resources on the DLE. A more

comprehensive rubrics will be uploaded on scoring system.

Grades

A total of 40% is needed for passing the module. When re‐taking the assessment, no score from a

previous assessment is taken forward. Thus, the entire coursework needs to be re‐done.