game-engines_skill

Overview

This skill teaches mastery of Unity, Unreal Engine, and Godot with engine-specific workflows, systems architecture, and production best practices. It summarizes component/node/actor models, lifecycle patterns, and optimization strategies for shipping stable, performant games. The content targets developers moving from learning to production-grade projects.

How this skill works

The skill inspects core engine patterns: Unity's GameObject + MonoBehaviour component model and lifecycle, Unreal's AActor/Component system and game framework, and Godot's Node tree, signals, and process loops. It highlights production-ready code patterns, movement/physics handling, animation handling, and build/runtime optimization tips. It also maps feature trade-offs across 2D/3D, networking, mobile, VR, and licensing to aid engine selection.

When to use it

• Choosing the right engine for a project (2D/3D, mobile, AAA, open source).
• Designing component/actor/node architectures and game lifecycles.
• Implementing production-ready movement, physics, and animation systems.
• Optimizing editor performance, build size, and runtime performance.
• Preparing projects for consoles, mobile, or VR/AR deployments.

Best practices

• Keep engine-specific responsibilities isolated: use services/managers for shared systems and components for object behavior.
• Follow the engine lifecycle rules: handle input in frame update and physics in fixed/physics update loops.
• Cache component references early (Awake/Constructor/_ready) to avoid GetComponent calls at runtime.
• Profile early and often: use build reports, profiler snapshots, and platform-specific tracing to find hot paths.
• Use deterministic physics settings and continuous collision for fast objects to avoid inconsistencies.
• Modularize assets and enable code stripping/compression to reduce build size and startup time.

Example use cases

• Implementing a responsive player controller with correct update separation (input vs physics) in Unity, Unreal, or Godot.
• Choosing an engine for a mobile 2D game (Unity or Godot) versus a high-fidelity console title (Unreal).
• Resolving physics glitches by moving collision handling to FixedUpdate/_physics_process and tuning timestep settings.
• Reducing build size by analyzing reports, removing unused assets, and enabling compression and code stripping.
• Building networked gameplay with engine-appropriate tooling: Netcode/MLAPI (Unity), built-in networking (Unreal), or ENet/Nakama (Godot).