Documentation + User Guide

Differences From Concept

There are a few key differences between the original concept and the final game:

• There are multiple enemy types (I only planned to have one - though I didn't say so in the Concept Document). I decided to make this change because adding new enemies was far easier than I expected, and the game felt very dull with only one type.
• I originally said that the game would have a "moderate level of difficulty". The reason the game is so hard is because the "everything dies in one hit" design makes for a much harder game than I expected. I actually found it to be very enjoyable, however, so I designed the game with this new difficulty in mind.
• I added dialogue and a story (I always wanted it but didn't intend to actually add it). This was one of those "nice to have" features lingering in the back of my mind. I thought it would be way too hard to add (at least in an unfamiliar game engine), but after making all the basic gameplay and UI, I found that it wasn't actually that difficult to make. I added the hostage dialogue first because I felt that it wasn't very obvious that you'd saved a hostage if you weren't paying attention. After adding the hostage message, I realised that I could easily make a similar system for proper dialogue, so I did.
• There are breakable windows. The reason for this is that firstly, they are very cool, and secondly, I needed a way to stop enemies from roaming too far from their spawn area. Windows proved to be a great solution to this problem, which is why I added so many of them into the game. They also serve to make the level design more interesting in terms of visuals and gameplay.
• I added the security door puzzle element. The main reason I added it is that windows were starting to get a bit old after 4 levels. I thought it would be cool if there was another similar level-gating object which stops enemies from roaming everywhere and stops the player from walking through a level too easily. The security door idea is perfect for this function. It is like a window, yet also very different, leading to interesting new level design ideas.
• The shots fired score was added because it was requested during the testing session. I though it was a cool idea and gave the player something to strive towards, so I implemented it.
• I also added difficulty settings (by user request). They were not planned but definitely make the game better and more accessible.

As for the gameplay loop, it is completely unchanged from the concept. You must kill all enemies and save all hostages to win. Killing a hostage ends the game.

The general combat is also the same. You get one weapon with no ammo limit (except for in hard mode) and all entities die in one hit.

I kept the sliding body sprite idea too. They are exactly how I imagined them.

Overall, the game is far better than I originally planned it to be. I didn't want it to be overambitious so I went for a simple idea. The execution of that simple idea, however, far exceeded my expectations.

Feedback Summary

The formal testing session went very well. The feedback was generally quite positive.

The following was summarised from 9 responses during the testing session.

Visuals Feedback:

The visuals were scored at 88.9% Very Good, 11.1% Good.

Feedback for the visuals was quite good. People liked the art style and general feel of the game. Some issues raised were that a few objects were hard to distinguish against other colours, and that a bit more animation/movement was needed in the visuals.

I didn't change any visuals in response to feedback, as I had very little time to do so.

Gameplay Feedback:

The gameplay was scored at 44.4% Very Good, 55.6% Good.

People seemed to like the gameplay but a few found it too hard (which is why I added an easy mode). One person also mentioned that multiple things could be killed at the same time with one bullet. I don't personally consider this to be an issue, but it was an interesting bit of feedback nonetheless.

Audio Feedback:

The audio was scored at 33.3% Very Good, 66.7% Good.

The audio was perceived to be too loud and bitcrushed, which I am inclined to agree with. People generally enjoyed it though.

If I had more time, I would have improved the audio.

Performance and Stability Feedback:

Performance and stability was scored at 77.8% Very Good, 11.1% Good, 11.1% Neutral.

According to the feedback I received, the game ran very smoothly for people. The only bug reported was that apparently you can shoot through walls at a specific angle. This shouldn't be possible, but I will investigate it just to be sure.

Difficulty Feedback:

The difficulty was scored at 22.2% Very Good, 66.7% Good, 11.1% Neutral.

Most people found the game quite difficult. Some struggled and gave up while others managed to finish it. One peson suggested adding a difficulty slider (which I did) while another requested I add more, even harder levels! It's certainly interesting to see how different types of people react to a hard and fast-paced game.

As a general response to the difficulty feedback, I added an easy and hard mode (alongside the default normal mode). This should hopefully satisfy all types of people, allowing them to play in a style that suits them.

One thing I noticed while observing the testing session is that people solved the security door puzzle very easily. This was the ideal outcome, as I intended for it to be as intuitive as possible.

Asset List

Every asset included in this list was made by me unless indicated otherwise. However, some were influenced by other materials (these cases have been clearly marked).

Art

All art made in Aseprite (with the AAP-64 colour palette)

Enemies:

• cletus_harling.png - Cletus Harling art (including corpse)
• enemy_pistol.png - Pistol enemy art
• enemy_pistol_corpse.png - Pistol enemy corpse variations
• enemy_shotgun.png - Shotgunner art
• enemy_shotgun_corpse.png - Shotgunner corpse variations
• enemy_uzi.png - Uzi Guy art
• enemy_uzi_corpse.png - Uzi Guy corpse variations

Tiles:

• floor_tiles.png - All floor tiles
• wall_tiles.png - All wall tiles

General:

• corpse.png - Default/prototype smiling corpse art (UNUSED)
• hostage.png - All hostage variations
• hostage_corpse.png - All hostage corpse variations

Player:

• player.png - Player art
• player_corpse.png - Player corpse varations

Projectiles:

• bullet.png - Bullet art

Props:

• couch.png - All couch variations (big and small)
• ovaltable.png - All oval table variations
• security_door.png - Security door frame and moving door sprites
• security_door_controlbox.png - Control box for security door
• vase.png - Potted plant art
• window.png - Window art - contains full window, broken window, and window frame
• breached_door.png - Broken door and doorframe art
• ex_car.png - State Extrication Bureau squad car seen outside each level

Scripts

All of the following scripts were written completely by me unless indicated otherwise.

I had some help from the Unity documentation for a few built-in functions (all of these cases have been appropriately linked in the code).

A very small section of MusicPlayerObject.cs (regarding object scene persistence) was inspired by this tutorial, but the code is not exactly the same and the rest of the script is all mine.

Entities:

• AddToTargeting.cs - Handles individual entity presence within faction array
• CorpseHandler.cs - Handles corpse creation for all relevant entities (had Unity docs help for angle difference calculations).
• Enemy.cs - Handles enemy count for each individual enemy. Adds parent enemy to count and removes it when killed.
• GoToTarget.cs - Makes an object go to the target of a TargetingBrain. Used to make LookTarget and MoveTarget objects go to an entity's target when chasing.
• HealthManager.cs - Script for managing health values and health change events. This script is used for everything that can be killed or broken.
• Hitbox.cs - Handles projectile-to-entity collisions and sends data to HealthManager.
• Hostage.cs - Handles hostage count, hostage visual variations, game over on hostage death, and hostage dialogue.
• LOSStateManager.cs - State management for entities. Used to determine if a sightline is or isn't broken. For enemies, this checks whether or not they can see the player. When the sightline state changes, a UnityEvent is called and various components on the entity are enabled and disabled. This is the main driving force of the enemy AI.
• Player.cs - Disables player controls on game over and causes a game over when the player dies.
• TargetingBrain.cs - Checks for closest enemy target every 1.5 seconds. the "targetEntity" variable is the current target and is used by numerous other AI-related scripts. This script serves as the main hub for all targeting behaviour.

General:

• RayQuery.cs - Static utilities class for quick raycasting functions. Mainly used by LOSStateManager and Shooter components.
• Utils.cs - Static utilities class that contains a few functions to easily perform distance checks between two transforms.
• DestroyOnCollision.cs - Destroys an object when it collides with a trigger. Used for bullets and was originally used for hostages.
• DialogueObject.cs - Can start new dialogue on level load or when called by another object. Used for all of the level intro dialogue and the Cletus Harling dialogue.
• DifficultyButton.cs - Difficulty menu button. Updates text and game mode when clicked.
• Disabler.cs - Disables an array of objects and components when called. Used for hostages (when they are saved) and player (when game win/over screen appears & when killed).
• EventOnInput.cs - Invokes a UnityEvent when a specific key is pressed. Used for "Space to Skip" functionality in cutscenes.
• GlobalRelay.cs - Relay between objects and static classes. Used to initiate level transitions via UnityEvent.
• GoToTransform.cs - Makes an object constantly move to another transform to simulate parent-child relationship. Used to make sounds follow enemies.
• InGameUI.cs - Handles all in-game UI (dialogue, hostage messages, score, restart/next/quit buttons, etc.). Got help for dialogue string formatting here.
• LevelDataObject.cs - On level load, tells the GameManager the name of the intended next level. Used for setting up level transitions.
• LookAtMouse.cs - Makes an object instantly snap to the mouse. Used for player aiming.
• LookAtTransform.cs - Makes on object smoothly turn towards aiming at another transform. Used for enemy aiming (they constantly look at an empty object named LookTarget).
• MusicPlayerObject.cs - Handles which song should play on a level or if music should stop playing.
• ScreenShaker.cs - Relay between UnityEvents and PlayerCameraController. Used for screenshake when certain things break, die, or shoot.
• Timer.cs - Timer object that can either count down once or continuously repeat counting down. Used for player and enemy shooting (repeat timer that causes gun to fire every X seconds).

Movement:

• EntityMovement.cs - Base movement handler that calculates damping, speed, move direction, etc. All movement scripts use this by changing its movement direction. I set it up like this to give all entities a consistent movement style.
• MovementChase.cs - Makes an entity chase a target transform and stop when close. Used for enemies.
• MovementIdle.cs - Makes an entity move in random directions and bounce off walls when colliding. Used for enemies.
• PlayerMovementController.cs - Takes user input and tells EntityMovement to move based on it. Used for player.

Overhead:

• FactionSystem.cs - Static class that handles faction arrays and targeting calculations. TargetingBrain uses this for all of the targeting/faction information it needs.
• GameManager.cs - Handles game information (kills, hostages, shots fired), game states (game over, game won), and level transitions. This script is the main brain behind the overall game logic.
• MusicController.cs - Handles music persistence between levels (had help for this here) and music transitions.

Player:

• PlayerCameraController.cs - Handles player camera movement (look-ahead, screenshake, etc.).
• PlayerShooting.cs - Tells a Shooter component to fire on user input. Target mouse button can be customised as well as whether the button must be held down or pressed once. This could theoretically be used to give the player multiple weapons or alternate fire modes that all function differently.

Projectiles:

• Damager.cs - Holds damage data for projectiles. The presence of this script also ensures that whatever is colliding with a Hitbox is an actual projectile.
• Shooter.cs - Handles all shooting logic. Used for player and enemies. Can be made into any sort of weapon if the public variables are customised.

Sounds and Music

All sounds made in BFXR

• Glass.wav - glass breaking sound
• Hit.wav - universal death sound
• Hostage.wav - original hostage save sound (UNUSED)
• Laser.wav - new hostage save sound
• SecurityDoor.wav - security door control box break sound
• Shoot.wav - universal shooting sound

All music tracks made in FL Studio 21

• ExtricationWubber.ogg - music for the first 3 levels
• FinalRush.ogg - music for the last 3 levels
• Intermission.ogg - menu and cutscene music

Fonts

These fonts are used for all UI elements. They were NOT made by me.

• PixelOperatorSC.ttf - CC0 font from Dafont.
• PixelOperatorSC-Bold.ttf - Same as above.

Prefabs

• Boss Variant - Cletus Harling boss. Inherits from PistolEnemy prefab.
• Bullet - Bullet projectile.
• Corpse - Corpse object.
• CouchBig - Customisable couch with a large collider
• CouchSmall - Customisable couch with a small collider. Inherits from CouchBig prefab.
• DialogueObject - Handles dialogue initialisation. Used with DialogueObject.cs script.
• FloorTileGrid - Standardised floor tilemap grid.
• Hostage - Hostage entity.
• InGameUI - All in-game UI (visuals and functionality).
• LevelData - Handles level transitions with LevelDataObject.cs
• Music - Music player that persists across scenes.
• MusicPlayerObject - Song request object. Used to play new songs when a level begins.
• OvalTable - Oval table prop.
• PistolEnemy - The pistol enemy type. Used as a base prefab for all other enemies.
• PlayerController - The player.
• SceneSetup - Prefab that contains all objects required to start making a level.
• SecurityDoor - Security door object. Contains control box.
• ShotgunEnemy Variant - Shotgunner enemy type. Inherits from PistolEnemy prefab.
• TilePaletteBasicThick - The floor tile palette.
• TilePaletteBasicThin - The wall tile pallete.
• UziEnemy Variant - Uzi Guy enemy type. Inherits from PistolEnemy prefab.
• Vase - Customisable vase object.
• WallTileGrid - Standardised wall tilemap grid.
• WindowThick - Edge of level window that can be broken but not moved through.
• WindowThin - Normal window that can be broken and walked through. Inherits from WindowThick prefab.

Animations

All animations have an animaton controller. I will not include those here as their purpose can easily be inferred from the animations they include.

• menu_fade_anim - Title fade/blur pulse effect.
• music_default - Music default volume
• music_fadein - Music volume fading in
• security_door_closed - Security door stationary animation.
• security_door_opening - Security door open animation.

Player and all enemies follow this formula.

• NAME_idle - NAME idle animation.
• NAME_shoot - NAME shoot animation.

Scenes

• Intro - Intro cutscene.
• Level(1-6) - Game level scenes.
• Menu - Menu screen.
• Outro - Ending cutscene.

Other

• AudioControl - Volume mixer that handles music and SFX volume separately. I didn't actually use this for anything.
• PhysicsMaterialCharacter - Physics material for all entities. Stops them from bouncing or experiencing friction. Gives nice slidey movement.
• WallRuleTile - Rule tile for walls. Allowed me to make levels much faster.

User Guide

Welcome to the user guide for Extrication.

Upon running the game, you will be greeted with a menu screen. You can click on any of the level options to play. Click on "Level 1" to start from the beginning.

By selecting the difficulty button, you can change how hard the game will be. The currently displayed difficulty is the one that will be active when you play the game.

Difficulty Settings:

• Easy: Slower projectiles
• Normal: Default
• Hard: Faster projectiles, limited shots

Once you have selected the first level, an intro text cutscene will appear. Press the Space Bar to continue.

When the level starts, you will find yourself inside a building. You can move your mouse to look around and aim, and press the WASD keys to move. The further you move your mouse, the further away you can see. This is useful for scoping out the next room.

You can click the Left Mouse Button to shoot. The delay is very short, so you can spam it to shoot rapidly. Be careful though, everything dies in one hit!

In the first room you will find multiple enemies and hostages. The man in grey with the gun is an enemy. Make sure to dispatch him very carefully. The people tied up on the floor are hostages. Stand over them to save them, and make sure that they don't get shot. If a hostage dies, it's game over.

If you die after entering the room, you can press Restart to try again. If the game is too hard, you can press Quit to return to the menu and change the difficulty.

Once you have cleared out the room, you can move on to saving the hostages.

Remember, all you have to do is stand on them.

The blue beams in the room above are windows, you can shoot them to get through. Be careful, though: enemies can still see you through them.

Once you have completed the level, you can press Next to advance to the following one.

Now you know how to succeed in Extrication. Kill all enemies, save all hostages, and, above all, be careful. Good luck!

Sources

Enaguas, J. (no date) Pixel operator, Pixel Operator Font. Available at: https://www.dafont.com/pixel-operator.font (Accessed: 29 May 2025). 

Rehope Games (2023) Uncover the Simple Trick to KEEP MUSIC PLAYING Between Scenes!, YouTube. Available at:

(Accessed: 29 May 2025). 

Technologies, U. (no date) Mathf.deltaangle, Unity. Available at: https://docs.unity3d.com/6000.0/Documentation/ScriptReference/Mathf.DeltaAngle.h... (Accessed: 29 May 2025). 

Dotnet-Bot (no date) String class (system), (System) | Microsoft Learn. Available at: https://learn.microsoft.com/en-us/dotnet/api/system.string?view=net-9.0 (Accessed: 29 May 2025).