Embedded Files
Lead Paragraph
In this update, I worked on bringing the player character to life by implementing animations. I’ll go over how I received the animation assets, what problems I ran into while trying to use them, and how I learned to work with Unity’s Animator system, animation states, and timing controls to get everything working smoothly in-game.
Why did we work on animations?
Until now, the player’s movement and combat systems functioned well, but visually, the character was completely static (just sliding around the screen). This made the game feel lifeless and disconnected from player input. The goal of this update was to add animation support and make the character’s actions more readable. With mechanics like dashing and wall jumping already in place, it was time to make those mechanics look as satisfying as they felt.
Development Process
The process started when Ewan handed me a few character animation GIFs along with something I didn’t fully recognize at the time - a texture map. I wasn’t sure how to use the texture map correctly in Unity, and since I had no prior experience with sprite sheets, I ended up setting it aside. Instead, I focused on the GIFs.
I quickly realized that Unity doesn’t work natively with GIFs as animation assets. So I needed to break them down into individual frames. I found a website that could convert a GIF into PNG frames, which gave me a sequence of images for each animation (walk, idle, jump, attack, etc.). From there, I imported these PNGs into Unity and created animation clips by dragging them into the Hierarchy window.
Once the raw clips were set up, I moved on to using Unity’s Animator system. I created an Animator Controller and started building out state machines for each player action: idle, run, jump, fall, attack, dash, wall slide, and so on. Each animation state was tied to a corresponding trigger or boolean that I could control through code.
It wasn’t plug-and-play though. I had to experiment a lot with the transitions. For example, the dash animation needed to end early enough that it could naturally blend into a jumping state. The attack animation needed to finish just before the player regained control, but not so quickly that it looked unfinished. I learned and used Unity’s animation sliders here - I could adjust exactly when one animation would end, when the next would begin, and how long to blend between them.
It took quite a while to figure out what was happening, as I've never done animations or anything remotely related, but once I started playing with the sliders and seeing what they did - it started making more sense and the animations started to look better.
Looping animations (like idle or run) also needed tweaking. Some animations would jitter or stutter if the last frame didn’t cleanly line up with the first, so I had to either trim frames or slightly adjust the animation speed to create a smooth loop.
Once everything was wired up, I used the same codebase from previous features (e.g., checking IsGrounded, IsDashing, or IsWallSliding) to feed the Animator the correct state data in real time. After a bit of tuning, the player finally responded visually to every action - and it made a huge difference to the feel of the game.
What I Took Away
This was my first time working with 2D animation in Unity, and it came with a fair share of surprises. I didn’t expect to be working with texture maps or needing to convert file formats just to get started. That initial confusion reminded me how important asset format knowledge is when working with teammates.
Once I got past the file conversion hurdle, learning how to build animation states and transitions in Unity was actually pretty enjoyable. The Animator system is powerful, but it does require a lot of trial and error to make things look smooth - especially when dealing with precise timings like dashing or attacks.
Working with the animation blend settings taught me how subtle timing tweaks can affect game feel. A too-long transition made controls feel sluggish, while a too-abrupt switch broke visual flow. Getting those sliders right was where the animations started feeling intentional instead of just an afterthought.
In the end, adding animations turned a functional prototype into something that feels like a real game. It gave the player character personality and clarity - and now every movement or attack is more readable and enjoyable to watch.
Google Sites
Report abuse