top of page

Undead Onslaught

In this project, I set out to learn Unreal Engine by remaking the university group project S.M.G.V.B.S.S.H.F.. The goal was to deepen my understanding of Unreal's tools and workflows while recreating and improving upon the original game. This involved exploring Unreal Engine's advanced features to enhance gameplay and visual fidelity.

Role

Lead Developer

team size 

1 person

development time

on-going

Game Engine

Unity

Genre

First Person Shooter

Technologies used

image.png

Unreal Engine 5

image.png

C#

image.png

GIT

image.png

Photoshop

image.png

Trello

Theme/Story 

The player awakens in an abandoned facility, armed with only a gun. As time progresses, they discover that the undead have begun to overrun the facility, relentlessly hunting them down. Forced to fight off the advancing hordes, the player starts piecing together clues about the origins of the outbreak, uncovering why the undead have risen and searching for a way to escape the desolate facility.

Design Process

In developing Undead Onslaught, I followed a five-step design process, which I will elaborate on throughout this portfolio piece. Each phase was crucial in shaping the game's mechanics, systems, and overall player experience.

1

DESGIN DOCUMENT/
research on unreal

prototyping

rought blockout/coding

2

3

refinement of code and level design 

4

passover and feedback

5

Design Document

The first step in my design process was creating the Game Design Document (GDD), where I organized all the initial ideas for Undead Onslaught and planned out the key features to be included. In this document, I outlined the core gameplay mechanics, establishing a clear vision for how the game would function and what players could expect in terms of experience and interaction. This foundational step helped guide the subsequent phases of development. 
I dedicated time to learning Unreal Engine, focusing on its capabilities for enhancing AI behavior, player control, and node-based coding. Additionally, I explored the implementation of a wave-based system, leveraging Unreal’s tools to create dynamic and engaging gameplay mechanics.

Core Game Pillars

  • A wave based system 

  • Responsive AI

  • ​ruined world environment

Gameplay Breakdown

In Undead Onslaught, players spawn into a map with basic equipment and must explore to familiarize themselves with the environment and unlock key features like weapon wall buys, perks, and the weapon-upgrade mashion. Waves of increasingly difficult zombies spawn, challenging players to earn points by defeating enemies, which can be spent on weapons, ammo, perks, or unlocking new areas. Upgrading gear, such as Pack-a-Punching weapons or acquiring special items like monkey bombs, is crucial for survival. Success requires strategic resource management, effective teamwork (in multiplayer), and careful decision-making to adapt to the escalating difficulty.

Explore abandoned facility

getting ready for the next wave

fighting  enemy's

Second-to-Second gameplay :

  • Engage in fast-paced combat by aiming, shooting, and manoeuvring around zombies.

  • Monitor immediate surroundings to avoid getting cornered or overwhelmed.

  • Gather dropped power-ups (e.g., Max Ammo, Insta-Kill, Nuke) for tactical advantages.

  • Repair barricades for extra points and to slow zombie spawns.

Minute-to-Minute gameplay :

  • Defend against waves of zombies while managing limited resources like ammo and points.

  • Decide where to spend earned points: buy weapons, open new areas, or activate perks.

  • Strategically position yourself to maximize survival and point efficiency for the next wave.

Hour-to-Hour gameplay :

  • Progress through increasingly challenging waves, unlocking new map areas and features as the game escalates.

  • Upgrade weapons via the upgrade machine and acquire perks to boost survivability and damage.

  • Adapt to new threats, such as special zombies or mini-bosses, while balancing resource consumption and survival strategy.

Code Example

BP_FirstPersonCharacter BluePrint Overview

Key Features

  1. Sprint Input

  2. ​Can Sprint Condition

  3. Sprinting State Management

  4. Custom Event: Restore Stamina

  5. Timeline: Set_Restore_Stamina_TL

  6. Stamina Restoring State​

Sprinting logic

  1. Sprint Input:

    • Node: InputAction Sprint

      • When the sprint key is pressed, the logic checks whether the character can sprint by evaluating specific conditions.

      • When released, it triggers the Stop Sprinting custom event to end the sprint.

  2. Can Sprint Condition

    • Branch Node: Determines whether the character can sprint based on various factors (e.g., stamina, standing state).

    • Conditions include

      • The character must not be crouching (likely checked via the Standing/Crouch logic).

      • The player must be in a valid state to initiate sprinting.

  3. Sprinting State Management

    • Set Sprinting: Sets a boolean variable (Sprinting) to true when sprinting begins and false when it ends.

    • This state is used to enable or disable related systems (e.g., adjusting movement speed).

  4. Stopping Actions

    • Certain actions are disabled when sprinting:

      • ADS (Aim Down Sights): Likely prevents aiming while sprinting.

      • Firing: Sprinting might block weapon firing for gameplay balance.

  5. Walking Speed Adjustment

    • The sprint logic adjusts the character’s walking speed:

      • Set Walking Speed: Increases or decreases movement speed depending on whether sprinting is active.

Restore Stamina logic

  1. Custom Event: Restore Stamina

    • This event is triggered to begin replenishing stamina after sprinting ends.

  2. Do Once Node

    • Ensures that the stamina restoration logic runs only once per trigger, preventing multiple instances of the stamina restoration process.

  3. Timeline: Set_Restore_Stamina_TL

    • A Timeline node is used to gradually restore stamina over time.

    • The Update pin continuously updates the stamina variable.

  4. Stamina Restoring State

    • Set Stamina Restoring: Sets a boolean to indicate that stamina is currently being replenished.

    • This prevents actions like resuming sprinting while the restoration process is ongoing.

Key Features

  1. Input Handling

  2. Stop Sprinting Dependency

  3. Ammo and Reload Check

  4. Switch on FireType

  5. Realism and Flow

  6. Timer Management

Fire Mechanics Logic:

  1. Input Handling:

    • Node: InputAction Fire

      • Triggers when the fire button is pressed.

      • Linked to conditional checks to determine whether firing can proceed.

  2. Stop Sprinting Dependency:

    • The Stop Sprinting node ensures that firing halts any ongoing sprinting.

    • This design makes sprinting and firing mutually exclusive actions, adding gameplay realism.

  3. Ammo and Reload Check:

    • A comparison checks whether the current ammo clip (Ammo Clip Current) is greater than 0.

    • The NOT condition ensures that firing is disallowed if the weapon is reloading or changing state.

  4. Switch on FireType:

    • Handles different firing modes:

      • Single Fire: Likely executes one shot and stops.

      • Automatic: Initiates a looped firing sequence, likely tied to the Auto Fire Timer.

  5. Realism and Flow: 

    • Prevents firing while sprinting, reloading, or if no ammo is available.

    • Automatically handles transitions between fire modes (single/automatic).

  6.  Timer Management:​​

    • Uses a Timer Handle (Auto Fire Timer) to control the timing of automatic fire.

    • A branch checks if the handle is valid:

      • If valid, the Clear and Invalidate Timer by Handle node stops the timer, halting automatic firing.

bottom of page