Shadow Man

Released (17/05/23)

This was a solo project developed for a module at Abertay University. The projects intention was to be a learn both Shaders and State Machines. I programmed and designed the game and level however for this project I used pre-bought and free assets. These will be listed at the bottom of the page.

ITCH.IO PAGE

The Project

As stated above the projects intention was for me to learn about shaders and state machines as I had not worked with these before, however for the project I wanted to create something a little different. My inspiration for the game was to create an enemy that instilled terror over traditional fear.
Terror is the anticipation of seeing something horrific, where as horror is the physical seeing of something horrific.

Full Portfolio:

Level Design:

The first initial stage was to texture the world and plan out routes around the map. Since the idea was for the game to be set in a forest I planned only a small road with two smaller paths leading from it to allow as much forest area as possible.

The second stage was building up the texture and height of the level, I build up an incline around the level to give off the idea that the player is in a ditch.

The third step was to place grass and rocks within the world to give the level a layered ground. As the game takes place in a forest I needed the ground to be full.

In this step I added all of the major landmarks and bigger objects so that I could adjust the previous steps to fit with these landmarks, I.E. footpaths and height of the ground etc.

Image showing more of what the previous image was showing.

This step was based around placing the trees and creating the forest areas of the maps.

In this screenshot it shows the placement of lighting within the scene.

This is the Lighting image with the global light darkened.

This screenshot shows when I added the distant fog to the level.

I added a ground fog/haze to support the distant fog and to make the scene more eery, I did this via a plane across the ground and a shader. I also continued to iterate upon each element over the course of the development lifecycle.

The following photos show the iterations and build up of the individual elements that create the final level. The photos show an increase in layers and show the design process.

Enemy State Machine:

This image showcases the variables and start method of the enemy state machine, The variables are split into easily digestible sections via the headers which keep collected variables in one place. The start function sets up the required elements for the game to run.

This image details more of the variables used in the state machine, again they are sectioned to be easily digestible.

This screenshot contains the update function and the choice adjustment function. The update function sends a trigger to the state to execute the update function of the state every frame, it also runs some of the important elements of the code. The choice adjustment function is called whenever the code makes a randomised decision, it changes barriers of the choices so that the choices cant keep repeating consecutively.

More code related to the choice adjustment explained in the previous image. A function that is called to reset the choices.

More code executed in the update function (executed every frame). This code is some of the more important lines like checking distances and seeing if the enemy can move within these distances.

This screenshot details important functions that the state machine uses often. Some of the functions are simply to swap between states, go to destinations, cancel paths, however other functions are more complex such as setting speed of the enemy, making the enemy appear and disappear, enabling and disabling the husk around the enemy.

Again this screenshot showcases some more of the complex functions such as swapping between animations, playing audio clips and this screenshot also shows the stun method of the enemy, this method is called upon when the enemy is caught in the players flashlight.

Enemy IDLE/Stalking State:

This is the stalk state, in this state the enemy has one job to watch the player from a distance for a randomly defined amount of time.

This is the IDLE state the enemy when in the IDLE state makes choices on what it needs to do next and communicates this with the other elements of the state machine. In this screenshot you can see why and when the enemy makes choices and how it makes those choices.

Continuation of the IDLE state. This image showcases more of how the enemy makes choices and how the choices are impacted by the current boundaries set in place. The image also shows the randomised wandering point function, which is where the enemy chooses a random place to wander to close by the player.

The next pictures show the IDLE and Stalking state of the enemy. The IDLE state is a state where the enemy resides and makes choices on what they should do next, the stalk state is a state where the enemy watches the player from a distance and the state is used to increase tension and make the player feel nervous.

Enemy Ring State:

These images showcase the ring state. This state is used when the enemy is wanting to attack the player, it works by having three rings from the players position. The three rings incrementally count down after the enemy has resided at that ring distance for a randomised time. On the last ring the state machine enters the attack state. This image shows the update method for counting down the seconds till the next ring movement and the setup of the enemy in this state.

The enemy in this state gives the player hints to their impending doom, such as an audio cue and increased visibility of the enemies whereabouts.

Attack/Imitate & Stun states:

This is the attack state, its purpose was to be entered when the enemy has gone through all the rings in the ring state, the purpose of this state is for the enemy to chase down and kill the player when entered. This image shows the enter and update methods of the state, the enterState method sets up the variables and state to be used correctly. The update state checks if the enemy is within range to attack the player then executes the attack function, this method is also responsible for resolving a bug where the enemy would get lost and the path would autocomplete.

This image shows the attack method of the attack state. It handles ending the game if the player is caught, it also toggles on a jump scare.

This is the Stun state, it handles disabling the enemy from moving, attacking and also makes the enemy visible. This state is called upon when the enemy is caught in the players flashlight.

The image shown is of the imitate state, the purpose of this state is to build tension and fear in the player as the enemy spawns in front of them visible and mirrors their inputs.

Other Scripts:

These images are of the game manager, this image showcases the setup (awake function), and the variables used within the script. The game manager is responsible for ensuring the game runs right, I would have liked to have split the game manager into two scripts as the game manager currently handles the cutscenes and individual stages in the game as well.

This showcases the update, RandomSpawn and GameStateUpdate function. The Update function checks for the players input to skip the intro monologue. The RandomSpawn function randomises the spawn of the keys in the level. The GameStateUpdate function updates the state of the game and what needs to happen at each state of the game.

This image shows the coroutine used when skipping the introduction monologue, and how it sets up the main game after this.

This image shows how the introduction monologue works. It also shows the end game function which is used for ending the game and pulling up the game over UI.