How do I choose the engine for a PC/Console project?

Use the Engine Decision Tree based on game type (2D/3D), cross-platform needs, and features, then verify against platform certification requirements.

When should I profile and optimize?

Early and often. Use engine tools like Unity Profiler, Godot Debugger/Profiler, or Unreal Insights to identify bottlenecks early.

How should input and controller support be handled?

Abstract input to actions (e.g., confirm/cancel) and map them to platform-specific buttons; implement consistent haptics and UI behavior across controllers.

pc-games

Scanned

npx machina-cli add skill vudovn/antigravity-kit/pc-games --openclaw

Files (1)

SKILL.md

2.9 KB

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.

Source

git clone https://github.com/vudovn/antigravity-kit/blob/main/.agent/skills/game-development/pc-games/SKILL.mdView on GitHub

Overview

Learn how to select the right engine for PC and console titles, and how to apply platform features and optimization strategies. This skill collates engine selection, platform certification, input, and profiling practices to help you ship performant games.

How This Skill Works

The skill guides you through engine selection using a decision tree and comparison factors, then applies platform features, controller input, and haptics planning. It also emphasizes profiling and solving performance bottlenecks with engine-specific tools like Unity, Godot, and Unreal.

When to Use It

Starting a new PC/console project and need engine direction
Deciding between 2D vs 3D and cross-platform goals
Preparing for console certification and platform guidelines
Identifying and solving performance bottlenecks during prototyping
Implementing robust input, actions mapping, and adaptive haptics early

Quick Start

Step 1: Define target platforms and game type (2D or 3D).
Step 2: Run the Engine Selection Decision Tree to pick Unity, Godot, or Unreal.
Step 3: Outline input mapping, haptics plan, and a basic profiling schedule; start your first build.

Best Practices

Profile early and often using the engine's profiling tools
Map actions, not buttons, to support cross-platform input
Prioritize draw call reduction with batching and texture atlases
Minimize GC spikes with object pooling and memory-friendly patterns
Follow platform guidelines and complete certification requirements early

Example Use Cases

Indie 2D project using Godot 4 for rapid iteration
Cross-platform 3D title using Unity with DOTS and Addressables
AAA game leveraging Unreal 5 with Nanite and Lumen
Steam-integrated title featuring achievements, cloud saves and rich presence
Console-ready game prepared for TRC/Lotcheck certification

Frequently Asked Questions

Add this skill to your agents