Illuvium - Trait Purity Indicator v1

The Challenge: Finding a Single Number to Represent Traits

When I was first told we needed a single number to represent the quality of a unit’s traits, my immediate reaction was, “That’s a terrible idea.” Why? Because they wanted it to be the average of all the traits. Sure, it sounds simple, but it’s also wildly misleading. I explained this—repeatedly. An average number doesn’t tell the full story of a unit’s value, especially when different stats matter more in different games. But no matter how many ways I tried to shut it down, the pushback was relentless.

Eventually, I got it: even if their proposed solution wasn’t ideal, the underlying problem was real. Players needed something easy to understand—even if it wasn’t perfect. So, I decided to take a step back, stop being a puritanical baby, and see if I could solve the problem in a way that matched the requirements. The lessons I’d learned from other parts of the project—like understanding the why behind a request instead of just reacting to the what—helped me a lot. Still, I went into the task “knowing” that it couldn’t be done. But after a small amount of wrestling with the problem, a solution was born.

I’m not very good at thinking outside the box. Or rather, I’m only good at looking outside of SOME boxes. Others I ignore completely, and that’s a real problem. What this taught me is that I need to do more listening to the team and the community, and if there is a problem… just fix it. It’s my job to find solutions. I’ve always asked the team to bring solutions with their feedback, but if the solutions aren’t ideal the answer isn’t to shut it down. It’s to take the proposal and break it down into a core problem statement that can be tackled. And then tackle it.

And the core issue here was readability, and accessibility. Players absolutely crave a way to quickly know ‘this is good’ or ‘this is bad’. From this, we have developed a lot more solutions, have simplified the project in many positive ways, and I think we are better for it. I know I’m better for it.

So to those that keep pushing feedback to us, and me specifically, thank you.

Aaron

The Foundation: Numbers, Bins, and Percentages

At its core, every unit in our game is represented as an NFT with a unique random number. This number is the blueprint for the unit’s stats in any game. Here's how it works:

• Breaking Down the Number: We split the random number into sections—or “bins”—each representing a specific trait. Think of it like dividing a cake into slices, where each slice has a different flavor.
• Converting to Percentages: Each bin is then compared to the maximum possible value it could have, resulting in a percentage. For example, if a bin’s maximum value is 100 and the unit’s bin value is 75, the percentage for that bin is 75%. The actual numbers are very big, but the idea is the same.
• Assigning Stats: These percentages are used to determine the unit’s stats. Many of the bins aren’t used, because each game has a different number of traits. At one point we thought to keep that number fixed for any game, and keep it small, but it didn’t give us the flexibility we wanted. 
• Fixed Locations: In each game, units have consistent positions for each stat. The first bin might be ‘strength’ in one game, and ‘charisma’ in another. (Hearts Ablaze, I’m looking at you).

I was happy with this system. It meant that we could assign unit traits in any game, before the game even existed. And new units could be spawned and instantly have traits applied in existing games. Since the blockchain is permanent, we didn’t want to update these as we built them. It defeats the point of something being fixed and rare. That is, we didn’t want to alter its value on a whim. I don’t think the community would much like that.

The Problem: Variability

As you might see, if you look at this from the perspective of distilling traits into a single number, it’s terrible. That single number has to have a set algorithm, and it can be so inaccurate as to be completely useless.

Here's why a simple average is so misleading:

Consider a simplified example with two units:

• Unit A: 5 Omega Power, 0 Attack Power
• Unit B: 0 Omega Power, 5 Attack Power

Both would receive the same 50% purity rating, yet their actual value depends entirely on how they are meant to be played.

• If they are Omega Casters:
• • Unit A is excellent
  • Unit B is terrible
• If they are Physical Attackers:
• • Unit B is excellent
  • Unit A is terrible

Yet they have the same rating!!

And it gets even worse - depending on what each unit was designed for, they could both be perfect at their roles or both be terrible at their roles, all while showing the same 50% rating!

This is why a simple average would be worse than useless–it could actively mislead players about a unit's value.

So it passes the ‘easy to look up’ test. But then a player might buy the unit with this Trait Purity Indicator (TPI) in mind, and find that the unit they just spent so much on completely sucks. That is a terrible experience we couldn’t risk, even if it considerably simplified the UI.

The Solution: Endless Human Suffering

I'm, of course, joking. Mostly. The key insight unlocked everything: we can do it manually, as long as we don’t care how hard the game design team works. What if we:

1. Rank which traits matter most for each unit.
2. Create a custom mapping to weight those traits.
3. Use that mapping to calculate a meaningful score.

For example:

• For an Omega caster, Omega Power would be bin 1.
• For a physical attacker, Attack Power would be bin 1.

This means we have to create mappings for:

• Every existing unit (200+ units)
• New units in future expansions
• Units for every game mode

Yes, this is a lot of work for our game design team. But they go hard, so I set them to work. And to make sure we got it right, I secretly made my own independent list. Here's the wild part - even though there are 720 different possible ways to order the traits for each unit, when I compared my list to the team's, we only disagreed on 3 units out of 200. That's how confident I am when I say that players can now trust that a high score means "this unit is good at what it's designed to do."

Cross-Game Consistency: The Strength of the Trait Purity System

One of the most exciting aspects of the Trait Purity Indicator is its cross-game functionality. In our ecosystem, each unit’s stats follow a predefined order of importance that applies universally across all of our games.

Here’s why this matters:

• Consistency Across Games: If a unit has a strong first bin (representing its most important stat), it will excel in all games within our ecosystem. For example, if the first bin corresponds to attack power in one game, it might correspond to speed in another. Regardless, the stat will always be the most impactful for that unit.
• Future-Proofing: Players can invest confidently in their units, knowing that a strong Trait Purity score today will translate into strong performance in future games. This eliminates the guesswork and makes your units more valuable over time.

The Weighted Purity Score: One Number to Rule Them All

To simplify things further, we’ve developed a weighted purity score that consolidates all of a unit’s bin values into a single number out of 100. Here’s how it works:

• Weighting the Bins: The first bin carries the most weight, followed by the second bin, and so on. This reflects the relative importance of each stat.
• Calculating the Score: By combining the weighted values of all bins, we generate a single number that accurately represents the unit’s overall strength and potential.
• Clear Insights for Players: With this number, players can quickly gauge a unit’s quality at a glance. Is it a top-tier unit? Will it remain relevant in future games? The weighted purity score provides clear, reliable answers.

Why Trait Purity Matters

The Trait Purity Indicator is a result of our philosophy. It’s our way of ensuring that players always have a fair, transparent, and consistent way to evaluate their assets. Here are a few reasons why it matters:

• Transparency: By breaking down how stats are determined, we remove the mystery and empower players to make informed decisions.
• Cross-Game Synergy: The Trait Purity system ties our games together, creating a unified ecosystem where your investments retain value and relevance.
• Fair Play: Whether you’re a new player or a seasoned veteran, the system ensures that everyone has a clear understanding of what makes a unit strong.
• Simplicity: I know we have failed you on this many times in the past, but we’re working on it. This is one area where we always wanted simplicity, but couldn’t work out how to give it to you. Now we can.

Pitfalls

While our Trait Purity system works well, it's important to be transparent about its limitations and how we plan to handle them.

• Weight Distribution: The system assumes a strict hierarchy where Bin 1 is always more important than Bin 2, and so on. However, reality isn't always so neat–some units might need equal weighting between bins. We've accepted this trade-off for simplicity.
• Unit Reworks: Since unit data lives on the blockchain, we face some interesting challenges when reworking units. For example, if we completely changed Rhamphyre's playstyle, their TPI could become misleading.

How We'll Handle Reworks

We'll approach this in three ways:

1. Prevention First
2. • We'll be extremely careful about changing unit identities
   • Small tweaks are fine, but complete archetype changes need serious consideration
2. TPI Updates (If Needed)
3. • For necessary reworks, we can update the trait mapping
   • This would change the unit's TPI to make it accurate again
   • We'll discuss any such changes with the community first
   • Our reasoning: if we're changing how a unit plays, we should update its TPI to match
3. Optional Exchange System (Possible Future)
4. • We could create an exchange system where players can:
   • • Burn their old NFT
     • Mint a new one with adjusted stats
     • Keep their TPI accurate without changing its value
   • While this would be ideal, it requires:
   • • Development work from us (though manageable)
     • Active participation from NFT owners

Example: TPI calculation for an Atlas

For those of you who want to know the nitty gritty of how the TPI for each unit is computed, here’s an example.

When an illuvial is created, a hexadecimal code is created with it. This code is broken down in 16 bins that represent the 16 trait power levels of the illuvial. Then, each of the values in these bins are converted into a value ranging from 0 to 1, which is then adapted to each game mode scale. 

Imagine that I just captured an Atlas with the following 16 traits:

Where “Bin #” indicates the Order of the Trait, “Value” indicates the Power of that trait, “Weight” is the Importance of that Trait for the Illuvial in any game, “Result” is the Weighted Value for each one of the 16 Traits of that Illuvial. The Trait Purity Indicator (TPI) is the sum of all 16 Results.

For this minted Atlas, the TPI is 59/100. 

Notes:

• The closer the “Bin #” is to 16, the less likely it is to have actual impact in any of Illuvium ecosystem games. This is why the closer to 16, the less “Weight” each “Value” has.
• Based on the previous note, when an Illuvial is minted, it will be optimal if the first 5-8 bins have the highest values, as these are the traits that will be used in most games and have more “Weight”.

So, a 59/100 indicates my Atlas performance in any game will be decent, but not crazy.

Looking Ahead

As we continue to expand, the Trait Purity Indicator will remain a cornerstone of our design philosophy. It’s a promise that your units will always have meaning and value, no matter where our games take you.

So the next time you acquire a new unit, take a closer look at its Trait Purity score. Behind that simple number lies a system with quite a bit of history.

What do you think of the Trait Purity Indicator? We can’t wait to hear your thoughts!