Amethyst — Sole Programmer on a Competitive 1v1 Turn-Based Tactics Game

The Project

Amethyst is a competitive 1v1 turn-based tactics game played on an 8×8 grid. It blends hero-based ability combat (inspired by Dota 2) with chess-style movement rules. Players draft teams of 4 heroes across 4 classes (Rook, Bishop, Knight, Queen), then compete to capture objectives, level up heroes, manage an in-game economy, and ultimately destroy the opponent’s Ancient structure. Combat is resolved through dice rolls, and every action — movement, attack, abilities — is powered by a shared energy pool rolled each turn.

Currently the game features 8 unique heroes, each with two unique, two-tier abilities, a full shop and inventory system with 5 currency types, 18 unique items, mining and fishing resource gathering, and a Steam-based MMR/leaderboard system. It ships on both Windows and macOS.

My Role

I’m the sole programmer on a 5-person team, working alongside a game designer/project manager (the client), a 3D artist/animator, a UI designer, and a VFX artist. I’ve been on this project part-time for 5+ years (~1,100 hours), and my responsibilities cover everything that touches code: gameplay systems, UI implementation, networking, audio, Steam integration, cross-platform builds, and engine-level bug fixes.

Beyond programming, I’m the integration point for the entire team. The client distributes tasks to everyone, but contributors come to me with what they need to do — I coordinate the work, implement their features or onboard them so they can implement themselves, and debug anything that breaks. I QA all visual contributions (animations, meshes, VFX, UI designs), and I’m responsible for making sure everything works in the shipped build. I also contribute game design advisory input, write technical documentation and flowcharts, and manage my own sprints and task breakdowns. The client makes all final design decisions — I advise, then execute.

What I Built

Core Gameplay Systems

The entire game loop was built from a heavily modified foundation. I started from the blueprints based Advanced Turn-Based Tile Toolkit (ATBTT), and fundamentally refactored it into a shared-energy-pool, player-input-driven turn system for 1v1 multiplayer. Over 5 years, the codebase evolved to contain more custom logic than original plugin code — with no third-party plugin dependencies beyond the initial ATBTT base.

Turn Manager & Energy System — Controls game flow: which player’s turn it is, energy rolls, action resolution, auto-end-turn conditions. Each turn, players roll 1d6 to determine available action points. Energy is spent on movement, attacks, abilities, resurrection, etc. I built the full energy pipeline including energy banking (save 1 energy if it wasn’t used this turn), amethyst-to-energy exchange with per-turn limits, escalating costs for repeated actions, and energy bar UI with cost previews.

Attack Wheel Combat — Each hero has a damage range determined by their attack stat (which increases as they level up from killing enemy heroes or capturing neutral camps). When a player initiates an attack, an attack wheel appears with gems spinning clockwise — the active gem cycles at a speed determined by the hero’s attack power, with the highest damage at the top and lowest at the bottom. The player clicks a button in the center to lock in their roll. Whichever gem the wheel lands on is also collected into the player’s inventory, tying every combat action into the gem economy. When attacking another player’s hero, the defender also spins a defense wheel simultaneously — the defense result is deducted from the attacker’s damage. From a networking standpoint, both players spin their wheels as soon as the attack starts, each sends their result to the other player’s game, and the receiving side plays a simulated spin landing on the transmitted result.

Attack wheel combat — hero attack, defense wheel, gem collection, escalating costs for repeated actions, hero death and level up.

Chess-Style Pathfinding — Each hero class moves differently: Queens move freely, Knights, Rooks, and Bishops follow their chess counterparts. I replaced the previous free-movement system with class-based pathfinding including per-class cost calculations and structure obstruction handling.

Chess-style movement — each hero class follows unique movement rules on the 8×8 grid

Ability System (8 Heroes)

I architected an extensible ability system where each of the 8 heroes has two unique abilities with level 1 and level 2 variants. The activation pipeline runs through: turn manager → player controller → ability validation → ability spawning → player execution.

Abilities span a wide range of mechanics:

Rook — Alpha: Taunt (forces nearby enemies to attack Alpha, taunting them for the next turn), Thorns Aura (passively returns damage when targeted)
Rook — Veil: Swap (switches positions with any hero), Deflect (passive chance to completely nullify incoming attacks or abilities)
Bishop — Ply: Spell Steal (steals an enemy’s spells — Ply keeps them until death), Arcanist (first attack per turn costs 0 energy)
Bishop — Zeus: Bolt (single-target ranged damage), Chain Lightning (ranged damage hitting target and all adjacent enemies)
Knight — Fletcher: Volley (ranged single-target attack dealing damage based on distance to target), Swiftness (chance to regain energy on every move)
Knight — Rider: Lasso (pulls a friendly or enemy hero to the square in front of Rider), Wilderness (passively reduces HP of adjacent enemies)
Queen — Ice: Freeze (immobilizes target for a full turn), Frost Armor (reduces physical damage taken by 50%)
Queen — Warmonger: Betrayal (causes an enemy’s adjacent allies to attack that enemy), Dispel (removes negative effects from an ally)

All heroes have level 2 upgrades that unlock at level 5. Tier 2 abilities generally increase range and effect values, but the more interesting upgrades add entirely new behaviors — Frost Armor gains a counter-freeze on the attacker, Lasso starts dealing damage on pull, Thorns Aura spreads to adjacent allies, Swiftness goes from a 50% chance to guaranteed energy recovery, and Spell Steal begins copying the level 2 versions of stolen abilities. Each upgrade had to be implemented as a distinct variant while sharing the base ability’s activation pipeline. Edge cases include abilities that interact with each other (damage reduction stacking with freeze), stolen abilities (Ply’s Spell Steal copying spells from the target), and forced actions (Warmonger’s Betrayal turning a target’s own allies against them).

Hero abilities — ability activation, targeting, and effects across multiple heroes

Status Effect System

Built from scratch and expanded over multiple years. The status effect system isn’t just for abilities — it’s a general-purpose framework used across abilities, items, and core game logic. The project currently has 30+ status effect blueprints.

Ability-driven effects make up the bulk: stuns (with specialized variants for Freeze, Taunt, Betrayal, Bolt, and Chain Lightning, all inheriting from a Stun_Base), damage multipliers (Frost Armor’s 50% physical reduction built on a DamageMultiplier_Base), spell immunity (Deflect’s block chance and Dispel’s cleanse, both extending a SpellImmunity_Base), and passive auras like Wilderness, Arcanist, Swiftness, and Spell Steal.

Reactive effect patterns handle status effects that trigger in response to being attacked — Thorns Aura returning damage to attackers, and Frost Armor L2 counter-freezing the attacker. A related pattern handles spreading effects to adjacent heroes, used by Thorns Aura L2 (granting Thorns to allies standing next to Alpha) and Wilderness (debuffing adjacent enemies, buffing adjacent allies — each with its own status effect blueprint).

Item-driven effects tie into the shop system: Strength Potion, Energizing Tonic, and Dispel HP Boost all apply their gameplay effects through the same status effect framework.

Game logic effects like Exhaust use the system to enforce turn rules — converting exhaustion into a visible, duration-tracked status effect displayed in the HUD rather than handling it as a hidden flag.

The framework supports configurable effect levels, duration logic, categories, visual icons in the HUD, lookup functions, and automatic removal on hero death.

Economy, Shop & Inventory

I built a complete in-game economy layer from scratch:

Currency & Gem Economy — The economy is driven by five gem tiers — Amethyst (highest), Topaz, Emerald, Sapphire, and Pearl — which map directly to positions on the attack and defense wheels. When a player’s wheel lands on a gem position, that gem goes into their inventory. Lower-tier gems can be converted up to Amethyst at fixed rates (e.g., 5 Pearl for 1 Amethyst, 4 Sapphire for 1 Amethyst, etc.), and once per turn a player can exchange 2 Amethyst for 1 energy. Mining yields 3 Amethyst per action. I built the full conversion UI, exchange rate logic, per-turn limits, and the integration between the wheel results and the inventory system.

Shop System — Players can access the shop from any hero as long as at least one of their heroes is adjacent to the Ancient or Side Shop. Items are one-time-use and unique. I built the proximity detection, item uniqueness rules, and the shop UI with card display.

Inventory System — Custom-built player-level and hero-level inventories with item transfer, backpack auto-collapse, hotkeys, and full network replication. No inventory plugin used.

18 Unique Items — Each with distinct activation mechanics: Fishing Pole, Mining Axe, Scroll of Learning, Strength Potion, Source of Luck, Energizing Tonic, Rejuvenation Potion, Phoenix Heart, Amethyst Hammer, and more.

Shop, inventory, and gem economy — buying items, activating from inventory, and converting gems to Amethyst

UI/UX Implementation

I implemented the complete game HUD from scratch across multiple iterations:

Energy bar with roll result and cost preview
Action panel with 5 player actions
Hero cards with hover/swipe, hero switcher between team members
Attack wheel animations and energy dice rolls
Health bars for heroes and buildings (faction-colored)
Ability bar with descriptions, icons, and cursors
Status effect display with visual icons
Top bar with team info, player stats, and level display
Tooltip and info cards for items, heroes, and abilities
Full inventory and shop panels

I also built the hero draft screen with class selection constraints and both-players-visible picks, the main menu, server browser, pause menu, and settings screens. Beyond implementation, I created UI mockups, wrote documentation for the UI designer, and exported PSD assets for in-engine integration.

Hover cursors — context-sensitive cursors showing valid actions across different game states

Networking & Multiplayer

Full network replication for a competitive 1v1 multiplayer game. Every system — gameplay, UI, economy, abilities — needed to work correctly for both the server/host and the remote client. This wasn’t a one-time networking pass; each new feature required its own replication work, and cross-platform play between Mac and Windows introduced its own category of issues. Networking was an ongoing responsibility across all 5 years of development.

Steam Integration & Platform

Steam Subsystem — Built a custom Steam integration subsystem in C++. Deployed builds to Steam across multiple iterations. Implemented a Steam-based MMR/ELO system where players wager points and the winner takes, along with leaderboards, player stats tracking, and winner name display.

MMR Leaderboard, connecting to server, Hero draft — Game start flow

Cross-Platform (Mac + Windows) — Maintained full cross-platform compatibility throughout 5 years of development. Debugged Mac-specific build failures, cursor rendering issues, and connection problems. Modified Unreal Engine source code to fix a macOS hardware cursor color bug — the engine used NSBitmapFormatAlphaFirst for cursor rendering, which caused incorrect colors. I identified the root cause and changed it to NSBitmapFormatAlphaNonpremultiplied, requiring builds from modified engine source.

Audio Implementation

Implemented game audio in 2026 — sourced and curated SFX assets, wrote an audio design document, and integrated sound effects across 20+ game events: turn start, attack wheel, energy events, item pickup, gem collection, fishing, mining, teleport, ability activation, outpost capture, hero death, respawn, level up, damage, freeze, cornerpiece destruction, and level ambience loops. Integrated AI-generated music and implemented volume controls.

Blueprint-to-C++ Conversion

In 2024, I converted the entire project from pure Blueprints to a hybrid Blueprint/C++ architecture mid-development. This required setting up C++ compilation on both Mac and Windows, restructuring systems (Steam subsystem, primary data assets, enums, structs) into C++, and maintaining Blueprint workflows for rapid iteration on gameplay logic.

Key Challenges & Solutions

ATBTT plugin transformation into a PvP tactics game: The Advanced Turn-Based Tile Toolkit supported single and multiplayer but was built around unit-initiative combat with heavy AI logic. I stripped out the AI systems (this is a PvP-only game), refactored the turn manager from initiative-based switching to a shared-energy-pool, player-input-driven system, rebuilt the game startup flow to support hero drafting and spawning (which the toolkit had no concept of), and implemented the entire cornerpiece/structure system from scratch. Over 5 years, the custom code outgrew the original toolkit entirely.

5 years of design pivots with strategic refactoring: The game underwent significant mechanical overhauls — energy systems changed multiple times, movement went from free to chess-style, melee combat was reworked, the shop/economy was built and rebuilt, abilities went from simple to two-tier leveling. The codebase isn’t spotless — there’s dead code from the original toolkit and deprecated systems that were kept because we occasionally rolled features back. It’s been a balancing act between the client wanting new features and me identifying the right moments to refactor, typically when a system had changed so much that the old architecture no longer made sense. The key systems stayed maintainable through those targeted refactors and modular design.

Ability system scalability: 8 heroes (with more planned), each with unique abilities and level 2 upgrades, all feeding through a single activation pipeline. Had to handle abilities that interact with each other (damage reduction stacking with freeze), abilities that steal from enemies (Spell Steal permanently transferring spells), and forced actions (Betrayal turning a target’s own allies against them) — while keeping the architecture extensible for new heroes.

Network replication across every system: Every game system needed to work correctly for both host and client. This wasn’t a single networking pass — each new feature required its own replication work, cross-platform testing, and state synchronization debugging. The hardest issues involved subtle state management problems that only surfaced in specific networked conditions.

Engine-level macOS cursor bug: Tracked down a rendering issue to Unreal Engine’s use of the wrong alpha format for macOS cursors. Fixed it by modifying engine source — requiring custom engine builds on Mac for the rest of the project.

Tools & Tech

Unreal Engine (Blueprints + C++), Advanced Turn-Based Tile Toolkit (ATBTT — heavily modified), Steam/Steamworks, UE Source Modification, Windows, macOS, Cross-Platform Builds