Filip Wilhelmsson

System and Technical Designer

Project Asylum

Ability System Prototype

Boss Fight

Tower Defense

Project Asylum

Hiding Figure

At the start of the project, I took on both systems design and scare tactics. Rather than relying on traditional jump scares, I aimed for a more subtle, atmospheric approach—scares placed throughout the game that players might only notice occasionally.To streamline implementation, I designed BP_HidingFigure with a simple setup: place the ChildActor SpawnPosition where it should appear, set the SpookPosition for its movement, and trigger it when the player enters the TriggerBox. This ensures scares feel natural and effective while being easy to integrate.

Projector Scare

To add both puzzles and scares, I experimented with shadows, fitting the theme of the building as the antagonist. The idea was to create a ‘shadow-show’ on a projector screen using a transparent material that cast shadows but had no collision.I designed two sequences:-One where a shadow-ball fails to cross a chasm.
-Another where it succeeds after the player places an object in front of the projector.The failure looped until the player, holding the correct item, interacted with the projector. This then triggered a third sequence where a mutant crashed through a fractured wall, leading to a chase.Unfortunately, this final part wasn’t implemented due to time constraints and shifting priorities.

Red Room Scare

I did not come up with the concept for this but implemented it through the description of another designer.

The implementation for this one is fairly straightforward as well. It‘s mainly activating and de-activating components in a certain order to create the scare.

The one design part I added to this was disabling the flashlight during the scare and then enabling it again. This was to prevent the red-light contrast towards the darker meshes from being saturated by the flashlight's light-component.

Isolation Room Scare

Idea for this one came about when we decided to make use of a mechanic that changes the layout.

With already some testing done using transparent materials that leaves a shadow and LevelSequences for the BP_ProjectorScare, this one felt very fitting, although the execution could maybe have been refined a bit.

It’s meant to sort of “give a face” to the evil that surrounds the player but still be vague.

Ability System Prototype

Goal
Create an ability system that:Is easily scalable for new abilities
Manages cooldowns
Supports different input types (instant activation, area targeting, etc.)Approach
I used two ActorComponents attached to the player:
AC_Abilities – Handles ability usage
AC_CDManager – Manages cooldowns
The system flow:
Input → Viability Check → Get Info → Create Ability → Trigger Cooldown
Each ability class then handles its own logic (movement, damage, duration, etc.).Implementation
AC_Abilities listens for input and checks with AC_CDManager to see if the ability is on cooldown.
If ready, it either spawns the ability or waits for mouse input (for targeting abilities).
Once used, AC_Abilities tells AC_CDManager to start a cooldown timer, storing the ability in a map until the timer expires.Result
To add a new ability, I only need to:
Assign a hotkey
Add the ability to the E_Abilities Enum
Create a function to spawn it
After testing, the system worked as intended, allowing for easy ability creation and management.

Hedgehog

Goal: To create a multi-target attack that follows the void/space theme. With an easily set max target amount and functionality to take Line of Sight into consideration.

Implementation: To make this ability work i needed to make use of a TargetManager to filter out which enemies were in range, and then filter out the X amount closest to the BP_Hedgehog when spawned.
Once targets have been found, the BP_Hedgehog spawns a BP_Quill for each enemy and assigns them as the quills target upon creation.
Once the quill is spawned it will:
-Rotate to face its assigned target.
-Increase its scale.
-Deal Damage.
-Decrease it's scale.
-Destroy itself.
-Once all quills are destroyed, the Hedgehog destroys itself.

Improvements: Currently it is possible for less than max amount of targets to be attacked, even if there are enough targets in range and not behind cover. Since the LineTrace to check for obstacles is done after the quills are spawned. Some of them might be squandered on close-by enemies behind cover, instead of targets slightly further away but NOT behind any sort of cover.

Doing the LineTrace after the Hedgehog has moved in to position. With additional communication between itself and the TargetManager, all targets in range could be cycled through and a new target could be set.

Step

Goal: To create a easily controlled movement ability that felt nice to use.

Implementation: One of the technical goals i had was to use ActorComponents as much as possible and to avoid ever touching the character blueprint which i was successful with.In general terms the AC_Abilities component reacts to the initial ability hotkey followed by a mouseclick. And then feeds the necessary info into a newly created AC_Step. Which then manages the:
-Camera duplicating and lerping.
-Creating and altering visual elements on the ground.
-Descending, teleporting and ascending the player.
-Controlled cleanup of duplicate camera, visual elements and the component itself.

Improvements:
-A check to see if the player has enough room to emerge at the desired location is needed to prevent getting stuck.
-The Step ability is currently usable on any surface in range. Adding a tag of some sort to the surfaces you want the player to be able to step to would prevent the player from targeting walls and such which, causes unwanted behavior.

Boss Fight

General Structure of the boss is 3 phases and 5 abilities which are:
-Projectile
-Sinewave bulletpattern
-Laser
-Pillars
-ShockwaveThe abilities are fired from a BehaviorTree at different intervals which changes based on the current phase. The phases also affect the intensity of the ability like firing rate and adding a reverse sweep for the laser and sinewave ability.

Boss Turret Component

The projectile system is fairly straightforward with spawning projectiles and using the players position to determine firing direction. It does however have functions to easily change the firerate and burst amounts.In phase 1 the boss will fire 4 projectiles with 0.2 second intervals between them.
-In phase 2 the boss will fire 7 projectiles with 0.15 second intervals between them.
-In phase 3 the boss will fire 10 projectiles with 0.1 second intervals between them.

The TurretComponent also has a toggle which causes it to keep firing constantly until toggled off. This toggle is used to create the sinewave pattern bullet attack the boss has by simply toggling it on and moving the projectile spawnpoint up and down while the boss rotates.

Laser

The laser ability is created by scaling a mesh to the length of a LineTrace that is fired just before.During phase 1 and 2 the boss will only rotate one direction and with the laser active. In phase 3 however the boss reverses it rotation and sweeps the laser the other way as well.If the laser comes into contact with either the player or one of the pillars it will deal damage to them.The player can jump over the laser or hide behind pillars to avoid taking damage.

Pillar

Spawning Process
-Three random points are selected within the navigable area, ensuring they don’t overlap.
-A pillar spawns at each point, starting slightly above the ground.
-A LineTrace confirms solid ground beneath, adjusting for uneven terrain.Functionality
-Pillars provide cover for the player.
-They absorb player projectiles, the boss’s laser, and boss projectiles.
-Each pillar has a health component and, when destroyed, has a chance to drop a health pickup.

Shockwave

The shockwaves base mesh is set to be the same size as the bosses interior space and then its simply scaled linearly upwards which makes it get the impression that it is moving outwards.Upon contact with the player, a function that determines which direction is away from the boss, from the players perspective. That direction is then used in conjunction with the ApplyForce blueprint node to push the player away.

Tower Defense

This started of as a side project to work on during my free time, but only 1 week in i got a bit overwhelmed by other obligations and had to take a break from it.A few months later, however, we started the "Intro to Visual Scripting" course at Futuregames, where I asked our teacher if it was alright for me to pick this project back up—which it was. From then on, I spent most of the course's five weeks working on this.

Tower Base

Enemy Base

The base tower class uses a struct with all necessary info that is then applied wherever it needs to be. The information is:
-Name (Name)
-BaseDamage (Int)
-BaseAttackSpeed (Float)
-BaseRange (Float)
-Projectile (Child class of BP_Projectile_Base)
-BaseCost (Int)
-Description (String)

Enemy Base
The enemies consist of a simple Struct that contains:
-Name (Name)
-MaxHealth (Integer)
-BaseMoveSpeed (Float)
-CurrencyOnKill (Integer)
Besides the functionality related to these values, the enemies also have a simple behavior tree that drives their movement from the start of the map to the end in a fixed path

Spawning

The enemy spawning is handled by a BP_EnemySpawner class that contains a editable WaveList array variable. This variable is of type F_Wave which is a struct that contains a single Map <Actor, Integer>.This structure allows for easy editing of what enemies to spawn and their amount, as well as have several different type of enemies per wave with a desired amount of each.

Debuff

To add some more variation to the gameplay i decided to add debuffs. The structure i went for was a base debuff class that inherits from ActorComponent that has a set lifetime which countdowns from its creation. The only other thing the base class has is a ResetDebuffDuration event to restart the timer in-case of debuff re-application.The actual Debuffs are then child classes of this one, the two debuffs i implemented were a Frost, which slows the enemies movespeed on hit for a short duration. The other one i implemented were a Fire Debuff, which does periodic damage.

Frost

Fire

The application of the debuffs are done by the projectile type which is assigned to the towers through its struct. When a tower deals damage to an enemy it also checks the projectile type, and if its frost or fire, it will add a corresponding debuff actorcomponent to the enemy.

C++ Prototypes

Crouch Component Prototype

For a while i've been needing first-person crouch for personal projects and after remaking it for the third time in blueprint i decided to create a modular, easy to use CrouchComponent in C++ that i could re-use in different projectsAdding it to projects:
1. Drag the .h and .cpp files into the new projects source folder
2. Change the class name to the new projectname ending with _API
3. Add component to character class
4. Set capsule component in beginplay

5. Add an input for crouch

6. Adjust exposed variables, mainly CrouchTransitionPeriod (how long it takes to crouch and un-crouch)

How it works

The CrouchComponent takes the capsule component at start and calculates standing height and crouch height based on the capsules HalfHeight.

The CrouchComponent creates a Timeline in the constructor and a CurveFloat in beginplay which it uses for the crouch animation to scale the player capsule between standing and crouching.

The input then alternates function call depending on what the current status is.

Safety Measures

To prevent the player from getting stuck when un-crouching, a spheretrace is fired upwards based on the playercapsules' radius and standing height, with some adjustments from the exposed variable TraceEndPointAdjustment. If the Trace collides with something, that means there is an obstacle above the player and the un-crouch call will be cancelled.

Event

The CrouchComponent also has an event for CrouchStatusChanged which can be very useful for changing movement speed, footstep sounds etc

Day/Night Cycle Prototype

For the DayNightCycle to work all you need to do is create a child blueprint of the C++ class and drag it into the world, after that you set the SunRotation Variables.

Easiest way to accomplish this is to rotate the DirectionalLight to the desired rotation for the specified time, and then copy its value and paste it in to the corresponding DayNightCycle SunRotation variable.Besides that you can select a StartingTime and the TimePeriodLength, which is how long each period is. The full cycle consisting of four periods.

The DayNightCycle works by lerping the DirectionalLight rotation and CurrentTime Variable(float) between the time periods, The time periods are:Morning (06:00).
Midday (12:00).
Evening (18:00).
Night (00:00) which is right after 23:59.

Once a time period Timeline finishes it updates the current TimeOfDay to the new one, before progressing time again.

This type of setup allows for easy control both when setting the time, but also to trigger events for each time period.

Weather System Prototype

To make the WeatherSystem work you first need to add a Niagara Particle System Component, then you need to supply the WeatherSystem with:
-Niagara Component reference.
-The current map Weather config (a struct variable).
-Lastly you need to initialize it. This is a design choice since the system is based on a UWorldSubsystem and you only want the system to be active on certain maps.
-You can also assign the WeatherChanged event.

The major feature of the WeatherSystem is that it works the transitions out on itself, for example Sunny weather has to transition in to Overcast before Rain can happen.There are however functions to force the desired weather.

The duration of the transitions and the length of each weather is defined within the struct that you supply before initializing it. A calculation is also done to determine how many steps are required to transition to- and from Overcast.When Transitioning, the Function responsible for either starting or ending the Overcast will call itself a certain number of times based on the CalculateOvercastTransitionRate and increase the SkyAtmosphere values appropriately.

Time of each WeatherDuration can also be randomized by setting the MinimumWeatherLength and MaximumWeatherLength variables in the struct. If a set time is desired they can simply be set to the same value.

The WeatherSelection within the subsystem is the major part that handles the flow, taking current weather into consideration as well as randomizing the outcome.

Favorite Games:
Dragon Quest 11
Resident Evil Series
Elden ring
Octopath Traveler Series
Stardew Valley





Email:
[email protected]

Hello! My name is Filip Wilhelmsson and i am currently studying Game Design at Futuregames in Stockholm. I am also looking for an internship within areas of System and Technical Design.My interest in games started early with games like Super Mario 64, Zelda: Ocarina of Time and Age of Empires 1 & 2. It was the late 90's and since then playing games have been a major part of my personal life.in 2022 i started studying Game Design even though it wasn't my first choice at the time, but i immediately realized that this is something i want to do for the rest of my life.My favorite parts of game design is the explorative nature which rewards curiousity and trying new ideas. The second part i love is the iterative process, where small continious adjustments can shape your idea in to something wonderful.Besides making and playing games i love cooking and everything surrounding it. I bake my own sourdough bread. I ferment my own kimchi etc. And the reason why i love this so much is probably for the same reason i love game design. It rewards curiousity in terms of flavor combinations and iterating on recipes make them even better!