Intro

// ===== The shape =====
// Loop: input -> update -> render, every frame
// State: positions, velocities, AI, inputs, scores
// Assets: textures, models, sounds, fonts
// Tools: an engine + an editor + your code

// ===== Engines (mainstream) =====
// Unity        C#, massive ecosystem, 2D + 3D + XR, multi-platform
// Unreal       C++ / Blueprints, AAA visuals, free until threshold
// Godot        GDScript / C#, open-source, lightweight, growing fast
// PlayCanvas   JS, web-first 3D
// Phaser       JS, 2D web games
// Bevy         Rust, ECS, code-first
// MonoGame     C#, code-first, indie favourite

// ===== Tiny game loop (browser canvas) =====
const STEP = 1/60;
let acc = 0, last = performance.now();
let pos = { x: 100, y: 100 }, vel = { x: 120, y: 60 };

function frame(now) {
  const dt = Math.min(0.25, (now - last) / 1000); last = now;
  acc += dt;
  while (acc >= STEP) {
    pos.x += vel.x * STEP; pos.y += vel.y * STEP;
    if (pos.x < 0 || pos.x > 600) vel.x = -vel.x;
    if (pos.y < 0 || pos.y > 400) vel.y = -vel.y;
    acc -= STEP;
  }
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  ctx.fillRect(pos.x, pos.y, 20, 20);
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

// ===== Math you cannot avoid =====
// Vectors, dot/cross products
// Matrices for transforms (translate / rotate / scale)
// Trigonometry for rotation, projection, oscillation
// Easings for animation feel

// ===== Patterns you will meet =====
// Game loop (fixed timestep, interpolated render)
// State machines (FSM) for AI behaviours
// Entity-Component-System (ECS) for data-oriented design
// Object pooling for performance
// Quadtrees / spatial grids for collision

// ===== When gamedev wins =====
// - Interactive experiences (games, sims, training)
// - Visualisations + interactive marketing
// - Engineering practice (math + perf + architecture all matter)

// ===== When gamedev hurts =====
// - Solo dev shipping at scope you can not finish
// - Live-ops games without an ops budget
// - Mobile distribution + payments is its own beast

// ===== Patterns to internalise =====
// - Pick an engine + ship a tiny game first; switching later is OK
// - Fixed timestep for physics; interpolated render for smoothness
// - Profile early; do not guess where frames go
// - Source control everything (LFS for binaries)

// ===== Pitfalls =====
// - Building your own engine when an off-the-shelf one would do
// - Frame-locked physics on slow machines -> jitter
// - O(N^2) collisions on big worlds
// - No save system until late -> playtesting is painful

// Game dev = engineering + design + art + audio + production.
// Start tiny. Ship something playable in a weekend. Iterate.