IMGD 4000

The goal of this project is to get up to speed doing Unreal Engine 4 (UE4) development, including familiarizing with the editor, adding code (both Blueprints and C++), importing art assets, and setting up source control.

First, you will setup your UE4 development environment. Then, you will familiarize yourself with the UE4 editor through a brief tutorial. After that, work through a tutorial that has you make the beginnings of a first person shooter (FPS) game using UE4. Lastly, you will show your understandings of UE4 basics by extending the FPS tutorial with custom code, a "10% extension".

Doing the above will help better understand the UE4 game engine by developing a game from a game programmer's perspective, providing the foundational knowledge needed for building your own game from scratch in UE4.

You will work alone for this project. This will ensure you have the development skills needed for subsequent projects, even if your tasks when you make your game in a team are partitioned. While you can discuss the project with other students and even help each other debug code, but you must write all code yourself.

WARNING! A state-of-the-art game development tool like Unreal Engine is always being improved, which means there will often be differences, large and small, between the latest available official documentation (not to mention information you find in user forums) and the current release you are using (e.g., UE4.15). Navigating such issues is an unavoidable part of professional game development. Use the online class forum at InstructAssist to get help and share relevant information with your classmates, TA's and faculty.

Setup

To setup your UE4 development environment, do the following steps. If using one of the machines in the IMGD the Zoo labs, steps #2 and #3 below are already done.

1. Create an Epic Games account
2. Download Unreal Engine Version 4.15 for Windows (to avoid compatibility problems, Windows is the only platform supported for this course)
3. Install Microsoft Visual Studio 2015 Update 3
4. Setup source control (git or svn)

About Blueprints

However, don't start out by thinking that it is always better to use Blueprints. This can lead to slower development time and harder to understand implementations. In fact, using only C++ code would be fine, except for the fact that this assignment is an occasion to get some experience with Blueprints also.

Some further hints:

• Good structure, good variable names, and good comments apply to Blueprints just as much as to textual code.
• A common practice is to use C++ for abstract base classes and Blueprints for instantiated subclasses.
• There are a few specialized features of UE4 (such as timelines) that can only be conveniently used via Blueprints.
• Many tutorials only provide implementation details in Blueprint.
• Learning how each Blueprint node relates to a C++ function is also useful. To create custom Blueprint nodes from C++ code, see wiki.

Editor Quick Start

Go through the Unreal Level Designer Quick Start Guide, which covers how to:

• navigate viewports
• create a new level
• place and edit actors in levels
• build and run levels

Programming Quick Start

Go through the Unreal Programming Quick Start Guide:

"This guide shows you how to create a new Unreal Engine project, add a new C++ class to it, compile the project, and add an instance of a new class to your level."

First Person Shooter Tutorial

Go through the First Person Shooter C++ Tutorial, which covers how to:

• set up a project
• implement a character
• implement a projectile
• animate a character

Note there has been a change in the signature of the OnHit method used in Section 3.4. The signature in UE4.15 is:

void OnHit (UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)

Visual Studio Hint: Enabling precompiled headers in Visual Studio will noticeably speed up compilation. However, please also read about some cautions to be aware of when using precompiled headers.

Extend FPS Tutorial Game

This means adding additional code (C++ or Blueprints) to extend the game functionality in some meaningful way by 10%. The specific extensions are up to you. Some hints for extending the FPS game are given below, but are only these suggestions---the actual extension is up to you. You will indicate what you have done with brief documentation when you turn in the assignment.

Note that "10%" is rather subjective. Do not concentrate on whether you have added 10%, just use this homework to learn as much as you can from the tutorials and documentation. It is very hard (although not impossible) to do less than 10% if you just spend some time experimenting.

If you are having trouble getting started with your "10%" modification, here is some advice:

1. Save a copy of your game in case you "break" something and need start re-start your modifications fresh. An easy way to do this is to make a copy your UE4 project directory. Another is to use source control, commit your working version, and, if you break something, just delete your current version and check it out fresh.
2. Revisit parts of the tutorial to refresh how the game is built (the first time through, you might have just been "plugging it in" without reflecting upon how it works).
3. Think about basic features from games you know and see if any of those fit in with your understanding of coding in UE4.
4. For technical unknowns, see if any of the resources provided for this class, or from a search through the Unreal Engine Documentation can help.

Some specific suggestions for extensions to the FPS tutorial:

• Add a way for the player to lose energy (e.g., stamina from running or jumping or just standing) and energy packs the player can pick up to recharge.

  Implementation note: Create a function inside of the player that allows adding energy. If the player "hits" the energy pack, add to the player's energy. Just have the energy displayed as an on screen debug message.

• Have button to pick up objects (and hold them while moving).

  Implementation note: Create a function in your C++ Character class to do a line trace on a key press (e.g., 'E'). If the line trace hits an object you want to move (such as a cube), attach the held object to your character. You can do this by storing a pointer to the object and updating its position every time your character ticks.

• Implement a jetpack (holding a button moves the player up, release lets gravity take effect).

  Implementation note: Create two functions in your Character class, one for a button pressed and one for a button released. In the button pressed event, calculate a maximum height for the player's thrust. Then, in your character's tick function, have the player linearly interpolate to that height. If the player has gotten close to that height, turn the "jetpack" off. Also, when the player releases the jetpack key, turn it off.

• Create an enemy (enemy doesn't need AI necessarily, could just shoot a projectile forward at a constant rate) and health for player.

  Implementation note: Create a new projectile class (a fairly simple class, with a static mesh for a visual representation in world and a boolean for whether it has been fired or not). Create a new pawn class for an enemy (again, fairly simple). For the enemy, the model can just be a cube. To control the firing rate (e.g., one bullet every 5 seconds) create a new variable to keep track of the total elapsed time from the last fired projectile. If the elapsed time exceeds 5 seconds, reset it, spawn a new projectile, and tell the projectile that it has been fired. In the projectile tick function, update forward velocity accordingly every tick. Create a delegate function for hit events in the projectile class. Create a function inside of the player that allows deducting health. If the projectile hits the player, deduct from the player's health. Just have the health displayed as an on screen debug message.

• Create an enemy with AI.

  Implementation note: as for the "create an enemy" suggestion above, but the enemy should react to bullets in some way when it detects a collision (e.g., ragdoll, shatter, lose health). Make the enemy move based on how the AI Controller tells it to move. Brownie points if you use a navmesh.

• Make a "sticky" object to which all projectiles stick (sort of a Katamari effect).

  Implementation note: Create a new actor class for a sticky object. Within this class, create a new delegate for a hit event. Inside, check the type of actor this sticky object has collided with, and if it is your character, attach the sticky object to your character.

• Create ammo packs. Make the player have a limited amount of ammo. Spawn ammo packs dynamically during the game to replenish ammo. The packs can respawn at specific points or spawn randomly within the bounds of a collider. The player will look at the pack and press a button to pick it up. Display the ammo supply on the screen.

• Minimap/overhead view. Use a render texture and a second camera to show an overhead view of the game world in one corner of the screen. Make a more complicated map (dig through the default assets or place some cubes as walls, etc.) so it looks interesting.

• Trigger audio. From your C++ code, trigger a sound to play when the player fires, when the bullet collides with another object, when the player walks and jumps, and any other effects you want to add. You can add an audio component to the Blueprint, but trigger it from your class in C++, not the event graph. Mess around with the attenuation radius, reverb, filters and other features to get a feel for what the engine has to offer when you go to make your term project. The quality of the audio itself has no impact on your grade.

• Add a second weapon, one that fires projectiles with different properties (e.g., faster bullets). Provide some way for the player to switch between weapons.

• Add targets that spawn automatically, if randomly, and provide points. These can be inanimate objects, but should be destructible.

  Implementation note: just have the points displayed as an on screen debug message.

Some of the above you may need to combine to get to 10%, depending upon the complexity of your implementation. This is admittedly vague, but the goal is for you do do enough to be competent in UE4.

Return to the IMGD 4000 Home Page

Send all questions to the staff mailing list (imgd4000-staff at cs.wpi.edu).