Pick an Engine

# ===== The mainstream options =====
# Unity         C#; massive ecosystem; 2D + 3D; mobile + desktop + console + XR
# Unreal        C++ + Blueprints; AAA visuals; first-class 3D + cinematic
# Godot         GDScript + C# + C++; open-source; lightweight; 2D + 3D
# Bevy          Rust; ECS; code-first; modern
# PlayCanvas    JavaScript; web-first 3D
# Phaser        JavaScript; 2D web games
# MonoGame      C#; code-first; indie / retro fit
# Defold        Lua; King's open-source 2D engine; small bundles
# Cocos2d-x     C++ / TS; 2D games (especially mobile)

# ===== Decision tree =====
#
# What is the GOAL?
#   Hobby + learning + ship small        -> Godot or Phaser
#   Mobile 2D / hyper-casual              -> Unity or Defold
#   Mobile / desktop 3D                   -> Unity
#   AAA-grade 3D                          -> Unreal
#   Browser-only                          -> PlayCanvas / Phaser / three.js + custom
#   Web + native + tiny team              -> Godot (cross-platform export)
#   Modern code-first with safety         -> Bevy (Rust)
#   Console publishing                    -> Unity / Unreal (mature pipelines)
#   Education / kids                      -> GDevelop, Scratch, Construct
#
# What does the TEAM know?
#   C# strong              -> Unity
#   C++ strong             -> Unreal
#   JS / TS strong         -> PlayCanvas / Phaser
#   Rust strong            -> Bevy
#   Python or beginners    -> Godot (GDScript reads like Python)
#
# What is the LICENCE budget?
#   Unity:    free until USD 200k revenue / install thresholds
#   Unreal:   free until USD 1M lifetime gross revenue
#   Godot:    MIT, no royalties
#   Bevy:     MIT/Apache, no royalties

# ===== Reality checks =====
# - 'I will write my own engine' -> almost always wrong unless engine itself is the project
# - Pick the engine your TEAM can ship in; not the one Reddit prefers this month
# - Switching engines mid-project loses 30-60% of work
# - For learning, Godot or Phaser are the friendliest

# ===== A minimal Godot example =====
# Scene: a Node2D root; a Sprite2D child; a script:
extends Node2D
var vel := Vector2(120, 60)
func _process(delta):
    position += vel * delta
    if position.x < 0 or position.x > 600:
        vel.x = -vel.x
    if position.y < 0 or position.y > 400:
        vel.y = -vel.y

# ===== A minimal Phaser example =====
import Phaser from 'phaser';
new Phaser.Game({
  type: Phaser.AUTO, width: 600, height: 400,
  scene: {
    create() {
      this.rect = this.add.rectangle(100, 100, 20, 20, 0xff0000);
      this.vel = { x: 120, y: 60 };
    },
    update(_, dt) {
      const s = dt / 1000;
      this.rect.x += this.vel.x * s; this.rect.y += this.vel.y * s;
      if (this.rect.x < 0 || this.rect.x > 600) this.vel.x = -this.vel.x;
      if (this.rect.y < 0 || this.rect.y > 400) this.vel.y = -this.vel.y;
    },
  },
});

# ===== Patterns to internalise =====
# - Ship something small in the engine before committing
# - Pick an engine that matches the platform + the team
# - Use version control (git + LFS for binaries) from day one
# - Profile early; do not guess where frames go

# ===== Pitfalls =====
# - Picking by hype; the tutorial you start with may not exist for the next engine
# - Underestimating console / store certification time
# - Building your own engine when Unity / Godot would have done
# - 'We will port to mobile later' without designing input + memory for it

// Unity   — biggest ecosystem; C#; great for 2D & 3D, mobile, AR/VR.
// Godot   — open source; GDScript or C#; lightweight, fast iteration.
// Unreal  — top-tier 3D; Blueprints + C++; AAA visuals.
// Phaser  — JS/TS; web/mobile 2D.
// LÖVE    — Lua; tiny 2D toy framework.