
Making Every Win Feel Different
Turning win animations into a lightweight, reusable feedback system for real-time gameplay.


From sprite sheets to a more expressive reward system
At Betterlore, I worked on redesigning how wins were celebrated in our live coin-pusher game. The existing animations looked too similar regardless of the reward value, and the sprite-sheet format made it difficult to introduce more complex animations without adding to the file size.
I created a five-tier reward system using Rive, giving smaller and bigger wins their own visual identity through motion, timing, and sound. The project also helped us move away from sprite sheets and adopt a more flexible approach to animation across the game.
Role:
Sole UI/UX Designer
Timeline:
2025 (~ 4 months)
Team:
UI/UX Designer • PM • Engineers • QA
Tools:
Figma • Rive • Adobe Illustrator • Adobe Photoshop
Status:
Shipped
Key Results
5
Distinct reward tiers
A clearer progression from small wins to big celebrations
Rive adopted across the game
Moved beyond sprite sheets to a reusable animation approach
Shipped to production
Integrated into live gameplay and adapted for portrait mode
THE PROBLEM
Bigger wins didn't feel much bigger.
The existing win animations looked almost the same regardless of the reward value. There wasn't enough visual distinction between a small win and a big one, making the celebrations feel repetitive.
We also relied on sprite-sheet animations, which meant larger file sizes as we introduced more complex effects. For a live game played mainly on mobile, adding more animation couldn't come at the expense of performance.
The challenge was to make every win feel different while keeping the experience lightweight and responsive.
THE APPROACH
Building on a Lighter Motion Workflow
Moving beyond sprite sheets
Before this project, I had researched and tested different motion workflows to address the platform's performance limitations.

Coin flipping sprite sheet sample
After Effects, Lottie, Rive
I explored After Effects and Lottie, but found them better suited to linear animations. Rive gave us something closer to what the platform needed: lightweight vector-based animations, interactive state machines, and runtime control.
After successfully testing Rive in an earlier feature, we used it as the foundation for the new reward system.
Designing one system for every reward
Instead of exporting separate animation sequences, I built the entire reward system in one Rive file.
The file contained all five reward tiers, from XS to XL, with number inputs and conditions that determined which animation should play for a given reward value.
I could test the system directly in Rive by changing the reward value and triggering the state machine, allowing me to validate how the animations responded before implementation.
Coins and chips shared the same reward system and visual treatment. The platform communicated the reward result to the Rive file, which then displayed the corresponding tier animation.

For this case study, I recreated the original prize ranges to demonstrate how the system worked without exposing production values.
Designing with implementation in mind
Building the animations was only part of the work. The Rive file also needed to communicate clearly with the platform.
I worked closely with frontend developers to define the inputs, conditions, and naming conventions they would reference in code.
We tested the state machine together and resolved cases where the expected animation wasn't triggered correctly. This collaboration helped make sure the logic I created in Rive worked reliably once connected to the platform.

State machine conditions controlling which reward animation is triggered based on the configured value range, trigger, and sound settings.
Keeping dynamic values inside the animation
One implementation challenge was displaying the player's actual prize amount.
The reward titles, such as Good! and Epic!, were embedded in the animations. But the prize value needed to change dynamically for every win.
Our initial approach was to render the amount separately through frontend code. However, reproducing the intended typography and keeping the value visually integrated with the animated composition proved difficult.
After researching alternatives, I found that Rive's Text Runs could keep the prize amount inside the animation while allowing frontend developers to update it at runtime.
I converted the prize values into Text Runs, giving developers control over the displayed amount without losing the typography and visual treatment of the animation.
Making iteration easier after implementation

The team wanted to move the reward system into production quickly, while the animations still needed testing and refinement.
Developers connected the Rive files to Firebase, where we maintained separate files for each environment.
I could upload updates to the appropriate environment and test them directly in the platform, reducing repeated developer handoffs and allowing design and development to progress in parallel.

THE DESIGN PROCESS
From nine planets to five reward tiers
Starting with an ambitious visual direction
While the technical workflow made richer animations possible, I still needed to define what the reward system should look and feel like.
The original brief was ambitious: nine reward tiers, each represented by a different planet. Smaller rewards would start with smaller planets and build toward the Sun as the biggest celebration.
I researched reward experiences in other games, collected references, and explored how illustration, motion, and sound could make each reward feel progressively more exciting.

After storyboarding the animations, I designed the first three concepts around Earth, Neptune, and Saturn.

Reducing the scope without losing the idea
The visual direction was approved, but creating nine bespoke animated rewards would take too long for one designer working across multiple projects.
To move into development sooner, the team reduced the system from nine planets to five tiers: XS, S, M, L, and XL.
Instead of starting over, I adapted the illustrations and motion direction I had already created into one visual system.
Slide left and right to compare before and after.
Creating hierarchy through motion
My first concepts treated every reward as a large, full-screen celebration. But the system needed clearer hierarchy—a small reward shouldn't interrupt gameplay in the same way as a significant one.
I differentiated each tier through illustration complexity, number of elements, scale, screen coverage, movement, color, animation duration, and sound.
Smaller rewards stayed quick and lightweight, while larger rewards became progressively more expressive. XL was the only full-screen experience, playing for six seconds before looping until the player closed it.
Each tier also had its own sound design, adding another layer of intensity as the reward value increased.
Visual
Tier
Duration





Extra Small
(XS)
Small
(S)
Medium
(M)
Large
(L)
Extra Large
(XL)
(Jackpot)
2 seconds
2 seconds
3 seconds
5 seconds
6 seconds
Using sound to reinforce the hierarchy
Each tier had its own sound treatment, increasing in intensity alongside the animations.
I sourced and edited the audio to match the pacing and emotional tone of each reward, making larger wins feel progressively more celebratory.
XS wins have short, punchy sound effects that are powerful but subtle enough not to interrupt gameplay
S wins are slightly longer and brighter effects that break the rhythm and signal a noticeable reward.
M wins included a subtle hovering spaceship sound to complement the spaceship illustration in the animation.
L wins have layered laser effects to match the spaceship firing animation, adding intensity.
and lastly, for XL wins/Jackpots I introduced looping, celebratory background music with layered sound effects for maximum impact.
THE FINAL SYSTEM
Explore the Reward System
From subtle feedback to full-screen celebrations, each reward tier has its own visual treatment, motion, and sound.
Select a tier below to experience the five reward animations.








