Chapter 24: Game Economy Design — Resources, Production, and Trade

Every game has an economy. This is true whether your game is Animal Crossing, EVE Online, Tetris, or Dark Souls. If your players gain something — health, ammo, experience points, currency, score, time — and spend something, you have an economy. The moment two resources can be exchanged for one another, even implicitly, economic forces take hold. Supply and demand, inflation and deflation, hoarding and trading behaviors — all of these emerge not because you designed them explicitly, but because players are rational actors optimizing for resources in a system you built.

This chapter is about making those forces intentional. Most designers stumble into economy design by accident. They tune enemy gold drops until "it feels right," they set shop prices based on intuition, they add a new currency every time a feature needs one. Then, six months after launch, they discover the top 1% of players have accumulated 400x the gold of the median player, the in-game economy is suffering runaway inflation, and the starter sword costs more than the endgame weapon because of some unintended interaction. By that point, fixing the economy requires surgery on a living patient.

The practitioner's approach is different. You treat the economy as a designed system from the start. You map flows before you tune numbers. You identify sources, sinks, and converters. You simulate player behavior and run the numbers before shipping. You understand that economies are dynamical systems — they don't just sit there; they evolve, and players will find equilibria you never imagined.

In this chapter, you'll learn how to design economies on purpose. We'll cover the Machinations framework for mapping resource flows. We'll examine inflation and deflation as the twin failure modes. We'll look at free-to-play currency hierarchies, single-player RPG internal economies, and the staggering complexity of MMO economies like EVE Online. We'll implement inventory and shop systems in GDScript. By the end, you should be able to sketch your game's entire economy on a whiteboard, identify the pressure points, and predict where problems will emerge.

💡 Intuition: An economy is any system where resources flow. "Resource" means anything a player values — currency, health, ammunition, time, attention, social capital. If players make tradeoffs between gaining and spending, you have an economy, and it will behave like one whether you designed it to or not.

What Is a Game Economy?

A game economy is the system of resources that players acquire, spend, convert, and trade within your game. Even games without explicit "money" have economies. Consider:

• Tetris has an economy of time and space. You spend space (placing blocks) to gain score. Lines clear space; stacking consumes it. Time pressure is a constant drain.
• Dark Souls has an economy of souls (dual-purpose currency and XP), estus flasks, humanity, and consumables. Every death is an economic event.
• Animal Crossing has an economy of bells, Nook Miles, furniture, turnips (the famous stalk market), and crucially — time and attention.
• Celeste has an economy of strawberries, crystal hearts, and deaths. Strawberries are optional; deaths are an implicit cost players pay in frustration.

The common thread: players acquire resources from some source, eventually spend them at some sink, and make decisions along the way about which resources to accumulate versus convert versus discard.

When you design a game economy, you are deciding:

1. What resources exist. Gold, wood, mana, lives, keys, reputation, energy.
2. How they enter the system (sources). Killing enemies, finding chests, harvesting plants, completing quests, login bonuses.
3. How they leave the system (sinks). Repairs, consumables, upgrades, deaths, time decay.
4. How they convert between each other. Smelting ore to ingots, trading gold for gear, sacrificing health for damage.
5. How players can trade them. NPC shops, auction houses, player markets, gifting.
6. How their values change over time. Early-game inflation, endgame deflation, market crashes.

Get these right and your economy hums along, rewarding engagement without collapsing. Get them wrong and you'll watch helplessly as your economy either starves players of progression (deflation) or floods them with meaningless wealth (inflation).

The Four Economic Functions: Sources, Sinks, Converters, Traders

Ernest Adams and Joris Dormans, in Game Mechanics: Advanced Game Design (2012), formalized a framework for analyzing any game economy using four fundamental functions. Every economic actor in your game is one (or a combination) of these.

Sources

A source is anywhere a resource enters the system from "outside" — outside meaning the economic simulation, even if it's inside the game's fiction. When you kill a goblin and it drops 10 gold, that gold didn't come from another entity's pocket. It materialized. The source generated it.

Examples: - Killed enemies dropping loot - Chests and containers with items - Harvested resource nodes (trees, ore veins, plants) - Quest rewards - Daily login bonuses - NPCs who give infinite handouts (rare, usually a bad idea) - Crafting materials generated from "nothing" via rest or time

Sources control the rate at which wealth enters your economy. If you want players to feel rich, increase source density or drop rates. If the economy feels starved, you probably have a source problem.

Sinks

A sink is anywhere a resource leaves the system. The gold you pay to repair armor doesn't go to another player or NPC's inventory — it simply vanishes from the economy. A well-designed sink destroys wealth, keeping total resource supply in check.

Examples: - Repair costs (item durability systems) - Consumables (potions, food, ammunition) - Upgrade costs (gold disappears when you enhance a weapon) - Fast travel fees (Bethesda and FromSoft games) - Death penalties (losing souls in Dark Souls) - Skill respecs - Gambling (in Diablo's Kanai's Cube or similar) - Cosmetics (cosmetics are usually the best endgame sink)

If sources outnumber sinks in both number and throughput, you get inflation. If sinks outnumber sources, you get deflation or progression stagnation.

⚠️ Common Pitfall: Designers often underestimate how much sink capacity an economy needs at endgame. Early game players spend freely on upgrades and consumables. Endgame players have everything they need; sources keep flowing but nothing compels them to spend. Result: endgame gold floods. Plan endgame sinks (cosmetics, prestige items, housing, crafting vanity) from day one.

Converters

A converter transforms one resource into another. The total resource pool changes composition but not always in quantity. Smelting 2 ore into 1 ingot is a converter. So is crafting 100 leather into a backpack, or sacrificing 3 common items to roll for 1 rare item.

Examples: - Crafting (ingredients become finished products) - Smelting, brewing, cooking, enchanting - Item disenchantment (WoW: items become dust/essences) - Sacrifice systems (exchange three commons for a rare) - Rerolling stats (consume materials to randomize)

Converters are not inherently sinks or sources, but most converters lose some material in the transformation (a gold-sink converter). A converter that transforms 2 wood into 1 wood is just a sink. A converter that transforms 1 wood into 2 wood is a source and will break your economy.

Three games worth studying in detail for their converter design:

Minecraft. The crafting grid is one of the most influential converter systems in game history. Every recipe is a fixed input-to-output transformation: 8 cobblestone becomes 1 furnace; 4 wood planks become a crafting table; 1 iron ingot plus 2 sticks becomes a pickaxe. Notice the pattern — inputs almost always exceed outputs in raw count, so crafting is a mild sink. But the output is qualitatively more valuable than the sum of its parts: a pickaxe is worth far more than 1 ingot plus 2 sticks. This is how Minecraft generates perceived wealth without generating actual resource abundance. The converter creates value by recombination, not by multiplication. Mojang also made the crafting grid spatial, which turns recipes into puzzles players discover rather than menus they scroll through. Converter design lesson: the transformation can carry the meaning, not just the numbers.

EVE Online. Every spaceship in EVE is converted from raw materials through an industrial chain hundreds of steps deep. Miners harvest asteroids; ore gets refined into minerals; minerals get combined into components; components get assembled into modules; modules get installed on ships. Each step is a converter, and each step loses some material (reprocessing efficiency is capped below 100%, intentionally). The result: a vast, player-driven supply chain where every ship in the game has been built by some other player from raw materials. When a titan ship worth tens of thousands of real-dollar-equivalents explodes in combat, the value is really, truly gone — the ship represented thousands of hours of mining, refining, and manufacturing by potentially dozens of players. This is only possible because every converter in EVE is a lossy one. If refining were 100% efficient, material accumulation would eventually saturate the economy. Converter design lesson: strategic inefficiency is a feature.

Terraria. Where Minecraft's crafting is simple and transparent, Terraria's is layered and progression-locked. Recipes require workstations (anvils, furnaces, alchemy tables, demon altars, hardmode forges), and higher-tier workstations unlock higher-tier recipes. You can't craft a Molten Pickaxe until you have an Iron Anvil, which you can't have until you've smelted Iron Bars, which you can't do without a Furnace. This workstation-gated approach turns converters into progression gates — each new station represents a tier of content the player has unlocked. Converter design lesson: the converter itself can be a reward.

Traders

A trader exchanges resources between two economic actors. The total pool is preserved — resources move, but they don't vanish or spawn.

Examples: - NPC shops (gold for items, items for gold) - Auction houses (player-to-player, with optional tax as a sink) - Barter systems - Gifting between players - Guild banks (intra-guild trading)

Crucially, an NPC shop is both a trader AND (usually) a partial source/sink, because NPCs typically have infinite gold and infinite stock. The NPC doesn't really possess the gold — when they pay you, they're acting as a source; when they take your gold, they're a sink. Pure trading happens between players.

Four trader implementations worth understanding:

World of Warcraft's auction house is the canonical MMO trader. Players list items for a starting bid and buyout price; other players bid or buy out instantly; the AH takes a listing fee (paid up front, refunded on sale) and a cut of the final sale price. Both the fee and the cut are pure sinks — gold destroyed, not transferred. The auction house has been one of WoW's most important economic tools for two decades. It enables specialization (a player who loves gathering can make gold selling to a player who loves crafting), creates price discovery (items find their actual market value), and provides a continuous gold sink that scales with economic activity. But it also enables goldfarming, price manipulation, and mass-flipping, which Blizzard has spent 20 years fighting.

EVE Online's regional market system takes the auction house idea further. Every star system has its own market; prices vary regionally; items must be physically hauled between stations. This means arbitrage — buying cheap in one region, transporting, and selling dear in another — is a legitimate profession. Haulers get ambushed by player pirates. Trade routes become contested. The trader system isn't just an economic tool; it's a generator of gameplay. Travel time and space between markets converts trading into a spatial activity. The trader becomes an adventure.

Animal Crossing: New Horizons's turnip market (the "stalk market") is one of the strangest and most-studied trader designs in gaming. Players buy turnips from Daisy Mae on Sunday mornings. During the week, turnip prices fluctuate at Nook's Cranny twice a day. Prices follow one of several patterns (decreasing, random, small spike, large spike). Players can visit friends' islands to sell turnips if those islands have high prices that day. This turned the casual life-sim into a minor financial phenomenon during 2020 lockdowns — Discord servers, spreadsheets, and turnip-price-tracking websites proliferated. The lesson: a single well-designed trader mechanic with variance and social exchange can generate more engagement than dozens of ordinary ones.

Player-to-player gift economies (rare but not absent) show up in games like Final Fantasy XIV's player-run shops via market boards and housing, Genshin Impact's paimon-bargain dailies (strictly NPC but with negotiating feel), and older MUDs. A true gift economy creates social bonds as a byproduct of resource transfer — which in turn creates retention. Don't overlook the social layer of traders. A trader isn't just an economic function; it's an interface for human relationships.

🎮 Case Study: Diablo II famously had no official auction house. Players traded directly, usually in game lobbies named things like "SOJ trade" (Stone of Jordan rings were a de facto currency because gold was nearly worthless at endgame). This was chaotic, exploit-ridden, and genuinely beloved. The informal player-driven trader layer emerged because the designed economy had gaps. When Diablo III tried to formalize this with the real-money auction house, it destroyed what players loved about D2 trading — the social negotiation, the mystery, the scam risk. Sometimes the messiness is the economy.

🔗 Connection: In Chapter 27 we'll look at AI design for NPCs. The economic role of an NPC (pure trader vs. source/sink hybrid) is itself a design decision with balance implications.

The Machinations Framework

Dormans' PhD work produced Machinations, a visual notation for mapping these functions as a directed graph. Nodes represent resource pools; edges represent flow. Sources are triangles pointing out; sinks are triangles pointing in; pools are circles; converters are rectangles. You can annotate each edge with a flow rate (resources per second, per action, per trigger).

You don't have to use Machinations software — any whiteboard sketch works. The value is structural: once you draw your economy as a graph, imbalances become visible. If gold has 14 sources and 3 sinks, you can see the inflation coming before you ship. If a particular resource has no outgoing edges (a pool with no sink), players will hoard it until it becomes meaningless.

Sketching exercises we recommend:

1. Draw every resource in your game as a circle.
2. Draw every source as an arrow into the appropriate circle.
3. Draw every sink as an arrow out of the circle.
4. Draw every converter as a rectangle connecting two circles.
5. Label each edge with approximate rates (per minute, per quest, per hour of play).
6. Identify circles with many incoming arrows and few outgoing arrows — these are your inflation risks.
7. Identify circles with many outgoing arrows and few incoming arrows — these are your deflation risks.

📝 Note: Machinations diagrams can be built in the free Machinations Community Edition tool or sketched on paper. Either works. The notation matters less than the discipline of mapping flow.

Inflation: When Gold Becomes Worthless

Inflation is the most common failure mode in game economies. It happens when resources flow into the economy faster than they flow out. Over time, the total stock of currency balloons, and prices — especially on the player market — climb to match. What cost 100 gold at launch costs 10,000 a year later. New players can't afford anything. Veteran players can afford everything.

The canonical cautionary tale is World of Warcraft. In 2005, the WoW gold economy was tightly controlled. A high-end mount cost 1,000 gold and felt aspirational. By 2020, high-end mounts had been supplemented by items costing millions of gold, and gold farming was so rampant that Blizzard introduced the WoW Token — a real-money-for-gold mechanism partly designed to drain gold (you buy the token with real money; it creates a sink competing with gold farmers; the gold paid by the buyer comes from someone else, but the actual redemption for game time is a sink because Blizzard takes the gold out).

Inflation happens for several reasons:

1. Source density scales with level, sinks don't. You kill tougher monsters at level 60 that drop more gold, but you still pay the same gold to repair. Net gold inflow per hour climbs.
2. Players accumulate gear and stop buying consumables. At endgame, players have best-in-slot gear; sinks fall away.
3. Gold sellers. In MMOs, real-money traders farm gold in industrial quantities, multiplying supply.
4. Duplication bugs. A single dupe exploit can inject millions of gold before it's patched.
5. Designer interventions. Adding a new source (a double-drops holiday event) without a new sink is an inflation accelerator.

The visible symptoms:

• Rising prices on the player market (if one exists).
• Consumables cost pennies relative to endgame wealth.
• New players feel locked out — they can't afford common items because the price has climbed.
• Wealth concentration increases. The top 1% have orders of magnitude more than the median.

EVE Online and PLEX: designing inflation deliberately. EVE has had continuous inflation for its entire 20-year lifetime, and CCP considers it acceptable. Their Plex system (Pilot License Extension) lets players buy game time with real money and then sell the resulting PLEX on the in-game market for ISK (the main currency). This means ISK inflation is bounded from above by real-money prices: if ISK inflates too much, the ISK-per-dollar ratio shifts, and PLEX becomes a de facto currency peg. CCP publishes monthly economic reports tracking M2 money supply (all ISK in circulation), velocity, CPI-equivalent prices on key goods, and inflation rates. They employ actual economists with PhDs to advise on policy. When the ISK supply grows faster than production, CCP rolls out new sinks — larger construction projects, bigger ship-loss multipliers in sovereignty warfare, new infrastructure that requires millions of ISK per day to maintain. The takeaway: if you run an MMO long enough, you are a central bank, whether you know it or not. You can either accept the role and manage it or deny it and watch your economy spiral.

RuneScape and the Wilderness removal: the cost of removing a sink. In December 2007, Jagex removed PvP combat and item-dropping from the Wilderness area of RuneScape, replacing it with safer mini-games. Their stated goal was reducing real-world trading (RWT) — gold farmers were using the Wilderness to transfer gold to buyers, then killing them to drop the items. Well-intentioned. But PvP death in the Wilderness was one of RuneScape's largest gold sinks: when a player died, their items (minus three) dropped and were claimable by the killer, but often the actual wealth was destroyed (left on the ground, timed out). Removing Wilderness PvP removed the sink. Over the next few years, inflation accelerated dramatically. Party hats — rare cosmetic items from a 2001 holiday event — climbed from single-digit billions to tens of billions of gp. The community revolted. In February 2011, Jagex returned the Wilderness to its original form. The community called this "the 2011 return of the Wild" and it's studied to this day as an example of how an innocuous-seeming change to a complex economy can trigger years of cascading effects. The lesson: before you remove a mechanic from a live economy, map what economic function it serves. It may be serving a role you weren't aware of.

Diablo III's Real Money Auction House: the worst inflation story in gaming. We cover this in detail in Case Study 1, but the summary: Blizzard's 2012 decision to allow real-money item sales broke the game's core loot loop. Drop rates had to be tuned so that items held real-money value, which meant items were too scarce to feel rewarding during normal play. Players stopped being excited about drops and instead calculated real-dollar expected values. The entire game became a spreadsheet. Blizzard shut the RMAH down in March 2014. The game became fun again. No mainstream game has attempted a real-money auction house since.

💀 Design Autopsy: WoW Gold Inflation. Over 18 years, WoW's gold economy underwent massive inflation. In Classic (2004-2006), the mount at level 40 cost 90 gold — a serious achievement. By Shadowlands (2020), typical endgame players accumulated hundreds of thousands of gold. Blizzard introduced increasingly extravagant gold sinks (the Traveler's Tundra Mammoth at 20,000g, the Grand Expedition Yak at 108,000g, the Brutosaur vendor mount at 5,000,000g). These helped but couldn't outpace source density. The WoW Token launched in 2015 — a real-money-to-gold conversion that simultaneously provided a sink (by buyers of game time) and legitimized the gold-for-real-money exchange. The lesson isn't that WoW did it wrong; it's that a 20-year MMO economy requires continuous intervention.

Deflation: When Everything Costs Too Much

Deflation is the opposite failure mode and is rarer in games but still possible. It occurs when sinks consume resources faster than sources create them. Players feel starved of progression; they can't afford anything; the experience of playing is one of scarcity and frustration.

Classic causes of deflation:

1. Too many high-cost sinks with too few sources. Repair costs scale with item value; if you have expensive gear, your repairs are crushing.
2. Death penalties that drain wealth faster than play restores it. Hardcore Diablo or ironman modes in old MMOs.
3. New content with high costs but limited farming. A raid that requires expensive consumables to even attempt, with no corresponding source increase.
4. Designer over-correcting for inflation. You noticed prices climbing, so you nerfed gold drops. Now new players can't progress.

Deflation can be either a design intent (permadeath games like Rogue Legacy or Don't Starve maintain scarcity intentionally) or a failure. The question is whether the scarcity serves the experience.

🎯 Tradeoff Spotlight: Scarcity vs. Generosity. Too much abundance and players feel nothing is meaningful — why bother getting the next sword when I already have three? Too much scarcity and players feel punished — I've played 20 hours and still can't afford the basic gear. The sweet spot is meaningful scarcity: resources are tight enough that spending decisions matter, but not so tight that play feels futile. This is the central tension of economy tuning, and there's no formula for it — only playtesting.

Free-to-Play Economy Design

Free-to-play games have a three-currency structure almost universally:

1. Soft currency — earned through gameplay. Gold, coins, credits. Used for common transactions.
2. Hard currency — earned through skilled play or limited acquisition. Rare gems, trophies, tournament points.
3. Premium currency — bought with real money. Gems, crystals, V-Bucks, Robux.

The economic logic is subtle. Soft currency lets you progress; hard currency unlocks premium content slowly; premium currency lets you accelerate. The goal, from the game's revenue perspective, is to create situations where players strongly desire premium currency — either for speed (time-gated mechanics) or content (cosmetics, character unlocks).

Key considerations:

• Conversion rates between currencies should be designed, not accidental. Typically, soft → hard is expensive; hard → premium is impossible; premium → soft is cheap.
• Dual-currency pricing (an item costs 500 coins OR 50 gems) is a common pattern. The gem price is usually 1/10 or less of the coin price, to give premium players the time-save they paid for without trivializing the coin economy.
• Battle passes are essentially a time-gated converter — you put in time and get rewards, and premium currency accelerates or enhances the pass.
• Gacha adds randomness — premium currency rolls for chance at rare items. This requires additional economic design (pity timers, duplicate conversion) and falls under increasing regulation.

✅ Best Practice: If you're designing F2P, pick your premium currency name and icon before you design anything else. Make it visually distinct from soft currency. Players should never accidentally spend premium currency when they meant to spend soft. Confused spends = refund requests = app store penalties.

⚠️ Common Pitfall: Do not design F2P economies to feel awful without spending. The 2010s-era "energy system" where you could only play 5 matches then had to wait 4 hours — players hate it, and it trains them to leave rather than pay. Modern F2P design creates positive pressure to spend (wanting more of a good thing) rather than negative pressure (wanting to escape a frustration).

Two F2P economies worth understanding in depth, because they represent different approaches:

Clash of Clans (Supercell, 2012) uses a two-currency model (Gold + Elixir + a third, Dark Elixir, introduced later) for soft currency and Gems as premium. Gems can instant-finish construction and training timers, which are otherwise the game's core friction. At first glance this sounds punitive — "pay to skip waiting" — but Supercell tuned it carefully. Base construction timers in the early game are seconds to minutes; spending gems is wasteful because timers aren't frustrating yet. Mid-game timers stretch to hours; spending gems is a meaningful shortcut. Endgame timers reach days; only a minority of players pay to skip, and those players are the whales who drive revenue. The design is sophisticated because it lets the majority play for free without feeling pressured, while creating real value for those who pay. Free players contribute to the social ecosystem (clan wars need players); paying players fund the game. Both are treated as legitimate user archetypes. The economy works because the pressure to spend scales with how much you want to play, not with how much you're blocked from playing.

Genshin Impact (HoYoverse, 2020) uses a more complex structure. Primogems are the soft premium currency — they can be earned slowly through gameplay (daily commissions, quests, exploration chests) or bought directly as Genesis Crystals (which convert 1:1 to Primogems). Primogems convert to Fates, which are spent on gacha banners to summon characters and weapons. The gacha uses "soft pity" (increased rates after a certain number of pulls) and "hard pity" (guaranteed rate-up at 90 pulls). The economy is tuned so that a free player can save enough Primogems across a roughly 6-week character cycle to guarantee one 5-star character if they spend carefully and don't pull on off-banner items. Paying players can pull immediately, at whale prices. The sophistication here is in the pity system — it converts the inherent cruelty of randomness into a bounded expected cost. You know the maximum you'll pay (~$200 USD for a guaranteed 5-star). Gacha math is no longer a lottery; it's a pricing system. Whether this is ethical is debatable (gacha regulation is tightening globally; some jurisdictions now require published rates), but the economic design is undeniably effective. *Genshin* has grossed over $5 billion in its first three years, making it one of the highest-grossing games ever.

⚖️ Ethics Preview: Free-to-play economies can be designed to serve players or to exploit them. We'll return to this in Chapter 33 on Game Design Ethics, where we examine dark patterns, predatory monetization, and the specific techniques used to extract money from addiction-prone players. For now, the practitioner's stance: you can design F2P ethically, but you have to do it deliberately. The default path of copying whatever the top-grossing mobile games do will lead you somewhere ugly. Know what you're building.

The Internal Economy of a Single-Player RPG

Single-player RPG economies are, counterintuitively, often harder to design than MMO economies. Why? Because in an MMO, the economy is self-correcting — players buy and sell to each other, prices float, and the worst an overly rich player can do is not participate. In a single-player RPG, there's only one economic agent (the player) and all the prices are set by you, the designer. If you tune them wrong, every playthrough suffers.

The main design question in single-player economies is: at what point in the game should the player be able to afford what?

A well-designed single-player economy has:

• Early scarcity. In the first few hours, the player should not be able to buy everything they want. This creates meaningful choice: do I buy the leather armor or save for the magical trinket?
• Mid-game equilibrium. By the middle of the game, the player has enough gold to buy most of what they encounter, but specific aspirational purchases remain.
• Late-game drain. The endgame should have massive sinks (legendary item crafting, special upgrades) that soak the accumulated wealth.
• A plateau that doesn't feel empty. Post-credits play should still offer reasons to earn gold, even if they're vanity.

Elder Scrolls games (Skyrim, Oblivion) famously fail at this. By level 30, most players have more gold than they can spend. The weapons and armor they find are better than anything merchants sell. Gold becomes meaningless. Bethesda compensates with house purchases and enchanting materials, but many players finish the game with 200,000+ gold and no reason to spend it.

Dragon Age: Origins does better. Gold stays tight throughout. Potions cost real money and are always worth buying. Armor upgrades remain relevant because random loot is rarely strictly better than shop-bought gear.

Dark Souls takes a different approach: souls are a dual-use currency for buying AND leveling up. Every soul you spend on a sword is a soul you can't spend leveling. This forces real economic choices. When you die and risk losing souls, each decision carries weight. The brilliance of the design is that there is literally one currency and it pays for every category of progression — you cannot "hoard souls" without accepting the opportunity cost of not leveling, and you cannot level without accepting the opportunity cost of not buying. This unifies economic decision and character progression into a single choice point, chapter after chapter. (Hollow Knight's geo works similarly though less elegantly — geo buys maps, charms, and key items, but levels come from Pale Ore, which splits the tension.)

Hollow Knight (Team Cherry, 2017) pulls the geo economy down several rungs of abstraction. Geo is scarce in the early game, becomes abundant in the late game, and is consumed by map purchases from Cornifer and Iselda, charm purchases from Salubra and Leg Eater, tram and elevator fees, and bench/repair services at the Nailsmith's. When you die, you lose all geo and must return to recover it from your Shade. This creates the same death-as-economic-event feeling that Dark Souls does, but with a key difference: geo is not progression currency. You can't level up in Hollow Knight; your power comes from charms and from the nail upgrades that require Pale Ore plus geo. So geo's role in the economy is more specific — it's the "adventure budget" rather than the "power budget." Both designs are legitimate. Pick the one that serves your game's progression philosophy.

🎮 Play This: Play 90 minutes of Dragon Age: Origins and 90 minutes of Skyrim back-to-back. Track every gold you earn and spend. Notice how differently the two economies feel — one tight, one abundant. Neither is wrong, but the tight economy makes merchants matter throughout the game while the abundant economy makes them irrelevant by mid-game.

MMO Economies and EVE Online

MMO economies are among the most complex systems human beings have ever built, and EVE Online is the most complex of them all. (We'll dive deeper in Case Study 1.) A full MMO economy can include:

• Multiple currencies (gold, honor, reputation, badges).
• A player market (auction house) with tens of thousands of items.
• Crafting systems with recipe trees hundreds of items deep.
• Gathering professions creating raw materials.
• Item degradation and repair.
• Taxation (a percentage of each auction house sale destroyed as a gold sink).
• Regional price variation (different cities, different auction house pools).
• Limited-time events injecting or draining resources.
• Hacks, exploits, duplicate bugs, and real-money-trading black markets.

Managing this requires tools most designers don't have to build:

• Economic telemetry — dashboards showing total gold in circulation, auction house volume, median item prices, gold drop rates.
• Leading indicators — rising prices on staple goods often precede inflation crises.
• Intervention levers — being able to launch new sinks or adjust drop rates at short notice.

EVE Online employs actual economists with PhDs. Their lead economist Dr. Eyjólfur Guðmundsson became famous in the mid-2000s for publishing quarterly economic reports. CCP Games treats EVE's economy as real enough to require real economic analysis.

Most games don't need this level of sophistication. But every MMO designer should plan for telemetry from day one. You cannot manage what you cannot measure.

🚪 Threshold Concept: The Economy Is a Living System. Once your game ships, your economy is no longer static — it evolves in response to player behavior, exploits, content updates, and external events like gold-farming services. You cannot "finish" an MMO economy. You can only manage one. Accepting this changes how you plan: you stop asking "what's the right gold drop rate?" and start asking "how will I monitor and adjust the gold drop rate over the game's lifetime?"

Resource Spirals: Snowball vs. Balanced

A resource spiral is a feedback loop where acquiring resources lets you acquire more resources faster. Spirals can be positive (snowball) or negative (comeback).

Snowball spiral (also called "rich-get-richer"): The more you have, the more you gain. Examples:

• Real estate in Monopoly: owning property lets you collect rent, which lets you buy more property.
• Gold in many RTSes: more gold → more workers → more gold.
• Gear in most RPGs: better gear → kill harder enemies → better gear.

Snowball spirals are often desirable in single-player games (they create a power fantasy) but dangerous in multiplayer (the leader runs away with the game). In multiplayer, you need either:

• Catch-up mechanics — losers get boosts (rubberbanding in Mario Kart, "bounty" targets in MOBAs).
• Natural convergence — spirals that self-limit (diminishing returns).
• Reset points — new rounds, new matches, resource resets between games.

Comeback spiral is rarer but real — the losing player gains resources more easily, allowing them to catch up. Super Smash Bros. has mild comeback mechanics; many board games have catch-up mechanics.

🧩 Productive Struggle: Think of a game you've played recently where one side took an early lead and won decisively. Was the win caused by early resource acquisition that snowballed? What catch-up mechanic, if added, would have given the losing side a fighting chance without trivializing the early lead? This is the central tension of competitive economy design.

Time and Attention as Resources

Some resources aren't explicit in the game UI but behave like resources nonetheless. Time is the most important of these.

In a session-based game, you have the player's attention for a fixed window. Every mechanic you ask them to interact with competes for that attention. Inventory management time, shop time, travel time — all of these are costs, even if the game doesn't charge currency for them.

Diablo's "one big pile" loot philosophy works partly because the time-cost of sorting and selling loot is minimized. In contrast, Path of Exile's complex currency system and trade economy consumes enormous amounts of player time — some players spend more time trading than playing.

Similarly, attention is a resource. If your game has six mini-currencies, players have to track six things. If you've designed seven different crafting materials with subtle differences, players must decide which matter. This is cognitive load, and it's a real cost, even if players don't name it.

Good economy design often means fewer resource types, not more. If two resources can be collapsed into one without losing meaningful choice, collapse them.

⚡ Quick Reference: Resource Minimization Principle. Before adding a new resource, ask: Can an existing resource cover this role? Can the new resource be replaced with a modifier on an existing one? If your game has more than 5-7 distinct currencies/materials that the player has to actively track, you're overcomplicating it unless complexity is the point (e.g., EVE, Path of Exile).

Currency Design: What Makes Gold Feel Valuable?

A piece of gold is just an integer in a database field. Why does gold feel valuable to some players and disposable to others? The answer is design.

Gold (or any currency) feels valuable when:

1. It's scarce. Players can't passively accumulate it.
2. It has meaningful uses. There are things worth buying at every price tier.
3. Its worth is legible. Players understand what they can afford.
4. Loss is possible. Death, theft, or decay create stakes.
5. Accumulation is visible. Seeing the number climb provides a dopamine hit.

Currencies lose value when they're trivially abundant, or when the uses for them are either too cheap (everything costs 10 gold and you have 10 million) or too expensive (nothing you want is affordable). The trick is keeping most purchases feeling slightly out of reach at any given moment.

Diegetic vs. abstract economies. A diegetic economy is one that exists in the game's fiction — gold coins, credits, septims. An abstract economy is purely mechanical — points, XP, tokens. Monopoly has a diegetic economy (the money looks like money). Tetris has an abstract economy (the score is just a number).

Diegetic economies give you thematic grounding. A fantasy game with gold coins can use medieval merchants, theft, banks — fictions that extend the economic system. Abstract economies give you design freedom — you can invent weird currencies that don't need to make narrative sense.

Most modern games use a mix: a diegetic main currency (gold) alongside abstract secondary currencies (honor points, battle pass XP, crafting shards).

🪞 Learning Check-In: Pause and think about your current project. What's your main currency called? Why? Is it diegetic (embedded in fiction) or abstract (mechanical)? Does its name communicate its purpose to new players? Would changing its name change the feel of spending it?

The Diablo III Auction House: A Cautionary Tale

In 2012, Blizzard launched Diablo III with a real-money auction house (RMAH). Players could list items for sale in exchange for actual cash, with Blizzard taking a cut. The idea was to legitimize the real-money trading that had plagued Diablo II — rather than fight gold farmers and item sellers, monetize them.

It was a disaster.

The problem wasn't the RMAH per se. The problem was that its existence warped the entire loot economy. Because players could sell items for real money, item rarity and drop rates had to be tuned to make drops scarce enough that items held real-money value. This meant the baseline drop rate from monsters was brutally stingy. Most players would grind for hours and get nothing — because if drops were generous, item prices on the AH would crash.

The result: Diablo III felt awful to play. The core loop of "kill monsters, find loot, use loot" was broken. Most loot was garbage. The "good" drops went to the auction house rather than to the player who found them (because an AH sale was worth more than using it). Players stopped being excited to find items.

In March 2014, Blizzard shut down the auction house. Later that year, they launched Loot 2.0 and the Reaper of Souls expansion, which dramatically improved drop rates. The game transformed from a frustrating grind into a well-loved ARPG. Blizzard later said the RMAH "fundamentally broke our game's core reward loop."

Lessons:

• Your reward loop must be designed for the play experience first, not the economic layer.
• Real-money economies warp non-money economies around them.
• Player-to-player trading systems create design constraints that ripple through everything else.
• Sometimes the best fix is removal.

We'll examine Diablo III and Diablo IV in depth in Case Study 2.

Implementing a Basic Inventory

Let's shift from theory to implementation. The core data structure for most economies is an inventory — a mapping from item types to quantities. Here's a simple GDScript implementation.

# Inventory.gd - simple dictionary-based inventory
extends Node

signal inventory_changed(item_id: String, new_quantity: int)

var items: Dictionary = {}  # item_id (String) -> quantity (int)

func add(item_id: String, quantity: int = 1) -> void:
    if quantity <= 0:
        return
    items[item_id] = items.get(item_id, 0) + quantity
    inventory_changed.emit(item_id, items[item_id])

func remove(item_id: String, quantity: int = 1) -> bool:
    # Returns true if removal succeeded
    if quantity <= 0:
        return false
    if not items.has(item_id) or items[item_id] < quantity:
        return false
    items[item_id] -= quantity
    if items[item_id] == 0:
        items.erase(item_id)
    inventory_changed.emit(item_id, items.get(item_id, 0))
    return true

func count(item_id: String) -> int:
    return items.get(item_id, 0)

func has_at_least(item_id: String, quantity: int) -> bool:
    return count(item_id) >= quantity

This is intentionally minimal. A production inventory would add stack limits, slot management, item metadata, persistence — but the skeleton is always a mapping from IDs to counts.

Key design points:

• Using a Dictionary over an Array because item lookups are O(1) rather than O(n).
• The add/remove methods emit signals so UI can react without polling.
• remove returns a bool — the caller needs to know whether the transaction succeeded. This matters for purchases (you shouldn't deliver goods if payment failed).

🛠️ Design Exercise: Extend this inventory to support stackable vs. non-stackable items. For example, a sword should take up one slot regardless of quantity, while arrows should stack up to 99. Add a max_stack_size lookup (perhaps in an ItemDatabase resource) and modify add to create new stacks when one fills up. Think about how you'd represent "slot 3 has a sword with +2 enchantment" vs. "slot 4 has 47 arrows."

Implementing a Shop NPC

The other core primitive is the trader — an NPC or vendor who exchanges items and currency. Here's a minimal implementation.

# ShopNPC.gd - basic buy/sell interface
extends Node

@export var inventory: Node  # player's Inventory
@export var gold_item_id: String = "gold"

# Prices: item_id -> {buy_price, sell_price}
var shop_prices: Dictionary = {
    "health_potion": {"buy": 50, "sell": 25},
    "iron_sword":    {"buy": 200, "sell": 100},
    "wooden_shield": {"buy": 80, "sell": 40},
}

func player_buys(item_id: String, quantity: int = 1) -> bool:
    if not shop_prices.has(item_id):
        return false
    var total_cost: int = shop_prices[item_id]["buy"] * quantity
    if not inventory.has_at_least(gold_item_id, total_cost):
        return false
    inventory.remove(gold_item_id, total_cost)
    inventory.add(item_id, quantity)
    return true

func player_sells(item_id: String, quantity: int = 1) -> bool:
    if not shop_prices.has(item_id):
        return false
    if not inventory.has_at_least(item_id, quantity):
        return false
    var total_value: int = shop_prices[item_id]["sell"] * quantity
    inventory.remove(item_id, quantity)
    inventory.add(gold_item_id, total_value)
    return true

A few things worth noticing:

• Buy price is higher than sell price. This is universal in games with vendors. The spread between buy and sell acts as a friction cost — you can't profit by buying from one vendor and selling to another (assuming flat prices). The spread is effectively a sink when players sell items they looted.
• Validation is explicit. Before modifying inventory state, we check that the transaction is possible (item exists, player has enough gold, player has enough items to sell). Only then do we commit. This prevents partial-transaction bugs.
• The shop itself has no inventory. This NPC is a pure source/sink (for the items it stocks) rather than a trader with finite goods. If you wanted finite shop stock, you'd add a second inventory to the ShopNPC.

📝 Note: Real production shop code would add many layers — UI events, sound effects, cooldown prevention (you can't spam-buy in one frame), dialogue integration, reputation modifiers, and more. But the economic core is what's above: validate, deduct, deliver.

Putting It All Together: Your Game's Economy

You now have enough theory to design your own economy, and enough code to implement a basic version. Here's a practical process:

1. List every resource. Gold, materials, consumables, XP, currencies.
2. Identify sources. Where does each resource come from?
3. Identify sinks. Where does each resource leave?
4. Identify converters and traders. What exchanges exist?
5. Estimate flow rates. How fast does each resource enter and leave per hour of play?
6. Check for imbalances. Do sources vastly outpace sinks? (Inflation risk.) Do sinks vastly outpace sources? (Deflation risk.)
7. Design the progression curve. At what point in the game should the player be able to afford each major purchase?
8. Build a spreadsheet model. Estimate gold-per-hour at various levels. Verify that shop prices are reachable but not trivial.
9. Prototype and playtest. Watch real players interact with the economy. Numbers on a spreadsheet lie; playtesters don't.
10. Plan for post-launch. What levers will you pull if inflation emerges? What new sinks could you add?

📐 Project Checkpoint: For your progressive project, design the internal economy. List every resource your game has. Map sources, sinks, converters, and traders. Sketch the flow as a Machinations-style diagram. Then implement an Inventory.gd and at least one ShopNPC.gd using the patterns from this chapter. By next chapter, you should have a playable prototype where the player can earn resources, spend them, and feel the economy working.

Concretely for our progressive project — the 2D action-adventure we've been building since Chapter 3 — here is what the economy looks like in Chapter 24:

One soft currency: "shards." These are crystalline fragments scattered through dungeons and dropped by defeated enemies. We use a single currency rather than multiple because (a) our game is small and doesn't need complexity, and (b) back in Chapter 12 we established that the XP/reward layer ties to progression, so we don't want to fragment the player's attention across multiple number counters. One currency. Clear purpose.

Sources for shards: enemy defeats (2-5 shards per normal enemy, 10-20 per elite, 50+ per boss), chest rewards (10-30 shards per chest, scaled by depth), quest rewards (chapters 19 and 21 established NPCs and quests), and rare "shard cluster" interactable rocks (100 shards each, one per level as a secret).

Sinks for shards: the shop NPC at the hub (selling potions, key items, cosmetic dye for the player's cape), fast-travel fees between unlocked waypoints (small — 5 shards — but meaningful in aggregate), and ability upgrade materials in Chapter 25 (shards combined with boss drops upgrade abilities).

Economy feel target: at any given point in the mid-game, the player should have enough shards for "most but not all" of the things they want. They should feel the weight of choosing between a damage upgrade and a defensive one. We'll test this in Chapter 31.

Shop NPC at hub: a character named Vera, a nomadic trader who's taken up residence in the player's hub area. She sells five items at any given time; her stock rotates based on the player's progression. She buys materials the player has no use for at a modest sell-to-buy spread (roughly 40% sell price to 100% buy price). She has voice lines — voice acting referenced from Chapter 21's dialogue system — that react to the player's wealth, current quest, and time of day. Economy is emotional as well as mechanical.

Implementation: use the Inventory.gd script above, extended with stack limits (next exercise). Implement Vera as a ShopNPC.gd node attached to her character in the hub scene. Wire her to the DialogueSystem.gd from Chapter 21 so her barter conversations feel like conversations, not spreadsheet interactions. By end of Chapter 24, you should be able to walk up to Vera, press interact, buy a potion, leave, come back, and sell an item you looted. That's the core economic loop, working.

Designing an Economy from Scratch — A Practitioner's Process

Everything up to this point has been framing. Now: how do you actually go from blank page to a functional economy? Here is the process that, in the author's experience, consistently produces economies that hold up to playtesting.

Step 1: List every resource. On paper (or a spreadsheet), write down every currency, material, consumable, and token your game has. If you have fewer than three, you're probably fine. If you have more than seven, stop and collapse aggressively. Be ruthless. The question is: does each resource create a distinct decision? If "gold" and "silver" always move together, they're one resource with a silly sub-pile.

Step 2: Map the flows. For each resource, draw (yes, physically draw) every source and sink. If you can't fit the diagram on one page, your economy is too complex or you're drawing it at the wrong level of abstraction. The goal is a diagram that a teammate can understand in 60 seconds.

Step 3: Identify pressure points. Look for resources with many sources and few sinks (inflation risk), or many sinks and few sources (deflation risk). Look for resources that are only sources for one other resource — these are "pass-through" resources and can often be collapsed. Look for cycles (gold → gear → gold), which can be powerful but also create runaway spirals.

Step 4: Estimate flow rates. Guess, but guess seriously. How many gold does a typical player earn per hour at each stage of the game? How much do they spend? What's the net per hour? Build a spreadsheet with columns for early game, mid game, late game, and endgame. Project accumulation. If your numbers suggest the player will be sitting on 50,000 gold by hour 10, with nothing meaningful to spend it on, you have a problem — and it's visible before you've written a line of code.

Step 5: Simulate with a spreadsheet. Adams and Dormans are emphatic about this and so am I. Before you implement, model the economy in Excel or Google Sheets. Simulate 100 hours of play. See where the money goes. See what happens if the player skips optional content. See what happens if they grind. The spreadsheet catches problems your gut won't.

Step 6: Prototype and observe. Build the smallest playable version that includes the economy. Give it to three playtesters. Watch them play without talking. Note what they buy, what they hoard, what they ignore. The gap between what your spreadsheet predicts and what playtesters actually do is where your design learning happens.

Step 7: Iterate at the flow level, not the price level. When something feels off, resist the urge to just change a price. Ask what flow is broken. If players aren't buying potions, is it because potions cost too much, because other sinks are more compelling, or because the difficulty curve doesn't require potions? Changing a single price is a local fix; changing a flow is a structural fix.

Step 8: Plan for post-launch. Write down, before you ship: what levers will you pull if inflation emerges? What sinks can you add? What drop rates can you tune? What events could you run to absorb excess wealth? Having these answers in a document means you can respond in a week rather than two months when the economy wobbles.

Common Economy Design Pitfalls

Even experienced designers hit the same traps repeatedly. Watch for these.

Pitfall 1: Currency sprawl. You add a new currency every time you add a new feature. Guild currency, dungeon currency, PvP currency, honor currency, crafting currency, event currency, seasonal currency. Now the player has 14 number counters and no idea which one matters. WoW has wrestled with currency sprawl for most of its life; they periodically consolidate, then the next expansion sprouts five more. The rule: add a new currency only when it unlocks a decision that existing currencies can't unlock. Reskinning gold as "honor points" for a separate system is still adding a currency. If it acts like gold, it is gold, and you're just creating confusion.

Pitfall 2: Hidden exponents. Your pricing curve looks linear on the whiteboard (100, 200, 300, 400...) but your income curve is exponential (source drops scale with level). Result: early game feels correctly tight; late game drowns in wealth. Always compare the shape of your pricing curve to the shape of your income curve. If they don't match, you get either inflation (income grows faster than prices) or deflation (prices grow faster than income).

Pitfall 3: The "everyone gets everything" endgame. Skyrim is the canonical example. By level 30, players have enchanted everything they own, filled every house, and have 100,000+ gold sitting unused. The endgame sinks aren't compelling enough. This is an easy problem to see in playtesting and hard to fix without redesigning loot itself. Plan endgame sinks during preproduction, not after launch. Destiny 2 learned this lesson — they added "infusion" (consume one gun to power up another), "masterworks" (enhance to endgame quality), and cosmetics as layered sinks for endgame currencies.

Pitfall 4: Dupe exploits and no rollback plan. Your economy will, at some point, have a duplication exploit. EVE, WoW, Diablo II, Final Fantasy XI, RuneScape — every major MMO has had them. The question isn't "will it happen" but "how fast can you detect and respond?" Design your telemetry so that a 10x spike in any currency's growth rate triggers an alert. Plan your response before the exploit exists: can you roll back specific accounts, specific items, or specific currency pools without destroying legitimate player wealth? These are hard questions with no good answers, but they're worse when asked during a crisis.

Pitfall 5: Confusing rewards with economy. Not every reward belongs in the economy. A story unlock is a reward but not a resource. A cosmetic achievement title is a reward but not a resource. A new dialogue option is a reward but not a resource. The question is whether the thing can be spent, traded, converted, or accumulated. If not, it's an unlock, not an economic object. Treating every reward as an economic object leads to currency sprawl (see Pitfall 1). Separate the reward layer from the economy layer in your design doc. Different rules apply.

⚠️ Pitfall: One mistake specific to F2P: pricing your premium currency in amounts players can't match. The classic example: a character costs 50 Gems; Gems are sold in bundles of 30, 80, 160, 400. You cannot buy exactly 50 Gems. You must buy 80, waste 30 Gems, or buy 160 and save 110 for later. This is deliberate friction that traps currency in player accounts, increasing spending pressure. It is also widely criticized as a dark pattern and is increasingly regulated in consumer-protection jurisdictions. Know what you're doing if you pick this design.

Summary

Every game has an economy, whether you designed it or not. The practitioner's choice is whether to shape it deliberately.

Sources are where resources enter the system. Sinks are where they leave. Converters transform between types. Traders move resources between actors. Together, these four functions describe every economy, from Tetris to EVE Online.

Inflation happens when sources outpace sinks — resources accumulate, prices rise, new players get locked out. Deflation happens when sinks outpace sources — resources stay scarce, progression stalls, play feels punishing. Both failure modes require vigilance, and in live games, continuous intervention.

Free-to-play games typically use three currencies: soft (grindable), hard (earnable through skill), and premium (purchasable with real money). Single-player RPG economies require careful progression curves. MMO economies are living systems that require economic telemetry and ongoing management.

Time and attention are resources even when they're not in the UI. Fewer resource types is usually better. Currency feels valuable when it's scarce, useful, legible, losable, and visibly accumulating. Diegetic currencies embed in fiction; abstract currencies live purely in mechanics.

The Diablo III auction house teaches that economic layers can warp core gameplay loops. Design the reward loop first; design the economy to serve it.

In the next chapter, we'll turn to progression systems — the broader framework within which economies operate. XP, levels, skill trees, and the pacing of power gain all interact with your economy design.

Next: Chapter 25 — Progression Systems: XP, Levels, and the Arc of Power