Marla

Dev log:

• Initially, the idea was for the game to switch from front to side perspective, where the camera and the corresponding key binds were changed through the player pressing tab to access different aspects of the map, however that was quickly scrapped in favour of a more traditional character controller. Due to the initial idea, it would have been necessary for it to be that if the camera detects a wall it moves closer to the player and if it detects something between the camera and object it teleports the camera to show the player, which is now obsolete due to switching to a traditional character controller with a cinemachine brain

• Initially, the interaction script was designed to allow the player to freely click around the map where an interaction prompt shows if the player hovers over an interactable objects, however this was later modified to be a simpler method where the player just moves close to an interactable object and an E to interact prompt shows up.

• Due to the game initially having enemies, a dash mechanic was implemented where if shift is held the player moves faster for 5 seconds, however that was removed in favour of focusing on platforming and puzzles.

• The first scripts to make for obstacles were a script to make an object go back and forth between 2 coordinates, a script to make an object spin at a set speed, a script to make an object lose solidness on collision, and a script where the player can move up and down when colliding with the object as if it was a ladder.

• At this stage I also implemented three AI types. One AI detects the player within a set distance and spawns a model 2 seconds after detection on detected player location every 4 seconds, one where the player enters the first radius and an enemy spawns and follows the player at a set speed until the player reaches the second radius, and an AI that makes an object move away from the player when they enter a set radius round it with randomized movement to look like a rat. In the current stage none of these AIs have been implemented due to the shift in focus on platforming

• For collectable sprites, I initially had the idea to make the sprite change angle with the camera angle, however after some trials I found that it looks very strange and it would be better and more attention grabbing if the sprite was simply made to spin on its own axis indefinitely and independent of the camera rather than skew based on camera angle

• In the outdated version of the level design, the roof became intrusive while working, so I implemented a script where the roof shows I play mode and in edit mode it hides it, however after implementing a better level design model this became unnecessary due to becoming less intrusive.

• At one point in the development there was an issue with getting the player to move with the moving platform, the issue was that the moving platform caused jittery, slow, and strange movement where some variations did not let the player follow the moving platform at all. After producing many different solutions all that had to be done was switch interpolate to none and collision detection to discrete on the rigibody component.

• Initially, the mouse interaction would have been done through abstraction where a mother abstract script is used to play independent results unique to the specific object without needing to explicitly specify, however due to cutting down to simply having 6 collectables it became unnecessary for the task needed and was substituted with an object holding array and its corresponding logic.

• The lockpicking stayed unchanged in terms of it having a close to pick point and pick point range collider with a pick end and a pin end collier used to detect if the pin is I the correct position and move it to that position. The main thing that was done was removing the function where if the pin is let go at the wrong place five times a pick breaks which was judged to make the game too difficult and provided no real value.

• The dialogue handling on the game was done by parsing through lines of a text document and displaying it in text mesh pro according to a set delay to give the payer time to read.

​

Code organization overview:

• AI Folder:

  • AITypeOne

    • The code continuously checks if it’s time to look for the player and it determines if the player is close enough for the AI to notice. If the player is within range, it waits a bit then creates an enemy near the player’s last known position.

  • AITypeTwo

    • The script monitors the player’s presence using two detection radii. When the player enters the closer radius, an enemy is spawned and moves towards the player. If the player moves beyond the second radius, the enemy returns to its original position. It checks for obstacles between the AI and the player. Collisions between the player and enemy reduced player health. Audio feedback is played when the AI detects the player within range.

  • AITypeThree

    • During the update, the script checks if the player is in sight and is not touching the vent. if so, it triggers actions like fleeing from the player and exploring randomly within a set radius. If the player is not in sight or the AI is touching a vent, the AI is destroyed. The “PlayerinSight” function calculates player distance and determines fleeing or stopping based on predefined instances. The “Explore randomly” function sets a new random destination within a specified radius for rat like movement.

  • AITypeFour(empty)

    • Not created

• Audio Folder:

  • FanAudioManager

    • Plays fan slice audio when the fan hits the player

• Base scripts Folder (now obsolete):

  • This was a simple test folder that was used to test abstraction-based object interaction and serves no real-world purpose within the game.

  • Interactable

  • Key

  • OpenDoor

• CutScenes Folder:

  • FlyThroughTest

    • The script sets the speed of all dolly carts to zero to prevent movement at start. When reached, the point is disabled and a corresponding flythroughs are initialized based on their index. Each flythrough sequence moves the camera along a predefined path using the associated dolly cart, adjusts camera priorities to switch cameras and paralyzes the player to prevent mid cutscene movement. The script then restores priorities and player movement after the end of the sequence. 

  • VideoCutscenes

    • This script is designed to manage the playback of video clips within the game. It utilizes the unity video player component to control video playback and raw image component to display the video on the screen. The startcutscene method initializes the video playback by assigning the necessary components, setting up the video clip, and stating playback.

• Damage Folder:

  • Respawn

    • The script monitors the player’s health status and triggers the respawn process when the player’s health reaches zero and the player is not touching a spawn point. Upon player death, it plays a death sound, moves the player to the last spawn point reached and resets the player health. The script also checks which was the last touched spawn point to prevent conflicts.

  • UniversalDamage

    • the universal damage script is designed to reduce the player’s health over time through the RepeatedOnProlongedContact method while in contact with a game object which has the script attached. To make the script universal, I decided to give it a damage value that is changeable from the inspector.

• Dialogue Folder:

  • DialogueTextFiles folder

    • The text files separate different dialogue sections in lines and formats things through bars and stars for bold and italics, respectively.

  • DialogueHandler

    • The script has functionality to display text dialogue on player activation of dialogue points. The dialogue stored in corresponding text files and the dialogue box UI element. The script handles the sequential display of dialogue lines with a specified interval between each line. It also formats text for bold and italic styling using special text to prevent issues with the chosen font.

• Inventory Folder:

  • InventoryItemHandler

    • The script initializes arrays to manage inventory points, whether items are picked, and their corresponding tags. Upon collision with designated items, it checks for available inventory slots, updates the inventory image with the collided item’s sprite, and marks the item as picked. Additionally, it destroys the collided item game object. This code is not the final version, rather it was a quick implementation for the sake of concept. The updated version will likely use abstraction like the interaction script.

  • InventoryUI

    • The script is responsible for managing the visual representation of the inventory system through game object references for an open and closed suitcase, as well as an inventory slider. Upon pressing tab, the inventory state is toggled, activating or deactivating the suitcase and inventory slider accordingly.

  • InventoryNew

    • The updated inventory includes arrays for collectable items, their corresponding inventory slots and picture pieces to be shown when items are collected. There are also variables for UI elements representing an opened and closed wallet. The main functionality involves tolling the inventory state when the ‘Tab’ key is pressed, handling item collection by activating corresponding UI elements and destroying collected items, while updating the wallet UI to reflect the inventory’s open and closed state.

• Lockpicking Minigame Folder:

  • LockPickPayloads folder:

    • Lockpick payloads are activated by pin behaviour and can be anything from simply destroying a game object to a more elaborate function.

    • ExitLevel

      • Exits level 1 and goes to level 2

    • OpenTheDoor

      • Destroys the game object for the locked door in level 1

  • EnablePicking

    • this script detects left mouse button clicks, casts a ray to check for collisions with the object, and activates the lockpicking game object accordingly. If lockpicking finishes, the script deactivates the object.

  • PickBehaviour

    • this script allows for adjusting the speed at which the pick moves and stores its original position upon initialization. During gameplay, the script continuously checks if picking is enabled and moves the pick accordingly based on player input. If any point is already pinned, horizontal movement is disabled to prevent interference. Additionally, a method is provided to reset the pick to its original position as needed. This script contributes to creating interactive and dynamic gameplay mechanics within unity projects.

  • PinBehaviour

    • this script controls the behaviour of pins used in a lockpicking minigame. It manages the interaction between the lock, the pick, and the player. The script includes references to various game object sand scripts. The main functionalities include detecting collisions between the pick and pins, handling pin movement, checking if pins are successfully picked and accessing the associated payload upon successful picking. Additionally, it manages audio feedback for pin movement and successful pin placement.

• Misc Folder:

  • Close

    • A filler script to close the settings menu

  • GameEndCollider

    • This script contains two collider variables, one to activate the falling logic to make the floor fall at a set speed for a set distance and one to activate the end collider to end the game once the player falls far enough to come into contact with it.

  • GoToSecondLevel

    • A script to handle the UI of the menu scene between level 1 and level 2, the script sets the lock state to be able to select things and has methods to be accessed by buttons to load level 2 and the main menu with an additional one to quit the game.

  • MainMenuHandler

    • The script is designed to manage the main menu, it includes functionality for starting and controlling two cutscenes, paying audio clips associated with each cutscene(which will be obsolete in future iterations where the audio will be embedded in the video clip), showing loading screens through asynchronous scene loading, and the activation and deactivation of the options and credits menu. A skip button was implemented to skip a cutscene due to feedback of the cutscenes being too annoying given that they are non-skippable.

  • RoofAndWalls

    • Script to help development by hiding the roof and walls while working and activating them while playing so that I do not have to navigate around them while developing (now obsolete).

  • Settings

    • This script manages game settings through a menu with sliders for resolution, volume, and sensitivity. It initializes slider values and updates settings based on user interactions, with the start method initializing settings while the update handles closing the settings menu with the escape key. The script includes methods to manage changes in slider values and applies settings through the apply button.

  • ToBeContinued

    • Temporary script for a to be continued ending.

  • UIHandler

    • This script manages the health bar and pause/continue where it updates the health bar based on the playerHealth gameManager variable.

• Obstacles Folder:

  • BackAndForth

    • The back-and-forth script moves an object from one point to another and speed steps to slow down the platform when in contact with a point so that the movement is not as stark.

  • FallingBoulder

    • Once the player reaches a collider a boulder falls and displays dialogue that portrays the character’s reaction to the boulder falling and blocking his path.

  • MoveWithPlatform

    • The move with platform script checks collision with the player and parents the player’s transform to the platform.

  • Plunger

    • The plunger script checks if the player is in range and uses the in-range detection to move the plunger in a set speed and distance and go back in place.

  • Slip

    • The script is made to make the player slip on a surface. It defines a slip speed and adjusts the player’s movement accordingly when triggered by a collider tagged as “player.” It also includes functionality to detect obstacles tagged as “WallObstacle” and stop slipping if one is encountered. To prevent wall glitches

  • SteamTrap

    • The steam trap instantiates a prefab with a timed interval with audio fading in and out according to the activation status of the steam prefab. The script also deals damage to the player with a delay when the prefab comes in contact with the player

  • TimeoutPlatform

    • This script controls a platform’s behaviour in response to collisions with a specified player game object. When a collision occurs the platform initiates a shaking animation and sets a timer to destroy itself after 2 seconds, the shaking effect is achieved through a coroutine, changing the platform’s position randomly within a specified range for a set duration. After the shaking, the platform is destroyed.

  • TurnAtSetSpeed

    • Rotates a game object at a set speed, used for a fan

• Player Folder:

  • ButtonInteract

    • The script stores  a trigger distance, a player layer and an E to interact sprite. The script checks if the player is in the trigger distance range f the applied object and if the player is in range it shows the E to interact sprite

  • PlayerAnimCTRL

    • This script takes keyboard input and states such as if the player is grounded or is on a ladder to change the character’s animation separately from the player movement script

  • PlayerMovement

    • This script uses a combination of floats, layer masks and rigidbody to control the player’s movement in different situation, such as if the player is paralyzed, if the player is moving normally, and uses ray casting to check if the player is grounded and able to jump, and if the player is in contact with a ladder. Additionally, the script features functions for the jumping and climbing behaviours themselves.

• GameManager script

  • The game manager script handles important variables to be accessed by multiple scripts such as the player health and the turn speed

​

Code guidelines:

• All scripts should consider rigidbdy if they are based on movement, and if there is an issue with movement check rigidbody first due to it being the most common issue.

• Most variables should be made available in the inspector with [SerializeField] being used if private.

• Use in line curly brackets instead of new line to optimize vertical space on screen.

• It is also recommended to keep comments inline for single line functions and previous line for multi-line functions or methods.

• Remove unused callback functions such as start and update functions to prevent unnecessary calls.

• For loops are preferred due to being more compact.

• All scripted post processing shaders must have a renderer feature and pass made manually, for shader graph shaders this can be generated automatically by unity through the add feature button.

• Whenever a new post processing shader is added, make sure to add it in the shader list within project settings to ensure that the shader is applied in build.

• A script longer than two readable horizontal 16:9 21.5-24-inch monitor screen lengths should be avoided, and one screen length is preferred.

​

Performance optimization ideas:

• Occlusion culling (delete unseen objects).

• LOD (not applicable given the project level type).

• Quad trees (project is too small for this to make sense).

• Disable continuous processes in code if no longer needed in the game progression.

• Look over shader passes to reduce unnecessary processing.