A top-down 2D roguelike where you play as pest exterminators clearing bug infestations. Think Enter the Gungeon meets Vampire Survivors with a darkly comedic twist.
For Players/Game Design: Overview • Features • How to Play • Status
For Developers: Getting Started • Development • Tech Stack • Architecture • Contributing
Hazard Pay is a top-down 2D pixel-art roguelike featuring "intentionally broken" character progression. Players choose from 4-5 unlockable exterminators, each with overpowered mechanics balanced by meaningful constraints, to clear procedurally arranged industrial sectors.
- Navigate through 25 procedurally arranged rooms (Sectors) with branching paths
- Fight increasingly challenging bug infestations using tactical fire spread and crowd control
- Choose 1 of 3 upgrades (Performance Reviews) after each room
- Level up to unlock path abilities at levels 10, 20, 30
- Defeat mid-boss (Sector ~12) and final boss (Sector 25)
- Unlock Overtime Mode (Endless) for infinite scaling challenge
| Pillar | What It Means |
|---|---|
| Systemic Variation | Each room forces tactical adaptation, not just higher numbers |
| Enemies as Teachers | Every bug type teaches a specific mechanic |
| Intentionally Broken | Overpowered abilities balanced by meaningful constraints |
Each character has one overpowered mechanic balanced by a constraint:
| Character | Power | Constraint |
|---|---|---|
| Flamethrower | Fire spreads infinitely between enemies | Takes damage in own flames |
| Beekeeper | Dead bugs become allies | Cannot deal direct damage |
| Cryo-Tech | Frozen enemies shatter and chain-freeze | Cannot damage unfrozen enemies |
| Swatter | Melee specialist with execute mechanic | Close-range only |
| Sprayer | Chemical DOT with poison immunity | Damage over time (no burst) |
1. Room Upgrades (Per-Run)
- Choose 1 of 3 after each room clear
- Categories: Power (damage/weapons), Defense (HP/resistances), Utility (speed/cooldowns)
- ~25 upgrade choices per full run
2. Level-Up Path System (Per-Run)
- Every Level: Auto-heal X% HP
- Level 10: Choose 1 of 3 major path branches (significant power spike)
- Level 20: Choose 1 of 2 options based on Level 10 choice
- Level 30: Final path choice (Endless Mode only, massive power spike)
- Level 31+: Permanent character-specific buffs each level (Endless only)
3. Meta-Progression (Persistent)
- Earn currency from runs
- Unlock new characters (after milestone achievements)
- Unlock additional character path trees
- Small meaningful upgrades
- 25 rooms total with Slay the Spire-style branching paths
- Room Types: Combat, Shop, Elite, "Unknown" (random modifiers/events)
- Bosses: Mid-boss (~room 12), Final boss (room 25)
- Endless Mode: Unlocked after beating final boss, separate mode per map
"Enemies as teachers" - each type exists to teach a specific mechanic:
- Roaches: Swarm tactics (teaches AOE value)
- Spiders: Web traps, ceiling walkers (teaches awareness)
- Wasps: Flying, ranged (teaches target priority)
- Beetles: Armored (teaches armor-piercing value)
- Larvae: Evolve if not killed quickly (teaches tempo)
- ✅ Combat system (move, aim, shoot, damage)
- ✅ Enemy AI and spawning
- ✅ Health system with visual feedback
- ✅ XP and leveling system
- ✅ Basic UI (health bar, XP bar, level-up screen)
- ✅ Object pooling system (2000+ enemy capacity)
- ✅ Status effect system with visual effects
- ✅ Fire spread mechanics working at scale
- 2000+ simultaneous enemies at stable 60 FPS
- Zero GC allocations during gameplay (after pool warmup)
- Status effects with VFX working on all enemies
- True "horde extermination" gameplay enabled
See PERFORMANCE.md for detailed metrics and optimizations.
- Room clearing and transitions
- Upgrade selection UI (pick 1 of 3)
- Path branches at levels 10/20
- 15-20 varied room designs
- First boss encounter
- Movement speed tuning
- Dodge mechanic (dash/roll/i-frames?)
- Damage feedback visuals (screen shake, particles)
- Heal percentage on level-up
- Character-specific attack patterns
- Unity 6.3 LTS or later
- Git installed
- GitHub account with repo access
- Code editor (VS, Rider, or VS Code)
-
Clone the repository
git clone https://github.com/[your-username]/exterminator-game.git cd exterminator-game -
Open in Unity
- Open Unity Hub
- Click "Add" → select cloned folder
- Unity automatically imports assets
-
Test the setup
- Open
Scenes/GameplayTest.unity - Press Play
- Controls: WASD to move, mouse to aim
- Should see player capsule moving smoothly
- Open
-
Create a feature branch
git checkout dev git pull origin dev git checkout -b feature/your-feature-name
For developers working on the project. Game designers and players can skip to the end.
| Component | Technology |
|---|---|
| Engine | Unity 6.3 LTS |
| Rendering | Universal Render Pipeline (URP) |
| Perspective | 2D (top-down orthographic camera) |
| Physics | Unity 2D Physics (Rigidbody2D, Collider2D) |
| Language | C# (.NET Standard 2.1) |
| Version Control | Git + GitHub |
| Project Management | JIRA |
- Component-based: Modular MonoBehaviours with single responsibilities
- Event-driven: Centralized
GameEvents.csfor system communication - Data-driven: ScriptableObjects for all configuration (upgrades, enemies, weapons)
- Manager orchestration: Sparse use of singleton managers to coordinate systems
Assets/
└── _Project/
├── Scenes/
│ ├── MainMenu.unity
│ ├── GameplayTest.unity
│ └── Endless.unity
│
├── Scripts/
│ ├── Managers/ # Singleton-style orchestrators
│ │ ├── GameManager.cs
│ │ ├── RoomManager.cs
│ │ ├── XPManager.cs
│ │ ├── UpgradeManager.cs
│ │ └── AudioManager.cs
│ │
│ ├── Player/ # Player-specific components
│ │ ├── PlayerController.cs # Orchestrator
│ │ ├── PlayerMovement.cs # Movement logic
│ │ ├── PlayerAiming.cs # Aiming logic
│ │ ├── PlayerAttack.cs # Attack logic
│ │ └── PlayerStats.cs # Data class
│ │
│ ├── Enemies/ # Enemy components
│ │ ├── Enemy.cs # Base enemy orchestrator
│ │ ├── EnemyMovement.cs
│ │ ├── EnemyAttack.cs
│ │ └── Types/
│ │ ├── Roach.cs
│ │ ├── Spider.cs
│ │ └── Wasp.cs
│ │
│ ├── Shared/ # Universal components
│ │ ├── Health.cs # Universal health system
│ │ ├── IDamageable.cs # Damage interface
│ │ └── Destructible.cs
│ │
│ ├── Systems/ # Non-MonoBehaviour logic
│ │ ├── SpawnSystem.cs
│ │ ├── CombatCalculator.cs
│ │ └── PoolingSystem.cs
│ │
│ ├── Data/ # ScriptableObject definitions
│ │ ├── UpgradeData.cs
│ │ ├── EnemyData.cs
│ │ └── WeaponData.cs
│ │
│ ├── Events/ # Event system
│ │ └── GameEvents.cs # Centralized event hub
│ │
│ └── UI/ # UI components
│ ├── HealthBarUI.cs
│ ├── UpgradeUI.cs
│ └── XPBarUI.cs
│
├── Prefabs/ # Reusable GameObjects
│ ├── Player/
│ ├── Enemies/
│ ├── Projectiles/
│ └── UI/
│
├── Data/ # ScriptableObject .asset files
│ ├── Upgrades/
│ ├── Enemies/
│ └── Weapons/
│
├── Art/ # Visual assets
├── Audio/ # Sound/music
└── Materials/ # Unity materials
Total Timeline: 20 months | Weekly Budget: ~6.5 hours
Deliverable: Playable combat loop (kill enemies, gain XP, level up)
- Unity setup and tutorials
- Movement + enemy AI
- Health/damage system
- Event system wiring
- Level-up system
Deliverable: Complete run with upgrades and boss
- Room clearing and transitions
- Upgrade system (1 of 3 choices)
- Path progression (levels 10/20)
- 15-20 varied rooms
- First boss fight
Deliverable: Replayable game with variety
- Second character
- 8-10 enemy types
- Room modifiers (hazards, constraints)
- Meta-progression (currency, unlocks)
- Endless mode
Deliverable: Presentable vertical slice
- Bug fixes and UI polish
- External playtesting
- Balance pass
- Ready for public viewing
Deliverable: Ship-ready product
- 3-4 additional characters
- Full enemy roster (15 types)
- Marketing (Twitter devlog, Steam page)
- Professional art evaluation
- Final polish and launch
1. Component-Based Modularity
- Each script has ONE responsibility
PlayerControllerorchestrates;PlayerMovement,PlayerAiming,PlayerAttackexecute- Example: Movement doesn't handle aiming or shooting
2. Event-Driven Communication
- Cross-system messaging via
GameEvents.cs - Decouples systems (Enemy doesn't need to know about XPManager)
- Pattern:
OnEventFired → Multiple systems react independently
3. Data-Driven Configuration
- All game data lives in ScriptableObjects (.asset files)
- Upgrades, enemies, weapons → designer-friendly, no code changes needed
4. Sparse Manager Use
- Managers coordinate high-level flow only
- Managers DON'T do work—they tell other systems to act
- Target: 5-7 managers maximum
Enemy.Die()
→ GameEvents.OnEnemyKilled?.Invoke(this)
→ XPManager.AwardXP()
→ RoomManager.CheckRoomClear()
→ AudioManager.PlayDeathSound()
→ UIManager.UpdateKillCount()
| Rule | Details |
|---|---|
| Naming | PascalCase for public, camelCase for private |
| Comments | Explain WHY, not WHAT (code should self-document) |
| Responsibility | If a class does 2+ things, split it |
| Events | Always unsubscribe in OnDisable() to prevent leaks |
| Commits | Clear messages ("Add enemy spawn system", not "update") |
| Role | Details | Focus |
|---|---|---|
| Developer 1 | Age 15, Game design, UI, progression, balance, art | |
| Developer 2 | Age 23, Architecture, enemy AI, combat, optimization |
30-minute sync meetings:
- Review (10min) — What worked? What blocked us?
- Plan (15min) — 2-3 tasks each, max 4 hours per task
- Check-in (5min) — Still on track? Still motivated?
Each month ask:
- ✅ Did we hit the deliverable?
- ✅ Do we still want to work on this?
- ✅ Are we having fun?
Result: 2-3/3 ✅ = continue | 1/3 ✅ = reassess | 0/3 ✅ = pivot or pause
Developer 1 tendency: Hyperfocus for 40 hours → burnout → abandon
Mitigation:
- ⏱ Time-box sessions: 2 hours max with breaks
- 💾 Commit broken code: Use
[WIP]tags - 🎉 Celebrate small wins: Don't wait for "finished feature"
- 🎯 One feature max per week
- 🤝 Weekly accountability check-ins
main # Stable builds only (protected, no direct commits)
↑
dev # Integration branch for features
↑
feature/* # Your work-in-progress branches
Start of session:
git checkout dev && git pull origin dev
git checkout -b feature/task-nameDuring work (commit every 30-60min):
git add .
git commit -m "Add feature description"
git push origin feature/task-nameEnd of session:
- Create Pull Request on GitHub
- Assign to other developer for review
- DON'T merge your own PRs (unless emergency)
✅ Good: "Add enemy spawn system", "Fix diagonal movement speed bug"
❌ Bad: "update", "fix stuff", "changes"
- Maximum 4 hours per task — break larger work into sub-tasks
- Commit WIP code — use
[WIP]tag, don't wait for perfection - Push regularly — don't hold changes locally for days
- Code compiles without errors/warnings
- No debug logs (or marked
// TODO: remove) - Single responsibility per component
- Event unsubscriptions in
OnDisable()if subscribed inOnEnable() - Game data in ScriptableObjects (no hardcoded values)
- Tested in Play mode (doesn't crash)
When reviewing, ask:
- Does it solve the stated problem?
- Is the approach reasonable for our timeline?
- Any obvious performance issues?
- Does it follow our architecture patterns?
Goal: Catch critical issues, not nitpick style. We have 280 hours total.
Each room introduces new constraints/modifiers/risk-reward scenarios that force tactical adaptation.
- ✅ Different challenge (not just higher numbers)
- ✅ Examples: hazards, arena shrinking, darkness, swarm composition
- ❌ Don't make it "same fight but HP doubled"
Each bug type teaches a specific mechanic or counters a strategy.
- ✅ Design question: "What does this enemy force the player to learn?"
- ✅ Examples: Roaches teach AOE value, Beetles teach armor penetration
- ❌ Don't create stat variations
Each character has one overpowered mechanic balanced by a meaningful constraint.
- ✅ Makes the character feel like an exploit discovery
- ✅ Examples: Beekeeper (allies, no direct damage), Flamethrower (spreads, takes damage)
- ❌ Balanced characters feel boring
- Early rooms: Moderately easy, never boring
- Mid-game: Smooth difficulty curve with spikes at bosses/elites
- Late-game: Occasional surprises to keep players alert
- General rule: Never too hard at start, never too easy at end
| Question | Options |
|---|---|
| Movement speed | Final tuning value? |
| Dodge mechanic | Dash? Roll? I-frames? |
| Attack patterns | Per-character variations? |
| Damage feedback | Screen shake, hit-stop, particles? |
| Heal % on level-up | Percentage value? |
| Upgrade power scaling | +10%, +20%, or variable? |
| XP curve | Linear or exponential? |
| Enemy scaling | HP/damage progression formula? |
- Currency sources (performance bonuses? found treasure? room completion?)
- Shop frequency and inventory size
- Unlock pricing structure
- Health system architecture (events vs inheritance)?
- Player death behavior and penalties
- Enemy death drops (loot system)?
- Room modifier types and selection algorithm
| Scenario | Likelihood | Copies | Revenue |
|---|---|---|---|
| Passion Project | 80%+ | 200-500 | $500-$2k |
| Modest Success | 5-10% | 5k-20k | $35k-$200k |
| Breakout Hit | <1% | 100k+ | $500k-$2M+ |
Strategy: Don't count on C, work toward B, expect A. This is a learning project first, commercial second.
- Twitter: Regular dev logs with GIFs (#indiedev #roguelike)
- Blog/YouTube: Weekly progress updates
- Steam: Build 10k+ wishlists pre-launch
- Outreach: Contact streamers and communities
- Discord: Build community early
- Start with programmer art
- Evaluate at Month 6
- Hire artist if needed (budget: $1k-$3.5k post-apprenticeship)
License: Proprietary — All rights reserved (closed-source learning project)
Questions or feedback:
Game Inspiration: Hades, Dead Cells, Slay the Spire, Enter the Gungeon Technical Guidance: Unity best practices, GDC talks, community resources
Last Updated: January 2026 | Current Phase: Month 1 — Foundation | Next Milestone: Functional combat loop
"Exterminate with style. 🪲🔫"