NFT Fantasy: Why Items-as-NFTs Does Not Enable Transfer Of Assets Between Games

As usual, everything is more complicated than it looks.

Over the past few months, there’s been a lot of disinformation spreading through crypto communities about NFTs as in-game items and cosmetics. As talk of “the metaverse” grows, and people float theories about owning items and cosmetic skins and being able to take between games, interest in what that means practically for gamers has lead to a wild array of theories, but they’re largely pushed by people who know nothing about game development. So, as a developer, it falls to people like me who live and work in these spaces to share our knowledge, and so over the next couple of weeks, I’ll attempt to do just that, so subscribe and stick around for the rest of the series.

What we’re going to be covering:

• The myth of ‘storing an item’ on the blockchain (or anywhere else) as an NFT (← You are Here)

• How games communicate and how game inventories work

• Why the concept of ‘items travelling between games’ is logically unsound

• The decentralization people are promising does not exist

• The promised metaverse cannot exist

• The lie of ownership and the reality of licensing IP

If you’re not interested in game assets, but are more interested in blockchain as infrastructure, you might want to head to the later parts:

Part 2: Why NFTs Don't Enable Knowing What You Own In Other Games
Part 3: Why None Of The NFT Plans Even Make Logical Sense

With that out of the way, let’s begin.

Thing is, being able to tell what someone owns in a game is a solved problem. APIs have been doing it for decades — that’s how PSN and XBox Live tell games what people bought in their stores, and grant them access to stuff like games, or DLC. We’ll dig into how that works in a later episode.

The blockers to cross-game itemization are, and always have been, logical, technical, legal, and business issues.

Before we start, I need to explain what an NFT is, and what it does.

What Is An NFT, Technically Speaking

At it’s simplest form, an NFT is just a record in a kind of database. You can retrieve the wallet address that owns it, the contract address that created it, the transaction history of its previous owners and sales, and the contents itself, which are arbitrary. In most public use cases, the NFT contains JSON — a structured text file containing data. It can execute arbitrary code or perform a function when certain conditions are met. Then it records the transaction on a blockchain. The NFT can never be edited or changed, and you can cryptographically prove that all transactions happened the way the blockchain says.

You can think of it just like a database that anyone can read. If you don’t understand why the kind of database a game uses is important, then this article is for you.

Items As NFTs

Let’s start with a simple example.

In this pitch, there are two games, and the concept is that Game A could store items people earn or buy in-game as an NFT on a blockchain, and then people who own it could use it in Game B.

Some definitions:
- Item: some in-game functional piece of gear, like a sword, gun, or armour.
- Cosmetic: some non-functional appearance change, like a skin for an item.
- Inventory: a collection of things you have, made up of both items and cosmetics.

While there are many problems with this idea from the get-go, this article focuses on the idea that the NFT, or any off-platform storage, could contain an item in its entirety for use in another game, which it could load at will.

To put names to it - here’s one example I hear a lot.

“With NFTs I could earn a rare sword in Diablo 3 and take it into Path of Exile!”

And there are fundamental problems with that idea, that are unrelated to blockchains or NFTs.

1. You can’t actually store the items or cosmetics themselves on the blockchain in a way that will let them be used automatically. They’re big, complex, and games can’t interpret them without a lot of manual work. In reality, if you were attempting to do this, the NFT would contain a string that uniquely represents them, the same ones the game uses internally, like “WEAPON_ENERGY_SWORD_01”, then it would be up to the other game to implement that in a way that can work with yours. This is how things like Twitch Prime drops are granted.

2. Even if you could store the raw asset data and send it to the other game straight off the blockchain, the other game has to spend time and money implementing those items and cosmetics.

To dig into these, we have to learn a little bit about how game assets are actually made, so let’s start with some of the basics, and the processes that a human has to go through to take something out of one game, and put it in another.

Since you can download assets from online stores and put them in games, you might think you can just export meshes (what most people think of when you say a 3D model) between games as well. But the truth is much more complex, and simply put: no.

What Actually IS An Item?

Game engines can’t even agree on which way is up, let alone a myriad of other things. You cannot simply ‘export’ and ‘import’, let alone have that happen automatically without knowing the intricate details of how the asset was created, and what specific tasks need to be done to make it work in your game. These assets aren’t just a model and textures - they all contain code of some sort that fundamentally ties them to the game they were created in. Even moving items or cosmetics between two games made in Unreal Engine is an extremely manual process, because they all depend on things in the codebase that don’t exist in other games.

At a high level, some of the things that can’t be imported are:

1. Behaviour. Every game has its own custom ways of storing and recalling that data. Even moving guns between two shooters can’t be done programmatically without customizing the task. For example, one might store rate of fire as a ‘rounds per second’, and the other might store a ‘delay between rounds’. Others might use curves to represent ramp speed, while some might just use a number. Recoil might be a central library or a function per gun. You need to recode the objects.

2. Audio. You could store wav files, but how they actually behave and produce sound are totally dependent on whatever audio middleware they might be using, like WWise or FMod. You need to reprogram the audio.

3. VFX and Fabric. Many of the cool visuals that you see in a game are built off the same tools and plugins, and again, switching between games means losing those tools. You need to rebuild the behaviors in equivalent modules.

4. Shaders. They’re like tiny programs that you use to generate the look of a surface in a game. It’s not as simple as just painting a surface with a texture, you code in how it handles reflections, how it emits light, what it does when you look at it. I’ve written shaders that adjust colours depending on what’s happening to the item, which refers back to the weapon code powering it, which can’t work without bits of my core engine. Shaders are used to simulate the liquid contents of bottles in Half-Life: Alyx. Some people use them to make it so text always faces the camera, which links back to the original font. So even the appearance of an item or cosmetic is likely to be tied to the internals of the game that created it. You need to rebuild these, and that’s just if you want them to work, because even if they could just work, that’s even more terrifying:
   
   Shaders are basically arbitrary code. You’re letting someone else run programs inside your game, on your players PCs. If your game loads a shader that you didn’t write, it could easily contain code to download child porn, or join a botnet and turned every player’s PC into a DDOS participant. This guy wrote one that runs an entire linux instance.

   
   You can never, ever let a client run a shader you don’t trust.

5. Animation. In animation, you start with a mesh, and build out a rig for it, which you can roughly consider to be the skeletal structure that the body moves around. It sets the rules for the ranges of how bones can move, but also how bones pull on the rest of the character, like how if you push your hand forward, how your elbow also moves, and maybe your shoulder stretches out at full extension. So if you’re moving a mesh that has a certain rig attached to it into a different engine that has a different rig, they’re going to have different bones, with different rules. At a minimum, you’ll have to go through something called Animation Retargeting in which you manually tell the game which bones in one rig correspond to the bones in a different one. You will need to manually reanimate or retarget.

6. Procedural animation. Even after you’ve done your retargeting, it’s normal to need to make programmatic adjustments, with things like Control Rig. This video from Epic shows Control Rig in action, and how despite having models and rigs for a gauntlet that’s already compatible with the game engine, it needs additional manual work to be used on a Fortnite character to stop the gauntlet clipping through their hand, and sitting how it should. You need to reprogram this.

7. Levels of detail. All of this is made more complex by that games all have different rules about what levels of complexity are shown at what draw distances. You might need to see all the details of a gun up close, but at 30 yards, perhaps it uses a simpler model to claw back some performance. Even simple 2D images like sprays or icons are not exempt from this. Mipmaps are a sequence of sequentially lower-resolution textures to be used at different distances, and it’s likely that every game will be using slightly different rules. You need to regenerate the assets.

8. QA. Adding items and cosmetics to games and their in-game data tables needs to be done at build time, and be tested before you let players see it. And even if you could do all of this at run time, live, why would any game just trust that some other game’s stuff was going to go through this process and magically turn out production-ready?

This is not even close to the full list of problems; I’ve stuck to the things that I think people who don’t work on games will be able to understand easily. The systems that enable games to display moving, animated 3D objects go multiple layers deeper than this — mesh deformations as the rigs move, how much of the appearance comes from rendering and shading, which again, are both deeply tied to the game itself. One of my prototypes used anime-style cell-shaded characters, and their stylization had nothing to do with the character models; they got their look from a post-processing volume that encapsulated the Actor, which is something the engine provided.

A simple throwable trip mine object.

But even if you pretend those problems don’t exist..

In The Pipe, Five By Five

Each game has its own processes (asset pipeline) that it goes through to manually take raw data like WAV files and meshes and turns them into functional things inside the game. So even just having the raw assets doesn’t help you. Converting them costs time, which costs money.

So even if you were to arrange all this ahead of time for specific items, why would a game studio spend all that money and time to produce another game’s items and cosmetics in their game, that they can’t sell, QA, control, buff, nerf, or protect themselves against?

And even if the myriad of things that you need to do to set something up in your game were done in advance, the only thing you’d be checking off the blockchain is that User A has Item B. But since you know this item can only come from Game B, you would just use an API to check for it. This is how games tell when people bought things like DLC for our games from the PlayStation or Xbox store. If someone’s account claims to have bought something from PSN, clearly the best way to tell is to check PSN.

Even if you were able to wave a magic wand and make all of the things that prevent it irrelevant, you’d still just be left with something that adds complexity while providing no additional value. The only extra functionality that would provide over a regular cross-game promotional item (like Little Big Planet was doing 10 years ago) is the ability to trade those items between users .. which Steam was doing 9 years ago.

If you’re currently thinking something about ‘but decentralization’, hold that thought. That’s a falsehood people have been selling, and I’ll address it in a future article. The point of this article is singular - to show how NFTs do nothing to mitigate any of the difficulties of asset sharing.

Game development is a complex, exciting, interdependent web of complexities that are largely invisible to people who never see them, and while I’m thrilled to see people taking an interest in game development tech, I hope this has opened at least a small window into challenges at play.

See you next time for part two: How Games Communicate.

for those we have lost; for those we can yet save