Category: Project 2

Game demo video:

Game Map:

Player spawn point:

The player starts the game in the main hall. This area gives the player a moment to get oriented before the mission begins. And some initial dialogue is triggered to introduce the mission:

Dungeon:

In the dungeon, players will encounter enemies like zombie skeletons and need to collect key items for the mission. This area was once used for serpent blood experiments. The atmosphere is dark, requiring players to use a flashlight to explore:

Corridor:

The Serpent’s Sealing Place：

Research:

Dark Souls: Death Loops and Ambiguous Narrative

In my game, the contrasting design between the sacred relics and the underground prison is meant to convey narrative clues through the space itself. Players won’t directly know the cause and effect through text, but will instead feel the traces of a completely collapsed order through the scene.

Why would there be a dark dungeon hidden beside a solemn relic? And in the dungeon, not only are books scattered everywhere and a statue of a goddess standing silently in the corner, but also skeletons quietly kneeling, seemingly still praying. These visual symbols do not point to a single answer, but are like scattered keywords, waiting for players to piece them together — perhaps they will interpret it as a betrayal, or a failed salvation, or the collapse that comes when faith becomes extreme.

In such a structure, the player is no longer a passive recipient of narrative, but an active constructor of meaning. I care more about the questions, emotions, and imagination they generate during exploration, rather than whether they “correctly understand” a predetermined ending.

Dark Meadow: The Pact

The visual and spatial design of this game shows the remnants of the old world：dilapidated hospitals, flickering lights, a mysterious white witch, and monsters wandering the corridors.

As the truth gradually unfolds, we realize that these monsters are not malevolent intruders, but “waste products” left behind from soul bargains or failed experiments—they no longer belong to this world, yet they are unable to leave it.

At the same time, the protagonist’s sense of unfamiliarity upon awakening in Dark Meadow inspired the direction for my player character design. I want players to enter the game in the same state as that awakening: knowing nothing about the ruins, and having to piece together their own understanding through exploration.

This sense of the unknown and the ambiguous makes me believe that rather than a clear narrative, a space that can be read is the most moving way to tell a story.

Other Research and Production Plan can view in week 1 entry:

Week 1 Research and Production Plan

Concept reflection

The Fall of the Descendants: Power’s Self-Corrosion

When traditional belief loses its genuine spiritual core, leaving behind only a structure of power that can be inherited and exploited—can it still represent justice? In such a system, bloodline is no longer a continuation of faith, but a token of identity, a legitimate means of domination.

I think this concept reflects certain realities. We may have all seen systems that appear to still function, maintaining sanctity and authority in form, but in truth have long strayed from their original meaning. The downfall of the guardians did not come from external enemies, but from internal hollowing and the erosion of values.

The Blood of the Serpent: A Forbidden Power

I chose the Serpent as a central symbol because it carries complex meanings across many cultures. It is often associated with both enlightenment and downfall. The serpent can grant wisdom, but it can also bring catastrophe. In the Bible, it tempts humanity to eat the fruit of knowledge. In Eastern traditions, it is frequently linked to dragons, immortality, and the cycle of rebirth.

In my game’s narrative, the blood of the Serpent represents a forbidden power, a form of knowledge that exceeds the natural boundaries of what humans are meant to possess. The descendants tried to harness it to transcend the limits of their physical bodies or prolong their lives. This reflects their belief that they could take the place of gods and rewrite the natural order.

This concept also reflects real-world anxieties around certain technologies such as gene editing and cloning. As we continue to push the limits of ethics and science, we often lose sight of the consequences. When the power to create is amplified by technology without a corresponding sense of humility or responsibility, the result may be not progress but chaos and madness.

Reflection:

This project gave me a deep insight into the many challenges faced by independent game developers. Although I am not a full-fledged indie developer, the whole process allowed me to learn and practice various stages of game development in a comprehensive way. It was also my first time using Blueprints in UE5 to program interactions for characters, enemies, and items, as well as my first experience creating UI and Widgets.

During development, I had to balance visual quality, gameplay design, in-game prompts, difficulty settings, and the overall atmosphere, which is quite challenging for one person. For example, UI design is a field worthy of deep study, and the same goes for level design. However, with limited time and energy, it’s difficult to cover everything thoroughly.

In addition, due to unexpected problems and technical constraints, I had to give up some design ideas and visual effects. To maintain acceptable game performance, I changed the shading model from SM6 to SM5 and reduced the lightmap resolution for some larger actors. Without these optimizations, the game would have suffered from serious lag. Although these changes improved performance, they also reduced lighting quality and overall visual appeal.

During the packaging stage, I encountered code errors and navigation issues. While enemy navigation worked fine in the UE5 editor, in the packaged build enemies sometimes got stuck on walls and failed to chase the player properly. This problem didn’t occur in the test maps.

This experience improved my practical skills. When solving problems, I learned to prioritize game performance first, and then find a balance with visuals, gameplay, and other aspects.

Used assets and resources in this project:

1.Dark fantasy greatsword pack

Dark fantasy greatsword pack | Unreal Engine 5 + UNITY – Naked Singularity Studiohttps://www.youtube.com/watch?v=_xR6SHgfhPU

2.Morbid Pack

Morbid Pack Volume 1 – https://www.fab.com/listings/8b88ac2e-9b50-4381-91d1-46683a89178b

3. Serpent Model I Created in Last Semester — Collaboration Units
(Full process: modeling, UVs, texturing, rigging)

4. Gargoyle Model I Created in Last Semester — Collaboration Units
(Full process: modeling, UVs, texturing, rigging)

5.Texture repaint (arm, zombies, skeleton, gun)

In my discussion with Serra, she suggested that I try modifying the model textures myself. Assets like the gun and the arm are way too common and a lot of people use them, so I redrawed the textures myself.

Skeleton texture – white and black:

Gun:

Arm:

6. Game Tutorial：

https://www.bilibili.com/cheese/play/ss32685?csource=Share_copylink&from_spmid=333.873.selfDef.purchased_lecture&plat_id=362&share_from=lesson&share_medium=iphone&share_plat=ios&share_session_id=B94F4E1E-BB07-40B1-83E1-A53774E26305&share_source=COPY&share_tag=s_i&spmid=united.player-video-detail.0.0&timestamp=1747402290&unique_k=528infI

• UI Page Design
• Interaction Design
• Character Dialogue Script & Box Collision Trigger

This week, I focused on polishing the project by adding some UI interfaces, creating door interaction blueprint, and implementing a few dialogue triggers for the main character.

UI Page Design

0:00:00 – 0:51:00

Game Main Interface:

In the game’s main interface, I used a camera that continuously films the serpent and added some camera shake effects to enhance the atmosphere：

This method of creating the main menu allows for a real-time dynamic background. Since the flowers and fog in the scene are subtly animated, it provides a more immersive effect compared to using a static pre-rendered image as the background：

Widget blueprint:

Level Blueprint:

When the level begins, I create the main menu widget and use the Set View Target with Blend node to switch the camera view to a dedicated one positioned for the menu background. I also set the input mode to UI-only and lock player input, so the player can’t move or shoot while on the start menu screen. Finally, I use a Play Sound 2D node to start the game’s background music：

Since I set the Z key as the input to start the game, once the player presses it, the player controller is obtained and keyboard input is disabled.

Then, the start menu widget is removed. I also added a camera fade node to avoid clipping issues, since the camera would otherwise pass through walls during the view target with blend node. The fade lasts for 2 seconds to smoothly mask the transition.

After that, I use set view target with blend again to switch the camera to the gameplay view and set the input mode to game only:

In-Game Interface:

The in-game interface consists of the health bar, ammo count, and the menu panel：

In game effect:

The health and ammo displays are updated in real time by referencing the player’s current stats. When either value falls below a certain threshold, the corresponding UI element changes color to alert the player.

In-game menu

I created an in-game menu where the player can view the control instructions, restart the game, continue, or quit the game.

In front of the starting hall, I added a box collision to trigger a key prompt showing “Press M to open the menu.”

The logic is similar to creating any widget: when the player enters the collision area, the widget is created and added to the viewport; when the player leaves, it is removed from the parent.

Mission result widget:

When the player opens the final door, the mission is considered successful, meaning they have successfully escaped, and the mission complete screen is displayed. If the player’s health reaches zero, the mission failed screen appears instead. In both cases, I use the same UI layout and simply use a select text node to determine which message to display.

In the player’s character blueprint, within the death system, I continue to use a create widget node after the player dies. Then I call a custom event from the mission result blueprint that displays the game result. In this case, I uncheck the if win boolean, since the player’s health reaching zero means the mission has failed. As a result, the select text node will display the mission failed message accordingly.

When the mission is successful, I added a box collision in the final door room. When the player enters it, the widget is displayed.

Character Dialogue Script & Box Collision Trigger

0:51:00 – 1:09:00

For the character’s voice lines, I used ChatGPT to help write the dialogue and Eleven Labs (https://elevenlabs.io/app/speech-synthesis/text-to-speech) to generate the voice. The protagonist is a seasoned mercenary who often complains about his boss during missions.

When designing the dialogue, I felt it was important to give the player some basic context right at the beginning, like why the protagonist is here. So at the start of the game, there’s a short conversation between the commander and the protagonist, explaining that this is a mission to investigate abnormal lifeform activity and retrieve experimental samples.

Since I initially didn’t add trigger boxes to create widgets(just some triggers to play 2d sounds), most of the mission hints like finding the key downstairs or collecting statue fragments are delivered through the protagonist’s voice lines.

He complains about the job while also subtly guiding the player on what to do next. This dual-purpose dialogue helps keep the pacing natural while reinforcing the character’s personality.

Interaction blueprint:

1:09:00 – end

In this part, I mainly worked on the blueprint logic for two doors: the small door downstairs and the final main door.

The small door requires a key to open. I placed two keys in the level to ensure that players can still progress even if they miss one. The final door requires the player to collect three statue fragments to unlock it. In total, there are six statue fragments scattered throughout the level.

The blueprint is mainly divided into three parts. The first part uses a timeline, lerp, and set relative rotation nodes to animate the door opening.

The second part handles the logic for checking how many keys the player currently has versus how many are required.

The third part adds a box collision that triggers different widgets to prompt the player. For example, if the player lacks enough keys, it displays a message indicating that a key is needed. When the key requirement is met, it shows a prompt to press the F key to open the door.

This week, I focused on fixing the issues related to the gargoyle’s physic mimics after death, and continued working on the attack damage detection system for the gargoyle enemy.

Physical collision problem:

Another issue that took me quite a bit of time to deal with was the gargoyle’s physical collision. After enabling simulate physics, I noticed that the gargoyle’s body would twist and rotate unnaturally, and the collision response was inaccurate. This is because UE5’s default physics collision is automatically generated based on the skeleton, which often doesn’t work well, especially for complex models like this one. The calculated collision volumes frequently don’t match the visual appearance of the mesh.

To fix this, I had to manually adjust the collision shapes for each bone, making sure their forms matched the model more closely. Although this process was time-consuming, the results were much better. The corpse no longer clips into the ground or flails around unnaturally:

There was also another small but important detail: bullet impact force. Since bullets in my game travel fast and carry a lot of impulse, if the player kept shooting after the gargoyle died, the corpse would sometimes get launched or spin wildly into the air. It looked like the body just disappeared under fire:

To prevent that, I set the Mass value of the gargoyle’s physical asset very high. This way, once it enters the death state, it stays grounded and barely moves, even under heavy gunfire. It simply collapses and remains in place, without being knocked across the room by the player’s attacks.

Attack detection:

For attack detection, I followed a similar approach to how I handled zombies. I created two Blueprint classes: one for Attack Start and another for Attack End.

These blueprints are used to get the socket locations of the bones at the beginning and end of an attack. Since the gargoyle sometimes attacks with its left hand and sometimes with its right, I couldn’t hardcode the detection logic in the character blueprint：

I added a sphere trace node, using the socket location as the center. This allows the detection area to be a spherical range around the attacking bone, and I can adjust the radius based on the actual attack reach. Once a hit is detected within that sphere, the damage is applied using the Apply Damage node.

In the gargoyle’s animation asset, I added a second notify track since the first track is used for attack sound effects.

On this second track, I inserted the previously created Blueprint classes for Attack Start and Attack End at the appropriate moments in the animation. Because attack damage detection happens every tick while it’s active, keeping it running constantly would be too performance-heavy. By placing these notifies only during the wind-up and impact portions of the attack animation, I can limit the calculation to just the moments when it’s actually needed.

This two weeks, my main task was to complete the blueprint scripting for the gargoyle enemy. Before writing the blueprint, I first needed to finish the animation assets for the gargoyle. I created new folders to better manage them, which are: attack animations, hit animations, death animations, idle, and walk animations.

Below is a video showing my full workflow：

To fix this, I export the retargeted FBX from UE, adjust the neck joints by rotating them properly in Maya, bake the keyframes there, and then export the corrected FBX back into UE5. I also added some additional movement details to the wings and arms, and removed unnecessary keyframes to make the animation cleaner and more efficient.

This whole process was actually much more exhausting than writing the blueprint itself because I had to constantly export and import files between two different software. Also, since the gargoyle’s running animation looked rather awkward and lacked a sense of threat, I ultimately decided not to use the running animation asset in the final version of game：

Write gargoyle blueprints

The blueprint for the gargoyle is almost the same as the one for the zombie, except for the different animation assets and animation blueprint. However, due to the different attack hit detection, I will rewrite its blueprint from scratch：

While debugging the gargoyle enemy’s death blueprint, I met a tricky problem. My original plan was to have the enemy play a death animation first, and then switch to simulate physics so the body could fall naturally. However, in practice, this caused major issues. Even after the animation finished playing, the gargoyle would still retain its previous AI logic. It continued executing its “AI Move To” behavior and kept rotating to face the player:

I tried many solutions, such as forcefully disabling the AI Controller, disconnecting the movement logic in the Blueprint, and even delaying the state transition. But none of them worked well. The gargoyle always ended up in a weird “half-dead” state where its AI was still running, which clearly wasn’t right.

In the end, I decided to abandon the death animation altogether. When the gargoyle’s health reaches zero, I immediately enable simulate physics and turn it into a static mesh. It then collapses naturally, and I set it to be destroyed after 10 seconds. Although this skips the animation transition, the enemy now falls quickly and smoothly, avoiding all those awkward leftover AI behaviors. In fact, the overall effect feels more natural this way.

This reminded me that many games actually handle enemy deaths like this. In several games I’ve played, enemies don’t bother with long death animations—they just drop instantly, with ragdoll physics handling the fall. Boss fights are a bit different, often featuring dedicated death animations, but even then the corpses usually disappear quickly, often accompanied by some kind of special effect.

With that comparison in mind, I think my current approach is a reasonable one. For regular enemies, keeping the combat flow smooth is more important than playing a full death animation. And since the gargoyle is just a basic dungeon enemy in this case, there’s no need to spend extra resources on its death presentation.

Even though I had to let go of my original plan, I’m actually quite happy with how it turned out. In game development, we often have to balance ideal designs with practical realities.

This week, I continued working on level construction, with a focus on building the dungeon area.

Working process:

• 00:00 – 10:52 : Completed the construction of the second half of the dungeon.
• 10:52 – 20:50 : make landscape and flower in the middle area
• 20:51 – 30:25 : Built the bridge and the final gate.
• 30:29 – 39:56 : Used physics-based drops to scatter debris and built the rocky walls.
• 39:56 – 47:57 : Write the blueprint of small gate and key
• 47:57 – end : Refined the space behind the corridor and the small door.

In the game world, the player starts in a grand hall filled with knight statues. This hall was once a sacred place dedicated to the worship of heroes and the goddess. Together, they sealed away a powerful being known as the Serpent.

Though they couldn’t destroy it completely, they managed to imprison it deep within this place. To guard the seal, the people built this ancient site and placed stone gargoyles as protectors.

However, over the years, the goddess and heroes vanished, and the memory of their purpose faded. One day, a descendant of the nobility discovered that the Serpent’s blood possessed miraculous powers—it could cure diseases, and even bring the dead back to life. Driven by greed, he secretly constructed a dungeon in a side chamber next to the main hall, using condemned prisoners and corpses for inhuman experiments in an attempt to harness this forbidden power.

When the player reaches the end of the hallway, they’ll discover an underground space. While designing this area, I wanted to create a sense of complete darkness, with no light sources at all. To progress, the player needs to turn on their flashlight. This creates a circular highlight in the scene, which not only guides the player’s focus but also helps enhance the overall sense of immersion.

When creating this scene, I used the previously mentioned Packed Level Actor method to combine the statue, vessels, gargoyle, and dragon-head sculpture into a single level instance. This area represents the place where those mad experimenters offered blood in their rituals.

Used plugin: Dash：

I use Dash to help me better organize assets. It makes the assets more visual. Although you can also use filters in folders, Dash feels a bit more convenient.

It also lets me use physics simulation brushes to scatter objects on the ground, and vine brushes to create vines on walls. But these tools can be a bit tricky to use.

However, when the project entered the later packaging stage, as the pressure of optimizing lighting and materials increased, I had to face a reality.

These vines brought a large lighting and performance overhead. For a game that needs to run smoothly and allow real-time player interaction, I had to delete them to ensure a smooth frame rate. The same applies to the point lights on the torches in the knight hall. I had to set them to static lighting because the knight statue actors are too large, and too many lights would bring a large overhead.

Compared to film production, this made me realize a core principle in game development. The balance between visuals and playable runs. I need to make choice and put limited resources where the player really needs to experience them.

Assets I used:

1.Dark fantasy greatsword pack：

2. Morbid Pack：

My process of building environment:

I tried for a long time to create volumetric lighting to achieve the Tyndall beam effect, but I wasn’t successful. So I had to make a fake light beam myself:

I added cube models, stretched them, then duplicated and rotated them six times to form the light beam model.

I used two texture assets from UE5’s built-in engine content pack to create a light beam.

The effect I get:

Create packed level actor

During the asset setup stage, I followed this tutorial and learned a really useful method called “Create Packed Level Actor.” It’s a great way to combine many different assets—it can regroup various assets into one big, rich new asset and pack it into the level, so it can be moved around freely.

The “Group” function in UE is really hard to use, because when rotating or moving, the pivot points of the parts need to be manually re-aligned. Otherwise, after rotation, their positions will shift and break the original composition.

I used this method to build almost all the complex assets in the game, such as staircases, the knight statue hall, some complex combined statues, tables, and the platform where the serpent is placed.

However, this method also has some downsides. When I try to place an actor inside a packed level actor, sometimes it stops working. Also, when complex actors are nested together, modifying them can cause some models to disappear. If I go into the original level where the model was made, all the parts are still there—but when I drag the actor into a new level, some of them are missing.

This cost me a lot of time when making the knight statue hall. I nested individual knight statues with a full row of statues and added blueprint components for the torches. The problem was, when I tried to modify the actor at the second level, going back to the first level wouldn’t save my changes—so I ended up losing the parts I just modified.

Also, in this setup, the blueprint components for the torches couldn’t display correctly. So what I did was place the torches separately instead.

When building the stairs, I also used the “Create Packed Level Actor” function. I created a stair module, so I can combine them to form multiple staircases.

When I first started building, I honestly didn’t know where to begin. The assets were like thin sheets of paper, so I had to manually align and connect the stair sections. Since there were gaps between the bottom of the assets and the stairs, I had to use single-sided walls to close those openings.

However, because these assets are quite modular and open-ended, there are many possibilities when it comes to rebuilding and reshaping the staircases.

This week, I had a lot on my plate — I devoted almost all of my time to this project. Trying out Blueprints and building the game was incredibly exciting for me, and along the way I encountered many challenges.

Here’s what I worked on this week:

1. Created the blueprint for the enemy zombies

2.Repaint the texture

In my last discussion with Serra, she suggested that I try modifying the model textures myself. Assets like the gun and the arm are way too common and a lot of people use them, so I’m planning to redraw the textures myself. Also, I noticed that the zombie and skeleton materials aren’t very high quality, so I redrew those too and tested them in Unreal Engine.

When I was painting the zombie textures, I wanted them to look more gruesome and fleshy. Although it’s not exactly bright, positive, or uplifting, it fits the overall game background.

In this game, the goddess and heroes sealed the Serpent but couldn’t kill it. Many years passed, and both the goddess and heroes disappeared without a trace. Some nobles discovered that the Serpent’s blood could cause mutations, and even had powers like resurrection and life extension. So, they built a dungeon near ancient ruins to conduct experiments. These zombies and skeletons are the tragic results of those experiments.

Skeleton texture – white and black:

Gun:

When I was painting the gun and arm skins, I actually really enjoyed it. As a player myself, I love buying skins in games, so having the chance to create them this time was exciting. I wanted to make the skins a bit more stylized and fun. Since the overall tone of the game isn’t very bright or lighthearted, I wanted the main character to look a bit more positive.

Arm:

When I was painting the arm, I added some paint-like graffiti, a fabric texture for the glove, and visible veins on the arm.

3. Build environment

Assets I used:

1.Dark fantasy greatsword pack：

2. Morbid Pack：

Morbid Pack Volume 1 – https://www.fab.com/listings/8b88ac2e-9b50-4381-91d1-46683a89178b

My process of building environment:

I tried for a long time to create volumetric lighting to achieve the Tyndall beam effect, but I wasn’t successful. So I had to make a fake light beam myself:

I added cube models, stretched them, then duplicated and rotated them six times to form the light beam model.

I used two texture assets from UE5’s built-in engine content pack to create a light beam.

The effect I get:

Create packed level actor

During the asset setup stage, I followed this tutorial and learned a really useful method called “Create Packed Level Actor.” It’s a great way to combine many different assets—it can regroup various assets into one big, rich new asset and pack it into the level, so it can be moved around freely.

The “Group” function in UE is really hard to use, because when rotating or moving, the pivot points of the parts need to be manually re-aligned. Otherwise, after rotation, their positions will shift and break the original composition.

I used this method to build almost all the complex assets in the game, such as staircases, the knight statue hall, some complex combined statues, tables, and the platform where the serpent is placed.

However, this method also has some downsides. When I try to place an actor inside a packed level actor, sometimes it stops working. Also, when complex actors are nested together, modifying them can cause some models to disappear. If I go into the original level where the model was made, all the parts are still there—but when I drag the actor into a new level, some of them are missing.

This cost me a lot of time when making the knight statue hall. I nested individual knight statues with a full row of statues and added blueprint components for the torches. The problem was, when I tried to modify the actor at the second level, going back to the first level wouldn’t save my changes—so I ended up losing the parts I just modified.

Also, in this setup, the blueprint components for the torches couldn’t display correctly. So what I did was place the torches separately instead.

When building the stairs, I also used the “Create Packed Level Actor” function. I created a stair module, so I can combine them to form multiple staircases.

When I first started building, I honestly didn’t know where to begin. The assets were like thin sheets of paper, so I had to manually align and connect the stair sections. Since there were gaps between the bottom of the assets and the stairs, I had to use single-sided walls to close those openings.

However, because these assets are quite modular and open-ended, there are many possibilities when it comes to rebuilding and reshaping the staircases.

Used plugin: Dash

I use Dash to help me better organize assets. It makes the assets more visual. Although you can also use filters in folders, Dash feels a bit more convenient.

It also lets me use physics simulation brushes to scatter objects on the ground, and vine brushes to create vines on walls. But these tools can be a bit tricky to use.

This week, I completed the following tasks in the character blueprint:

• Set up footstep sounds
• Added mouse input for aiming down sights
• Created a transition to zoom the head during aiming
• Adjusted walking speed while aiming
• Added depth of field effect when aiming
• Set footstep sounds specifically for aiming movement
• Created the weapon blueprint
• Wrote a custom event for weapon firing
• Added a weapon state machine
• Added weapon sound effects, bullet effects, and reload effects
• Implemented bullet hit effects
• Created a function to count bullets
• Built the reload blueprint
• Added natural bullet spread
• Added recoil effect when firing
• Added bullet glow effects

This week, my main focus was still on blueprint scripting. Once the character and enemy blueprints are done, I can just drag them into the map and use them directly. Although there are many follow-up steps afterward, the blueprints are definitely the top priority.

After finishing them, I’ll move on to reworking some model textures, building the scenes, creating the UI and main menu, and finally packaging the game.

Set up footstep sounds:

I selected the audio files and created a single cue. Then, I added an audio modulator to unify the pitch and volume across these sounds, while also introducing random variations in pitch and volume. This way, when played back, the audio feels much more dynamic and natural：

Then, I went back to the animation asset and added a “Notify” — “Play Sound” — selecting the sound cue I just created.

Added mouse input for aiming down sights

Similar to before, I added mouse input, set it up as IA_focus (for aiming function), and linked it inside the character blueprint. This lets me control the focus with the mouse smoothly.

I used a timer to make the aiming zoom effect transition more smoothly. This approach will also come in handy later for toggling the flashlight and handling other action transitions.

Adjusted walking speed while aiming：

In the speed calculation function, I added a condition that if the character is aiming, the selected float value becomes 150(150 for the speed of walk with aiming).

Then I add blueprints for the weapon, cause there are some functions like reload ammo and ammo calculation, I need to split these from character blueprint, otherwise, it will be mass.

Then, in the weapon blueprint, attach (or spawn) the weapon to the character’s arm.

In the weapon blueprint, I set up the following event icons: fire_weapon, change bullets, and recoil.

In fire_weapon, I configured three states: start firing, firing, and stop firing. Then I used play animation montage to connect the animation assets to each of these states.

The rest of the operations are all shown in my screen recording：

This week, I mainly worked on setting up the character blueprint, including:

• Character capsule setup and camera setup
• Character state machine setup (idle, walk, run)
• Implemented camera rotation control using mouse movement
• Added shift key input to trigger the running state and linked it to the state machine, enabling communication between the character blueprint and the animation blueprint
• Added weapon drag effect (weapon swings slightly caused by camera movement)
• Added character detail lighting (I wanted to create a warm light to simulate a body-attached light source, combined with a cold light for contrast)
• Effect testing

Before getting started, I will provide all the assets I used and the link to the tutorial I followed. Since the tutorial I found is from the Chinese platform Bilibili, I won’t be able to share a YouTube link for the video resource.

Assets used:

1.Environment:

2. Morbid Pack

Morbid Pack Volume 1 – https://www.fab.com/listings/8b88ac2e-9b50-4381-91d1-46683a89178b

3. Serpent Model I Created in Last Semester — Collaboration Units
(Full process: modeling, UVs, texturing, rigging)

4. Gargoyle Model I Created in Last Semester — Collaboration Units
(Full process: modeling, UVs, texturing, rigging)

5. Tutorial：

https://www.bilibili.com/cheese/play/ss32685?csource=Share_copylink&from_spmid=333.873.selfDef.purchased_lecture&plat_id=362&share_from=lesson&share_medium=iphone&share_plat=ios&share_session_id=B94F4E1E-BB07-40B1-83E1-A53774E26305&share_source=COPY&share_tag=s_i&spmid=united.player-video-detail.0.0&timestamp=1747402290&unique_k=528infI

Character capsule setup and camera setup：

At the beginning, I set up the Animation Blueprint, Character Blueprint, and Blend Space for the character.

When I started setting up my character, the first step was to create a Character Blueprint. Inside the blueprint, I added the character mesh and carefully adjusted its position so it sat correctly within the capsule collider. This ensures that the character’s mesh and collision boundaries are properly aligned, which is really important for smooth movement and interaction.

I applied the same process for setting up the camera. I attached the camera to the character blueprint and positioned it in a way that works well with the gameplay perspective I want to achieve.

These might seem like basic steps, but getting them right early on saves a lot of trouble later in the pipeline—especially when starting to work with the animation blueprint and player controls.

Character state machine setup (idle, walk, run)：

Inside the Animation Blueprint, I set up the State Machine, including Idle, Walk, and Run states.

In the Blend Space, I blended the Idle, Walk, and Run animations, and set up the corresponding movement speeds.

For example, I set the walking speed to 300 and running speed to 750. Since my scene is quite large, I needed the character to move a bit faster to fit the scene.

Implemented camera rotation control using mouse movement：

在角色蓝图的文件夹中，我增加了输入的文件夹，并加入了鼠标可以控制角色摄像机视野旋转的input action：

I also changed the bool input to Axis 2D, since the mouse controls the camera rotation based on X and Y movement on the screen plane. Using a bool would only allow simple on/off states, while Axis 2D lets me read continuous input values, which is more suitable for smooth camera control.

I used the Input Mapping Context to organize all the input settings and define the input devices, making the control setup more clean and modular.

I added a Look event in the event graph to call IA_look：

Added shift key input to trigger the running state and linked it to the state machine, enabling communication between the character blueprint and the animation blueprint：

Similarly, I set up the Shift key input within the Input Mapping Context.

I added an if-run boolean check in the running graph. Then, I created a speed calculation function that uses this boolean—if the character is running, it sets the speed to 750, otherwise to 300.

Added character detail lighting (I wanted to create a warm light to simulate a body-attached light source, combined with a cold light for contrast)：

This was my first attempt at adding a warm light attached to the character, so I added a point light inside the capsule.

Later during testing, I adjusted the light settings and created a toggleable flashlight-like feature for illumination.

This week, teacher introduced some experimental opportunities we can explore this semester, so I’m thinking that I might take this chance to push myself and create an FPS shooting game.

Recently, the second season of The Last of Us has been airing, and I really love its art style. The decaying cities are covered by plants, and people embark on a survival journey.

What sets this work apart from other zombie-themed works is that it more realistically reflects a cruel and heartless world. For example, under the rampant spread of cordyceps fungus, the government not only fails to provide shelter to the people but instead takes those who are uninfected in surrounding towns under the pretext of sending them to safety zones, only to kill and cremate them in the wilderness. The reason is that the higher-ups believe that if these people die, they won’t be infected in the future, which would reduce their workload.

After the outbreak, other survivors desperately scavenge for resources in order to live. Some even use lies to lure others in, only to kill them and steal their supplies when they least expect it. In that world, humans seem to have become even more terrifying than the zombies.

Inspired by this, I want to make a zombie FPS game. However, I need to think about how to make it and what the protagonist’s purpose in the game would be.

So, I’ve been researching the art design of The Last of Us to get some inspiration：

We can see that most of the city scenes are open and spacious, while enclosed areas usually feature a focal point that draws the player’s attention, along with strong lighting contrasts to guide them in the right direction. Since I’ve never tried designing game levels before, I don’t really have a clear idea of where to start.

I’ve built a game level in Unreal Engine where the player can move back and forth. The layout is shaped like a “U”. The player spawns underneath a collapsed overpass and needs to find the correct path by navigating through the wreckage and abandoned cars. Along the way, zombies will appear to challenge the player.

In terms of gameplay expectations, the player can see their destination—an area filled with tall buildings—in the distance from the overpass. This visual cue encourages the player to explore and figure out how to reach that location. When the player discovers a way to climb the collapsed structure and get onto the overpass, they gain the opportunity to observe their surroundings from a higher vantage point.

The first area is designed like an isolated island, so the player needs to traverse vehicles and the overpass to reach the second section. I want the player to do more than just stand in one place shooting zombies—I want them to actively explore the city, using collapsed structures and debris to discover new paths and move from one location to the next.

The second area the player reach is partially submerged in water, so they have to move forward by stepping on sunken cars. If the player falls into the water, they will die.

I referenced this picture:

Then, while building the level, I imported Unreal Engine’s first-person shooter template to test it. Through testing, I discovered that there are some issues with the scene.

For example, the player needs a strong motivation to explore the map and receive positive feedback—but figuring out how to design that feedback loop is quite challenging.

The second issue is that the scene is too open and expansive, which results in endless skylines in the distance. If I were to build out all the surrounding buildings, it would require a massive amount of work.

A massive map would make the entire gameplay flow more complex. So I think I need to find an alternative approach, even though I’m quite reluctant to let go of this level.

Find Plan 2:

How can a zombie shooting game remain engaging when the scene is smaller in scale? How can I make the decaying environment more interesting?

I was reminded of Escape Room, where the protagonist is tricked by a company—thinking they were just joining a regular escape room game, only to realize that failure means death. So I started wondering if I could incorporate something similar into my game.

For example, the protagonist could also be participating in what they believe is a live-action immersive experience, but it turns out they’ve been deceived and thrown into a zombie-filled environment. They must outsmart the zombies and gather materials to repair the safehouse door lock in order to escape. Meanwhile, everything is being livestreamed by the company for profit. When the protagonist defeats a zombie, viewer reactions and comments would pop up in the bottom left corner of the screen, showing the audience’s responses in real time.

However, although this idea is quite diverse, it would be difficult to implement. For example, how to write the blueprint for delivering items（like find, pick tool to fix the safe door), and how to design a real-time feedback system in the bottom left corner similar to a live stream. I searched online for tutorials but couldn’t find much to reference, so I need alternative solutions.

Find Plan 3:

I thought I could continue my game design based on some tasks I completed last semester. In our group project last semester, we designed a dungeon short film, but due to some factors, the entire scene turned out quite dark, and my model didn’t look great in the scene. So, I thought I could design my own dungeon game, using the gargoyle as one of the enemies.

I tried using Mixamo’s animation library and motion mapping to implement actions like attack, chase, idle, knockdown, and hit reactions. However, I still need to adjust the animation blending and manually keyframe the wing animations：

This way, I can apply the model assets I previously created to design a game, which I think will be quite meaningful.

So, I plan to create a first-person, single-player game set in a dungeon. The protagonist is a member of a mysterious organization, sent to investigate supernatural occurrences and deal with the roaming monsters. The story’s opening is somewhat similar to the beginning of Resident Evil, where the protagonist goes to a strange village or eerie mansion to investigate and ends up killing the leader inside.

Although the game might not have deep spiritual themes or messages, I want to learn how to write blueprints and the process of creating game enemies, and I believe I will gain a lot from it.

Art style

In terms of art style, I suddenly thought of a game I played back in my primary school: Dark Meadow: The Pact，which was developed by Phosphor Games Studio based in Chicago, was built using the Unreal Engine 3 and was first released on the iOS platform (iPhone and iPad) on October 5, 2011.

The player wakes up in an abandoned hospital, having lost all memories of the past.

The only “guidance” comes from a man speaking through a loudspeaker. He claims he was once trapped here as well and tells you that the only way to escape this nightmare is to kill a being known as The Witch.

As the player battles monsters in the hallways, gains experience, and ascends to higher floors, the story unfolds—eventually revealing that The Witch is, in fact, the player’s own daughter.

Game Plan:

So, I wrote down all my game ideas to make sure I won’t forget them later. I’m planning to create two maps: the first one is a forest map on the surface, and the second is a dungeon map. I hope I’ll have enough time to finish both of them：