home / skills / vudovn / antigravity-kit / pc-games

pc-games skill

safe

/.agent/skills/game-development/pc-games

This skill guides engine selection, platform features, and optimization strategies for PC and console game development across popular engines.

npx playbooks add skill vudovn/antigravity-kit --skill pc-games

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

Files (1)

SKILL.md

2.9 KB

---
name: pc-games
description: PC and console game development principles. Engine selection, platform features, optimization strategies.
allowed-tools: Read, Write, Edit, Glob, Grep
---

# PC/Console Game Development

> Engine selection and platform-specific principles.

---

## 1. Engine Selection

### Decision Tree

```
What are you building?
│
├── 2D Game
│   ├── Open source important? → Godot
│   └── Large team/assets? → Unity
│
├── 3D Game
│   ├── AAA visual quality? → Unreal
│   ├── Cross-platform priority? → Unity
│   └── Indie/open source? → Godot 4
│
└── Specific Needs
    ├── DOTS performance? → Unity
    ├── Nanite/Lumen? → Unreal
    └── Lightweight? → Godot
```

### Comparison

| Factor | Unity 6 | Godot 4 | Unreal 5 |
|--------|---------|---------|----------|
| 2D | Good | Excellent | Limited |
| 3D | Good | Good | Excellent |
| Learning | Medium | Easy | Hard |
| Cost | Revenue share | Free | 5% after $1M |
| Team | Any | Solo-Medium | Medium-Large |

---

## 2. Platform Features

### Steam Integration

| Feature | Purpose |
|---------|---------|
| Achievements | Player goals |
| Cloud Saves | Cross-device progress |
| Leaderboards | Competition |
| Workshop | User mods |
| Rich Presence | Show in-game status |

### Console Requirements

| Platform | Certification |
|----------|--------------|
| PlayStation | TRC compliance |
| Xbox | XR compliance |
| Nintendo | Lotcheck |

---

## 3. Controller Support

### Input Abstraction

```
Map ACTIONS, not buttons:
- "confirm" → A (Xbox), Cross (PS), B (Nintendo)
- "cancel" → B (Xbox), Circle (PS), A (Nintendo)
```

### Haptic Feedback

| Intensity | Use |
|-----------|-----|
| Light | UI feedback |
| Medium | Impacts |
| Heavy | Major events |

---

## 4. Performance Optimization

### Profiling First

| Engine | Tool |
|--------|------|
| Unity | Profiler Window |
| Godot | Debugger → Profiler |
| Unreal | Unreal Insights |

### Common Bottlenecks

| Bottleneck | Solution |
|------------|----------|
| Draw calls | Batching, atlases |
| GC spikes | Object pooling |
| Physics | Simpler colliders |
| Shaders | LOD shaders |

---

## 5. Engine-Specific Principles

### Unity 6

- DOTS for performance-critical systems
- Burst compiler for hot paths
- Addressables for asset streaming

### Godot 4

- GDScript for rapid iteration
- C# for complex logic
- Signals for decoupling

### Unreal 5

- Blueprint for designers
- C++ for performance
- Nanite for high-poly environments
- Lumen for dynamic lighting

---

## 6. Anti-Patterns

| ❌ Don't | ✅ Do |
|----------|-------|
| Choose engine by hype | Choose by project needs |
| Ignore platform guidelines | Study certification requirements |
| Hardcode input buttons | Abstract to actions |
| Skip profiling | Profile early and often |

---

> **Remember:** Engine is a tool. Master the principles, then adapt to any engine.

Overview

This skill covers core principles for PC and console game development, focusing on engine selection, platform features, controller support, and performance optimization. It distills practical guidance for choosing between Unity, Godot, and Unreal, and outlines platform and certification requirements. The content targets developers deciding architecture, tooling, and optimization strategies for cross-platform projects.

How this skill works

It inspects project goals—genre (2D/3D), team size, visual targets, and specific needs like high performance or lightweight deployment—to recommend an engine and workflows. It maps platform features (Steam, PlayStation, Xbox, Nintendo) to implementation priorities and prescribes input abstraction, haptic patterns, and profiling-first optimization steps. Engine-specific best practices for Unity, Godot, and Unreal are highlighted to guide implementation choices.

When to use it

Selecting an engine for a new 2D or 3D game based on team size and visual targets
Planning platform integration (Steam features or console certification) before development
Designing input systems that abstract actions across controllers and platforms
Optimizing performance where profiling reveals draw calls, GC spikes, or physics bottlenecks
Deciding when to use engine-specific features like DOTS, Nanite, or Godot signals

Best practices

Choose the engine by project needs (genre, team, performance), not hype
Profile early and often; address the largest bottlenecks first
Abstract inputs to actions instead of hardcoding button mappings
Use object pooling, batching, and LOD/shader simplification to reduce runtime cost
Follow platform certification and platform-holder guidance before submission

Example use cases

Indie 2D platformer: pick Godot for fast iteration or Unity for larger teams and asset pipelines
Cross-platform 3D game with mid-level visuals: use Unity for portability and mature tooling
High-fidelity AAA environment: adopt Unreal to leverage Nanite and Lumen
Multiplayer PC release on Steam: integrate achievements, cloud saves, leaderboards, and workshop support
Controller-driven console title: implement action mapping and haptic tiers for consistent UX

FAQ

How do I choose between Unity, Godot, and Unreal?

Pick based on game scope: Godot for lightweight or solo projects and 2D excellence; Unity for cross-platform, medium teams, and flexible pipelines; Unreal for top-tier visual fidelity and large-team AAA work.

What should I profile first on a slow build?

Start with the frame time breakdown: GPU draw calls and overdraw, CPU main-thread time, physics steps, and GC activity. Fix the largest contributor with batching, collider simplification, or pooling.