Graduate Portfolio - Character Animation - Gameplay Animation

Character Animation - Gameplay Animation

03/10/25 - 02/12/25

Introduction

This blog post explores the development of gameplay animations that have been implemented into Unreal Engine. This explores initial research to understand technical processes, development of animation loops and integration into the engine alongside visual coding blueprints to create a functioning character controller. 

Project Management

The image below shows the production schedule for this project. Everything is currently on track, however, it does feel quite tight with limited wiggle room. Regardless of this progress is being consistently made and there still feels enough time to finish all assets within the timeline. Due to being successful in a job interview, I am moving from part time (4 days a week) to full time which means in November I will be losing my Fridays on this project, however, weekends and evening will still be available. This does create a little bit of pressure, however, still feels achievable.

Below shows the Trello board. I still have the cutscene animation to make, however, I have an upcoming holiday that I may pause the gameplay animations for so that I can completely focus on the cutscene. This will mean this outcome runs a little longer, however, since gameplay loops can be started and completed in a day typically it makes this outcome feel a little more flexible. Whereas, the cutscene animation will require lots of iteration and polish over a greater number of frames that flow together, therefore, utilising a holiday to focus on that will be beneficial.

Research

I started this project with researching an array of key elements that I would need to explore so that I could anticipate the challenges I may face and understand the pipeline I would need to follow to produce a successful and playable character controller.

This video below (James, How Do I?, 2022) shows the pipeline for setting up a 3D model with textures in Unreal Engine. The key element here is that Substance Painter allows a packed texture export that uses RGB values for metalness, roughness and AO. Then using a node based material setup they can be correctly set up in engine.

This next video below (Aspland, 2023) shows  the pipeline for creating a character controller using common concepts such as importing animation, integration to the state machine and hooking up using a modified version of the third person character blueprint.

This next video below (Bohl, 2023) building on the ideas from the previous, however, due to the longer length in video provides a more detailed breakdown of the process. This will help me troubleshoot potential problems.

Next I found the below video (Ask A Dev, 2023) this is produced by a professional animator and shows a more detailed breakdown of the tools available and the scenarios they can be applied. This means that I can learn concepts rather than just following along with a tutorial which suits my learning style more.

All the previously cited videos focused on general locomotion, however, I also wanted to create and attack system. The video below (Unreal University, 2024) shows how a simple 3 point attack combo system can be created using custom animations. This utilises player input and the default slot node to trigger animations based on player input.

Character Integration

This image below shows how the materials were set up for the character using the packed texture nodes. The relevant channels from the textures are plugged into the different maps to ensure that the texture displays properly.

This image below shows all three textures set up on the character. This includes the head, eyes and body material as well as a separate material for the staff. This has integrated well and luckily doesn’t feature the inverted normals I was seeing in Maya due to the flipped UVs.

This image below shows the character placed inside the level environment with full scene lighting working, opposed to simply in the model viewer.

This image below shows the set up of the emissive material through exposing the intensity value. This means that a slide can now drive emission which potentially could be animated later.

This image below shows the character in the scene with no emission.

This image below shows the intensity of the emission turned fully on to maximum.

To see the effect of the emission even further the scene lighting was turned down low and you can see that it creates this cool sci-fi glowing effect which works well. Perhaps this could be animated later and used in conjunction with some of the animations. For example maybe it flashes as the character hits something.

The next pipeline challenge to solve was the export and import of the animations into the game engine. I had a few problems here where the character was stretching when I deleted the control rig. I was deleting the control rig because only the animated skeletal data was needed in the engine. After some research I found the video below (Peterson, 2025) which helped solve this issue. The animation wasn’t baking onto baked to the skeleton but rather than deleting the control rig and using a direct export I used the game export or to export the animations into engine, which solved this problem.

This gif below shows the first animation implemented into engine as well as the character on the third person controller being replaced with my character. This was such a relief because it meant the animation pipeline from Maya to engine was solved!

Gameplay Animations

Now that the pipeline was secure it was time to develop more animations that would be later implemented into the character controller to fully bring this character to life in engine.

Idle

The below video shows me acting out the animation for the idle. The plan here was to create a relatively generic combat focussed idle so that punches could easily come from this pose.

This gif below shows the initial development with this animation, however, some polish is needed to the hair and ears.

04/10/25

The gif below shows further development including animation refinement on the hair, ears, brows, hands and general polish. I also noticed the scene was set to 24 fps which was a rookie mistake given that games are animated to 30fps. I changed this and tweaked the key frames so that it worked on this frame rate. 

I noticed some odd deformation on the skinning and made tweaks to the chest, head, neck and jaw in referenced file, which was then updated in the animation. This made the character deformation look a little more believable. The overall animation was now looking good and particularly liked the offset in the arm motion and the subtle movements on the feet as the weight shifts across the legs.

This was then integrated into Engine along with the new Skeletal Mesh so that the updated skinning was present in engine too.

I had a lot of animations that I wanted to make, however, I knew I wasn’t going to have time for all these. Therefore I split the Trello card into 2 so that I had a Core Animation list and then advanced animations. If I had spare time I would experiment with the advanced animations, however, I now knew which ones were core animations that were essential to the character controller setup.

This shows the final list of core animations within the Trello card in the image below.

Run

05/10/25

Next I moved onto the run animation. I wanted an athletic run so I found the video below (Andre, 2010) which provided a good and realistic piece of reference that would support my animation development. 

I also looked at the Animator's Survival Kit (Williams, 2009) to remind myself of the key poses within a run animation. I would then be able to use the core timing but modify the poses to match the reference I gathered.

The gif below shows the initial blockout of the key poses in this run.

The next gif below shows further refinement to the feet and spine poses across the animation.

Next in the gif below there is more refinement to the body and arm poses.

Lastly the gif below shows the final polish with all elements of the character moving.

This gif below shows the animation working in game. This works really well as the sprint that would show the character at maximum velocity. It has a good range of motion and looks appealing from all angles which will work well for a 3D platformer/action game that this is intended to be.

Jump

08/10/25

Next I studied the Game Anim book (Cooper, 2019) to understand how the jump should be constructed. This showed that there should be a take off animation, in air loop and landing animation to create all 3 components that could be blended together. This is different from animating a jump in full for TV/film because the jump needs to be instant and respond to player input. Therefore, we need to loop the middle of the jump for as long as the player is in the air, which we won’t know. When the player reaches the ground we can run a short landing animation before blending back into locomotion. 

The gif below shows the initial development with the take off animation, however, is still unfinished.

10/10/25

This next gif below shows the completed take off animation. There is a little bit of anticipation, however, the character quickly flips into the loop poses. This is so the animation can hint at anticipation, however, get right into the jump pose as close as possible to the player input.

This next gif below shows the jump loop animation which will be blended too after the previous animation shown above. This is a simple subtle loop that includes some motion but can be looped until the character hits the ground.

The last gif shown below is the landing animation. This animation is very short because the player may continue running as they hit the ground and we want to reduce the amount of slide that can happen.

11/10/25

Now that I had 2 movement animations, an idle and a jump system I wanted to start making the character controller system so that these could all be triggered in real time.

This first image below shows blueprint visual code that gets the character and sets the character movement state.

The next image below gets the player’s speed and allows the character to switch from falling to not falling as well as determining whether the player is allowed to move or not.

This next image below shows the state machine that drives the character. This uses the variables identified in the previous two images and uses them to determine logic for which animation can play. A locomotion state machine is created and cached that can then be triggered. This essentially creates a fluid state that can be blended in and out of. This makes triggering other animations like jumps or attacks easier because you need less transitions. Instead you can determine what animations can be triggered from any locomotion state.

The image below shows the cached locomotion state that moves between idle and the walk/run animation blend space driven by player speed.

The image below shows how the speed of the character is being plugged into the blend space to drive the desired animation. Essentially if the speed is lowed then a walk animation will play and if it is higher a run animation will play in the walk/run state.

This next image below shows the expanded state machine. This shows how the cached locomotion state allows a jump to be triggered. This then blends into the fall loop unless the character makes contact with the ground in which the land animation will play. The land animation will also play if the character hits the ground whilst in the fall loop. After the landing animation is complete the character returns to the locomotion state which is driven by the player speed.

The video below shows this set up working in game driven by my controller input. Everything is working well, however, walk and sprint don’t blend well together and there needs to be more animations that reflect the speed of the character.

Slow Walk

12/10/25

This gif below shows a slow walk. This would play before the other walk animation and retains the cocky/confident personality that was present in the previous animation. This reflects the character personality that was outlined in the character bio. 

The image below shows the blend space that has previously been discussed. You can see the horizontal line with dots on - these dots are the animations and the length of the line is the player’s max speed. The speed drives where the blend is on the character and therefore what animation is playing. E.g. if it is between two animations then 50% of each will be playing - creating this blend. The more animations in this blend space then the better the blends will look since automatic blends tend not to work too well but subtle blends will work better. This is a great example of using creative and technical skills to create realistic movement in realtime.

The gif below shows the blend space working on the character. The slow walk and walk blend together really well and the transition is smooth. The walk to sprint still needs work through the introduction of a jog to make the transition more seamless.

17/10/25

To create the job I gathered the reference below (CG Reference, 2022). I tend to exaggerate poses a lot so I studied this footage to help understand the motion and keep some more subtle.

The gif below shows the developed jog animation. This features more subtle arm and leg motions compared to the sprint to hopefully bridge the walk and sprint animations more effectively.

The image below shows the updated blend space. This include the idle and the beginning so that this can blend into the walk directly here, this will mean that you can create an even slower walk through lightly pressing the movement stick. It also features the new jog animation and tweaks to the positions so that the speed matches the foot motions and reduces foot slide.

This gif below shows this in action featuring the slow walk, walk, jog and run with smooth blends. This now feels really responsive and makes the player acceleration look natural and smooth as the motions become larger at greater speeds and more reduced at lower speeds.

Double Jump

19/10/25

Next I wanted to implement a double jump system. I really wanted a front flip that would then blend into the pose below, however, I wasn’t sure how to do this through a trigger. I knew how to trigger an animation and keep this looping, so I could create an indefinite looping front flip, however, I thought this would be weird. Therefore, I decided to create a simple loop in the pose shown below that would contrast the previous jump pose.

I used the video below (Rotten Rabbit, 2024) to understand how this could be implemented into the game. This used a simple blueprint focussed setup to increment the amount of jumps up to a max of two and then reset this when the character hit the ground. This meant that the game would only allow 2 jumps which was the goal.

The gif below shows the completed double jump loop.

The gif below shows the double jump working in engine. It was a little difficult to get this working well, however, the jump force was experimented with to create some additional force but less than the original jump. It was also adding the force to the original jump, meaning if you did the double jump as you were accelerating up you would get more double jump power than if you did it as the character was falling down. To fix this I noticed there was an option to apply flat force on the double jump and when this was ticked it would reset the force and apply a flat amount of upward force. This meant that the double jump always applied the same level of force which solved this glitch.

Combat Animations

08/11/25

Now that the locomotion and jumping was fully working it was time to add the attack combo flexibility. I gathered the below video (Animation Reference Videos, 2022) to inform the quick jab which would be the first part of this combo.

I next found the below video (Jeffries, 2022) that shows how to deliver a successful uppercut. This will inform the second part of the attack combo. The direction given in the video shows that the hips drive a lot of the force, therefore this is something I want to include in my animation.

Lastly I found the below video (Gogan, 2024) which provides a good animated example that shows how a punch can be delivered in a game animation. Similar to the jump the player needs to press the attack button and get an instant result without too much anticipation, so this video shows how a couple of frames can be used for the anticipation before landing the hit and then slowly returning to the idle pose.

I then wanted to use so root motion so that the player thrusts forward as they attack to make the attack feel more impactful. The video below (Code On Fire, 2025) shows how this can be enabled in engine to prevent the character model from snapping backwards and instead maintaining the new end pose as their true location in the world.

Lastly I rewatched the below video (Unreal University, 2024) to remind myself of the core functionality. This made sure that I created the animations in a way that could be integrated into the engine easily.

Jab - Combo 01

The gif below shows the first attack in the combo, the jab. This holds slightly on the impact frame to create a good sense of power and also features some extreme poses to extend the attack before recoiling to further build the power.

Uppercut - Combo 02

09/11/25

The gif below shows the second part of the attack combo featuring similar techniques to the previous but with different poses and larger motions.

Rising Uppercut - Combo 03

14/11/25

Next I wanted to do a rising upper cut to finish the combo in a flashy way with the character leaving the ground. I found the below video (IGN, 2016) that shows a real person re-enacting a video game character’s motions. This helped me understand the poses needed for this rising uppercut.

The gif below shows the initial blockout and polish of this animation. This is still work in progress and more polish needs to be done to the overall movement, ears, hair, pauldrons and knee straps.

16/11/25

The gif below shows the final animations of the final part of the animation. All three animations are looking good, however, they need to be integrated into the engine to really gain a feel for how they work and look in a real-time scenario.

17/11/25

Using the concepts learnt so far I was able to integrate the combo system and root motion relatively easily, however, I was unable to get root motion in the Z axis (up). The gif below shows the problem this causes where essentially the character is glued to the ground despite the character leaving the ground on the rising uppercut part of the combo. Despite looking around there settings there didn’t seem to be any clear reason to why this was and when the animation was played in the viewer the root motion worked. Therefore, this needed further investigation and research as to why this wasn’t working.

By reading this forum post (Vaei, 2016) I learnt that when the character is on the ground the Z (up) axis is locked and in order to unlock it the character needed to be in flying mode. I did some research and came across the below video (Druid Mechanics, 2022) which showed how I could set up some simple blueprint code to set the character to ‘falling’ and trigger and reset this through and animation notifier.

The visual blueprint below shows the ability to set and reset the character movement state and ultimately set the character to enter falling mode. This was then directly used at the beginning and end of the animation to allow the character to leave the ground and reset this when the animation finishes.

This change has enabled the character to leave the ground and now the root motion is applying properly and the attack combo is playing as expected!

Level Design

22/11/25

Now that the character controller system was fully built and functioning I needed to build a gameplay space to present the animation. The idea was that this would be the first area of the game, where the player would start from after the crash landing cutscene I built. The plan was to download some rock assets and build a simple rocky gameplay environment that could show off locomotion, jumping and the attack system. I started with this small sketch below to plan the flow of the level. I added notes to highlight the key aspects that should highlight my animations well.

I acquired the following assets : 

• Spaceship 3d asset by L_Krajewski (SketchFab)
• Stylized Rock 01 3d asset by Agustin Honnun
• Stylized Rock 02 3d asset by Agustin Honnun
• Stylized Rock Diorama 3d asset by Agustin Honnun
• Stylized Small Low Poly Rocks 3d asset by JamyzGenius
• Alaskan Cliff Rock 15 3d asset by Tobias White
• Modular Rock 01 3d asset by UJJWAL CHAUHAN
• Worn Rock (Floor Material) asset by G4A Gaming Labs
• Fire VDB Pack Loop Real Time VFX asset by one.studio2

This enabled me to construct the environment shown in the images below.

This top down, annotated drawing shows the path that will be taken by the player. This starts at the ‘x’; then goes onto a jumping sequence for the first line of dots; then onto the next larger jumping sequence at the next dots and dashes before finally reaching a plateau for the combat animations to be showcased where the fist is marked.

The series of images below show the character in the environment from the perspective of the gameplay camera. This is to showcase shots of the environment as the player would see them.

23/11/25

To further improve continuity I added the spaceship 3D asset to the environment and added a flaming particle system. This shows the spaceship crash landing to further link this gameplay sequence to the crash landing cutscene animation. This is in the location where the player will start this sequence so they instantly see the burning spaceship.

Overall the level design process went well. I didn’t need everything to be perfect from a game design perspective because this was simply to showcase the animations I’d made for this character controller. Colliders on the 3D assets were a little tricky to get right. Some of the simple collider options would create large areas that restricted movement and would have needed custom controllers creating. To combat this I removed colliders from most objects except the large flat platforms. As I said before, I didn’t need this to fully function as a game so I could simply avoid collision with the character for the purposes of the animation presentation.

Recording Footage

Next I needed to find the best way to record the footage from the engine. Since I knew that Unreal was used to render animations I assumed this process would be fairly easy. I found the below video (EZ Unreal, 2024) that showed a process for recording gameplay footage using the sequencer that seemed to work well. In practise it didn’t properly capture the exact camera input I was making and instead created its own camera fixed to the back of the character. This meant I wasn’t able to capture the exact motions I wanted. 

I did some further research and found this video (hawaiifilmschool, 2024) that looked at the scene recorder system. This essentially records the player input and always it to be played back - effectively baking an animation of the character moving based on the player input. I was then able to access specific cameras or add custom cameras and use these to render out a video. The best option was often to create custom cameras that tracked the movements and then create a series of clips that could be later edited together. This process took longer than expected, however, it seemed to be the best way to render high quality videos out of Unreal Engine. 

Now that I’d solved the render pipeline issue I created a short plan for the clips that would be captured. This would then enable me to create these sequences and create the rendered videos. The sequences required were :

1. Idle in the starting location
2. Walk past ship casually (slow walk blending through locomotion animation to run)
3. Jump up platforms to reach a height.
4. Jump across the platforms with gaps between to showcase the double jump
5. Jump up to top platform.
6. Idle to Combat loop on top to cycle through all attack animations.

This video below shows the captured clips edited together. I am also going to add rendered animations of each individual loop from different angles to the end of this video. This will help further showcase the work that I have completed on this outcome.

02/12/25

I rendered all the animation, however, I ran into another issue. One of the Maya animation files I rendered showed the character with really shiny materials opposed to how they should look. This meant that two of the loops had a different render quality to the rest of the animation which was jarring to watch as they transitioned. The shiny materials can be shown below.

I knew that this was something to do with a change that had been made to the materials. This was a referenced file so I tried refreshing the reference, however, this didn’t work. Ultimately you could animate a material therefore referenced files allow you to alter the materials. This was frustrating because I couldn’t find the exact values that had changed. After much investigation and experimentation I found that it was possible to open a window that would show all the changes made to a referenced file. Most of the changes were animation changes, however, when I scrolled through I was able to pin point the materials changes as shown in the image below. 

Once I reversed these changes in this window I achieved the render quality as shown below. This now matched all other rendered animations, which ultimately improved the overall presentation of these individual animation loops.

Final Outcome

This last video below shows the final animation featuring the in game animation capture and the individual rendered anima

Also in higher quality on Vimeo : https://vimeo.com/1139831160

Conclusion

Overall, this project was a really valuable learning experience that helped me better understand gameplay animation as part of a real-time pipeline, rather than treating animation as a standalone outcome. The focus on getting animations working properly in Unreal Engine pushed me to think more technically about my decisions and how animation impacts player feel and responsiveness. Creating and implementing a full set of core gameplay animations, including locomotion, jumping and attacks, helped reinforce the importance of modular animation, blend spaces, state machines and blueprint logic when building game-ready characters.

I also learned a lot through problem-solving and iteration, particularly around exporting animations from Maya, handling materials correctly and understanding the limitations and use cases of root motion. Although balancing the project alongside full-time work was challenging at times, it encouraged better planning and more focused iteration. Overall, this project has helped bridge the gap between animation and implementation for me, and I now feel far more confident creating, integrating and troubleshooting gameplay animation within Unreal Engine.

The overall quality of the outcome was good, although I would have liked to spend more time developing a more complex animation system. Despite this, all core animations are in place and the systems I developed provide a strong foundation that could be built on further. The combo animation system worked particularly well once I resolved the locked root motion issue. The locomotion blend space also performs well, using speed-driven blending to create smooth transitions between animations. The final rendered video clearly shows the amount of work that went into this project and presents the animations in a clear and polished way.

References

1. Andre, D. (2010) Up Hill Training-Speed Treadmill Going Vertical. 20^th August. Available at: https://youtu.be/futHz1mQIBI (Accessed: 20 December 2025).
2. Animation Reference Videos (2022) Punching on bag/ Boxing Reference- Animation Reference Videos. 9^th November. Available at: https://youtu.be/TaNWKoytdOE (Accessed: 20 December 2025).
3. Ask A Dev (2023) Animation Blueprint Intro | Unreal Engine Tutorial. 1^st November. Available at: https://www.youtube.com/watch?v=jIsccLR9U88Ymsabf0ZQuE (Accessed: 20 December 2025).
4. Aspland, M. (2023) How To Make An Animation Blueprint In Unreal Engine 5.1 | How To Animate A Character - UE5 Tutorial. 19^th February. Available at: https://www.youtube.com/watch?v=qbgDaRo312k (Accessed: 20 December 2025).
5. Bohl, E. (2023) How to Make a 3rd Person Character in UE5. 17^th January. Available at: https://www.youtube.com/watch?v=Ymsabf0ZQuE (Accessed: 20 December 2025).
6. CG Reference (2022) Gentle jogging - Side view - Animation reference. 21^st September. Available at: https://youtu.be/J8I4ftrbmRI (Accessed: 20 December 2025).
7. Code On Fire (2025) Unreal Engine: What Root Motion is and how it works. 27^th April. Available at: https://youtu.be/efdDTnEolIc (Accessed: 20 December 2025).
8. Cooper, J. (2019) Game Anim: Video Game Animation Explained. 1st Edition. Florida: CRC Press.
9. Druid Mechanics (2022) Using Mixamo Root Motion Animations in Unreal Engine 5. 6^th July. Available at: https://youtu.be/f32fzAuJyZU (Accessed: 20 December 2025).
10. EZ Unreal (2024) EASILY Capture In-Game Video Footage in Unreal Engine 5 (UE 5.4 Tutorial). 6^th May. Available at: https://youtu.be/LmE1rgCR6YA (Accessed: 20 December 2025).
11. Gogan (2024) How to ANIMATE a PUNCH QUICK TIP. 22^nd July. Available at: https://youtu.be/Lg-F_0wsncg (Accessed: 20 December 2025).
12. hawaiifilmschool (2024) The Scene Recorder AKA The Take Recorder in Unreal Engine (something important to understand). 31^st August. Available at: https://youtu.be/5T9ItX2_p-g (Accessed: 20 December 2025).
13. IGN (2016) Street Fighter in Real Life - Ken's Move Set. 23^rd February. Available at: https://youtu.be/nZ67ByLSmfs (Accessed: 20 December 2025).
14. James, How Do I? (2022) Substance 3D Painter Textures into Unreal Engine 5 Including Emission. 19^th September. Available at: https://youtu.be/wcpz9_stKgs (Accessed: 20 December 2025).
15. Jeffries, J. (2022) The Correct Way to Throw Uppercut. 18^th January. Available at: https://youtu.be/eBxn21FtqPg (Accessed: 20 December 2025).
16. Peterson, L. (2025) How AAA Studios Export FBX Animations From Maya To Unreal Engine. 17^th February. Available at: https://youtu.be/fjSQti0gSoU (Accessed: 20 December 2025).
17. Rotten Rabbit (2024) Double Jump Tutorial | Unreal Engine 5. 18^th October. Available at: https://youtu.be/0C4kr_8ZTmg (Accessed: 20 December 2025).
18. Unreal University (2024) How To Make An Attack Combo System In Unreal Engine 5. 20^th August. Available at: https://youtu.be/Q5xk5PYlQ1k (Accessed: 20 December 2025).
19. Vaei (2016) ‘How to set up root motion jumping?; Unreal Engine, 15^th June. Available at: https://forums.unrealengine.com/t/how-to-set-up-root-motion-jumping/360874/2 (Accessed: 20 December 2025).
20. Williams, R. (2009) The animator’s survival kit: Expanded edition. London: Faber and Faber.