Week 2: Zombies, Zombies & More Zombies

After setting up the basis of the core player mechanics last week, I moved my efforts onto the next most important aspect. ZOMBIES!!!

Before the project started I had originally planned to use a zombie model from Adobe Mixamo which would give me a fully rigged character as well as the entire bank of animations that Mixamo has to offer. I have used Mixamo in the past so I would have been familiar with the workflow of exporting them from the website and getting the characters working in Unreal Engine. My only caveat with this is that the zombie models on Mixamo didn't really fit the aesthetic that I was planning for and there isn't much of a selection to choose from with their zombie models. This led me to look for other options. I could always come back to Mixamo as a fail-safe if I couldn't find something that I was more happy with

While looking around for different models and animations I managed to snag a massive deal during a sales period on the Unreal Engine Marketplace on some amazing zombie models and animations which I felt fit my project perfectly.

Decayed Zombies Pack:

This pack contains 5 different zombie models that can all be customized. Each model also offers segmented body parts which will allow for dismemberment which is certainly something that I will look into using to add some extra 'Juice' to the models. Who doesn't love exploding heads?

Zombie Basic - MoCap Pack

This pack contains over 200 different animation sequences which have all been motion-captured and also fit the models wonderfully. This will allow me to add lots of variety to the zombies that I otherwise wouldn't have been able to. While having the extra animations won't add a great deal to the actual gameplay it will allow me to add a lot of 'juice' and substance to the enemies which will add to the overall polish in the end.

Now that I've covered the core assets that I'm using for the zombies, what have I spent my time with this week?

My tasks for this week were to set up a basic zombie AI so I could start testing the rest of the mechanics with them. My other major task was to set up the game rules and framework because without that then the game doesn't really work.

So I set out with setting up the zombie character first. I started by setting up a new character class in Unreal as well as a new AI controller to possess the character. I then set up a new blueprint interface specifically for the zombie characters. I have used this to create references to itself as well as the player character. I use this method to avoid using cast nodes which in the end, results in more efficient code. I also went through a similar process to the player character's animations. I set up a new animation blueprint with a new state machine to handle the locomotion animations. I won't go through the process again as it's pretty much the same as the player character.

With the core classes set up, I moved on to setting up a base AI that I could use for prototyping. The core behavior for the zombies is for them to chase the player and then attack them once they are within range of the player. I started by setting up a behavior tree that works similarly to a state machine. It will execute different branches of the tree based on the desired logic. A behavior tree needs a blackboard to operate correctly. The blackboard is essentially the 'brain' of the behavior tree and will store all of the variables that the tree uses. My first goal was to get the zombie to chase the player which is a relatively simple task.

I then created a 2nd task which would be used to attack the player. The task simply plays the animation of the attack and the actual attacking logic will be handled elsewhere.

With the tasks ready to use I needed to add them to the behavior tree. I started by using a selector node which is pretty much the same as an 'if' statement. Behavior trees run from left to right so it will hit the chase attack first. I've added a decorator to both tasks which will check if a bool value is true or false from the blackboard. If it's false then it will continue to run the chase task however if it's true then it will run the attack task.

I am changing the bool of 'CanAttack' based on the distance of the pawn to the player character. I am not 100% sure if this is the most effective way of running this logic for the desired effect due to it running every frame however it provides the correct gameplay effect so I'm happy with it for now.

At this stage, I now have a zombie character that will chase the player and play an attack animation when it gets to a certain distance from the player, however, the zombie doesn't actually do anything to the player at this stage. I left the logic for the zombie here for now and came back to it later on in the week which I will detail later on.

My next step is arguably one of the most important, setting up the game rules and framework. This will structure the way that the game plays so I need to address this early on to allow for future development. This meant that I needed to set up the round-based framework and handle the spawning of zombies within that framework. I started by setting up some variables with functions to handle those variables inside of the gamemode. I also set up a new actor which would be used as a spawn point.

Basic high-level overview of expected outcome

The main reason for having a queue system linked to the spawning system is to limit the amount of zombies that can be spawned at any single time. This will help to reduce any performance issues by not overloading the engine with too many AI characters at once. Also from a design point of view, it makes more sense to have a maximum limit to the amount of zombies at any 1 time.

This function will set the integer for the map variable 'ZM pool' which basically tells the game how many zombies to spawn. This function is called as part of the start new round function to tell the game at the start of every new round, how many zombies will need to be spawned. The integer that gets added to the pool is based on an algorithm that allows for the amount of zombies to scale with the round number.

Once I had these functions set up as well as some others in the background all hooked up together it started all fall into place.

The way that the game handles the spawning is that it would just pick a random spawner actor within the level and if no zombie was spawning on that index in the spawning array then it will spawn 1. With this setup, it would prove to be an issue in a large-scale environment by causing zombies to spawn in areas where the player currently isn't. I set up a way to activate and deactivate specific spawners by removing them from the available array of spawners. This system needs more testing however it's working at the current scale within the test level so at this stage I went to finish off the zombie attack but before that, I needed a health system.

I opted to create a new blueprint component that would handle the health. By using a component it allows me to add it to any actor to give it a health system with the click of a button. This means that I only need to create a single health system and then it can be used by anything in the game. I used the 'On Take Any Damage' event to allow the system to work with the built-in unreal engine damage system which makes it really simple to apply damage to something, in this case the health component.

With the component setup, I added a bit more logic to the game framework to change the health of the zombies based on the current round. This gives the game some simple scaling depending on how long the player can survive. In the same vain i also added a new function to increase the run speed based on the current round.

Now that actors can have health I finished off the zombie attack logic. I added a small collision box to the hand that will then overlap the player collision for the hit detection. To make sure that the zombie is only hitting the player during the correct timing of the animation, I used an anim notify. This basically tells the game that during those specific frames in the animation, the zombie can register a hit to the player, as long as the collision is also set to true. Again by using the build in damage system from Unreal, the zombies can now send damage values to the player which will interact with the health component.

Week 2 Gameplay Demo:

Outside of the development of the project I have spent my time this week finalizing my proposal document which outlines my key research topics as well as the aims and goals of this project. My target's for next week's development is to start looking into the gameplay mechanics for the rest of the game. This is things like the different upgrades that will be available, and how the progression of the game will work. I will start prototyping some of those mechanics while also starting some early blockout work for the level.