Lua for Game Development

-- The GAME LOOP is the heartbeat of every game. Each frame it does
-- three things in order: read input, UPDATE the world, then DRAW it.
-- LÖVE (the popular Lua game framework, written "LÖVE2D") gives you
-- three callbacks to fill in — it calls them for you ~60 times a second.

function love.load()
  -- Runs ONCE at startup. Set up your starting state here.
  player = { x = 400, y = 300, speed = 200 }   -- a table = one entity
end

function love.update(dt)        -- dt = "delta time": seconds since the last frame
  -- Move right while the right arrow is held down.
  if love.keyboard.isDown("right") then
    player.x = player.x + player.speed * dt     -- * dt keeps speed frame-rate-independent
  end
  if love.keyboard.isDown("left") then
    player.x = player.x - player.speed * dt
  end
end

function love.draw()
  -- Draw a filled circle at the player's position, radius 20.
  love.graphics.circle("fill", player.x, player.y, 20)
end

-- Behaviour: a circle slides left/right at 200 pixels per second,
-- moving the same real-world distance whether the game runs at 30 or 144 fps.

-- POSITION + VELOCITY is the simplest physics there is. A position is
-- "where you are" (x, y); a velocity is "how fast x and y are changing".
-- Each frame:  new position = old position + velocity * dt.

-- A reusable 2D vector built from a plain table.
local function vec(x, y) return { x = x, y = y } end

local ball = {
  pos = vec(0, 100),     -- starts at the left edge, 100px down
  vel = vec(60, 0),      -- moving right at 60 px/s, not moving vertically
}

local gravity = vec(0, 90)   -- pulls 90 px/s DOWNWARD every second (y grows down)

-- Simulate 3 frames of a 0.5-second step so you can read the numbers.
local dt = 0.5
for frame = 1, 3 do
  -- 1) gravity changes the velocity
  ball.vel.x = ball.vel.x + gravity.x * dt
  ball.vel.y = ball.vel.y + gravity.y * dt
  -- 2) velocity changes the position
  ball.pos.x = ball.pos.x + ball.vel.x * dt
  ball.pos.y = ball.pos.y + ball.vel.y * dt
  print(string.format("frame %d: pos=(%.1f, %.1f) vel=(%.1f, %.1f)",
        frame, ball.pos.x, ball.pos.y, ball.vel.x, ball.vel.y))
end

-- Behaviour (prints):
-- frame 1: pos=(30.0, 122.5) vel=(60.0, 45.0)
-- frame 2: pos=(60.0, 167.5) vel=(60.0, 90.0)
-- frame 3: pos=(90.0, 235.0) vel=(60.0, 135.0)
-- The ball drifts right at a steady 60 px/s while falling faster and faster.

-- ENTITIES AS TABLES: every game object is just a table of fields,
-- and you keep them all in one list so the loop can update them together.
-- Remember: Lua tables (lists) are 1-BASED — the first entity is [1].

local entities = {}   -- our list of game objects

-- A tiny factory: build an entity table and add it to the list.
local function spawn(kind, x, y, hp)
  local e = { kind = kind, x = x, y = y, hp = hp, alive = true }
  table.insert(entities, e)             -- appends at position #entities + 1
  return e
end

spawn("Player", 0, 0, 100)
local goblin = spawn("Goblin", 50, 0, 30)
spawn("Goblin", 80, 10, 30)

-- Apply damage to one entity; mark it dead at 0 hp.
local function damage(e, amount)
  e.hp = e.hp - amount
  if e.hp <= 0 then e.alive = false end
end

damage(goblin, 30)        -- 30 - 30 = 0, so goblin.alive becomes false

-- ipairs walks the list in order from index 1; count who is still alive.
local alive = 0
for index, e in ipairs(entities) do
  if e.alive then alive = alive + 1 end
end
print("Entities still alive:", alive)   -- prints: Entities still alive:	2

-- Outside LÖVE, Lua powers ROBLOX (via "Luau", its dialect), Defold,
-- Garry's Mod, and World of Warcraft addons. Here is a Roblox-style
-- server Script: give every player who joins a coin counter.

local Players = game:GetService("Players")

-- PlayerAdded fires once per player; we connect a function to that event.
Players.PlayerAdded:Connect(function(player)
  local stats = Instance.new("Folder")   -- a container object
  stats.Name = "leaderstats"             -- this exact name shows a leaderboard
  stats.Parent = player

  local coins = Instance.new("IntValue") -- holds a whole number
  coins.Name = "Coins"
  coins.Value = 0
  coins.Parent = stats

  print(player.Name .. " joined — gave them 0 coins")
end)

-- Luau also adds string interpolation with backticks and {} :
-- local name = "Sam"
-- print(`Welcome, {name}!`)   -- Luau only; prints: Welcome, Sam!

-- Behaviour: the moment a player joins, a "Coins" value starting at 0
-- appears on the in-game leaderboard, and a join message is printed.

-- 🎯 YOUR TURN — make movement frame-rate-INDEPENDENT.
-- A player should move 150 pixels every second no matter the frame rate.
-- That means: position changes by speed * dt each frame.

local player = { x = 0, speed = 150 }

function love.update(dt)
  if love.keyboard.isDown("right") then
    -- 1) Move the player right by speed scaled by delta time.
    player.x = player.x + ___          -- 👉 multiply player.speed by dt
  end
end

-- ✅ Expected: after holding "right" for exactly 1 second of real time,
--    player.x has increased by 150 (because 150 * (sum of dt) = 150).

-- 🎯 YOUR TURN — count living enemies the 1-based Lua way.
local enemies = {
  { name = "Bat",     alive = true  },
  { name = "Slime",   alive = false },
  { name = "Skeleton", alive = true },
}

local alive = 0
-- 1) Loop the list IN ORDER starting at index 1 (hint: ipairs).
for _, e in ___(enemies) do            -- 👉 the iterator that starts at index 1
  -- 2) Only count the ones whose alive field is true.
  if ___ then                          -- 👉 e.alive
    alive = alive + 1
  end
end

print("Alive:", alive)
-- ✅ Expected output:  Alive:	2