home / skills / bbeierle12 / skill-mcp-claude / case-studies-reference

case-studies-reference skill

/skills/case-studies-reference

This skill provides case-study driven insights on building systems from Fortnite, Rust, Valheim, Minecraft, No Man's Sky, and Satisfactory to inform design

npx playbooks add skill bbeierle12/skill-mcp-claude --skill case-studies-reference

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
3.4 KB
---
name: case-studies-reference
description: Game building mechanics case studies and decision frameworks. Use when designing building systems, evaluating trade-offs, or learning from existing games. Reference-only skill with detailed analysis of Fortnite, Rust, Valheim, Minecraft, No Man's Sky, and Satisfactory building systems.
---

# Case Studies Reference

Detailed analysis of building systems from successful games, plus decision frameworks for new projects.

## Quick Reference

| Game | Building Focus | Physics | Scale | Key Innovation |
|------|---------------|---------|-------|----------------|
| Fortnite | Combat/action | Arcade | Small | Edit system, speed |
| Rust | Survival/raids | Heuristic | Large | Tool Cupboard, decay |
| Valheim | Exploration | Heuristic | Medium | Stability from ground |
| Minecraft | Creativity | None | Infinite | Voxel simplicity |
| No Man's Sky | Base building | Minimal | Medium | Snap points, free place |
| Satisfactory | Factory | Grid-based | Large | Hybrid grid/free |

## When to Use This Skill

Use case studies when making design decisions such as which physics model to implement, how to handle multiplayer building, choosing between grid and free placement, and deciding on decay/upkeep systems. The analyses provide concrete examples of trade-offs and their outcomes.

## Reference Documents

See `references/` for detailed documentation covering game-by-game breakdowns of building mechanics and performance strategies, decision matrices for common architectural choices, anti-patterns identified from games that struggled, and architectural recommendations organized by game genre.

## Decision Framework

For quick decisions, use the matrices in `game-analyses.md`:

**Physics Mode Selection:** Are you building a survival game where building is about shelter? Use heuristic physics like Rust or Valheim. Is building core to moment-to-moment combat? Use arcade physics like Fortnite. Is engineering challenge the point? Consider realistic physics with caution since Medieval Engineers showed this approach frustrates most players.

**Multiplayer Architecture:** Competitive and PvP games require server-authoritative building with latency accepted as the cost of security. Cooperative games can use client prediction with server reconciliation for responsive feel. Single-player can use fully client-side for maximum responsiveness.

**Persistence Strategy:** Long-running servers need decay and cleanup. Rust's model combines gameplay balance through resource sinks with server health through automatic cleanup. Without decay, servers accumulate abandoned bases until performance degrades.

## Key Insights Summary

Rust demonstrates that decay serves dual purposes: gameplay balance by forcing maintenance, and server health by cleaning abandoned structures. Valheim shows that "magic force from ground" stability is more intuitive than realistic physics. Fortnite proves that speed and simplicity trump realism for action games. Satisfactory's hybrid approach of grid for structures plus free placement for conveyors satisfies both organized and creative builders.

## Related Skills

This reference skill pairs with implementation skills that provide working code for the patterns discussed here. Use `performance-at-scale` for spatial indexing, `structural-physics` for stability systems, `multiplayer-building` for networking, `terrain-integration` for foundation systems, `decay-upkeep` for maintenance systems, and `builder-ux` for user experience patterns.

Overview

This skill provides case studies and decision frameworks for game building mechanics, drawing on analysis of Fortnite, Rust, Valheim, Minecraft, No Man's Sky, and Satisfactory. It is a reference resource for designers choosing physics, placement systems, persistence, and multiplayer architectures. The content focuses on trade-offs, real-world outcomes, and actionable recommendations.

How this skill works

The skill inspects building systems across genres and extracts patterns: physics modes (arcade, heuristic, realistic), placement paradigms (grid vs free), persistence strategies (decay/upkeep), and multiplayer approaches (server-authoritative vs client-predicted). It summarizes key innovations, anti-patterns, and decision matrices to guide quick choices. Detailed game-by-game breakdowns explain why particular systems succeeded or caused problems.

When to use it

  • Designing a new building system and choosing between grid, snap, or free placement.
  • Selecting a physics model appropriate for combat, survival, or creative play.
  • Deciding persistence and cleanup mechanics for live servers to prevent sprawl.
  • Architecting multiplayer building to balance responsiveness and security.
  • Learning from existing games to avoid common anti-patterns and pitfalls.

Best practices

  • Match physics complexity to core gameplay: prioritize speed for action, heuristics for survival, and avoid full realism unless it serves the fun.
  • Use hybrid placement when you need both orderly construction and expressive layouts (e.g., grid for bases, free for connectors).
  • Implement decay or maintenance for long-running servers to manage abandoned builds and create resource sinks.
  • Favor server-authoritative approaches for PvP and competitive scenarios, and client prediction with reconciliation for cooperative play.
  • Document failure modes and anti-patterns from case studies to inform prototyping and testing.

Example use cases

  • Choosing whether to implement a building edit system for a fast-paced shooter like Fortnite.
  • Designing stability rules that feel intuitive by using ground-based heuristics like Valheim.
  • Creating a decay/upkeep loop for a survival MMO to reduce abandoned structures similar to Rust.
  • Combining grid-based factory placement with free conveyors for a Satisfactory-style engineering game.
  • Deciding multiplayer reconciliation strategies for cooperative base building.

FAQ

When should I pick grid vs free placement?

Use grid for clarity, performance, and predictable pipelines; use free placement for creativity and organic layouts; use hybrid when both needs exist.

Is realistic physics recommended for building systems?

Realistic physics can deepen simulation but often frustrates players; prefer heuristic or arcade models unless engineering realism is the core gameplay.