Lua Basics

-- This is a statement that assigns the value "hello" to the variable "greeting"
greeting = "hello"

-- This is a comment and will be ignored by the interpreter
greeting = "hello"

-- Function to check pal's health
function checkPalHealth()
    -- Get pal using getPal function
    local pal = getPal("anubis")
    -- Return pal's health
    return pal.health
end

-- Declaring a variable
local x = 5

-- Declaring a variable without the `local` keyword
y = 10

-- Declaring a number variable
local age = 25

-- Declaring a string variable
local name = "John"

-- Declaring a boolean variable
local isValid = true

-- Declaring a table variable
local myTable = {1, 2, 3}

-- Declaring a function
function sayHello()
    print("Hello!")
end

-- Calling a function
sayHello()

-- Declaring a function with parameters
function add(x, y)
    return x + y
end

-- Calling a function with arguments
result = add(5, 10)

-- Storing a function in a variable
local myFunction = function()
    print("Hello!")
end

-- Passing a function as an argument
otherFunction(myFunction)

-- If-else statement
local x = 5
if x > 10 then
    print("x is greater than 10")
else
    print("x is less than or equal to 10")
end

-- Elseif statement
local x = 5
if x > 10 then
    print("x is greater than 10")
elseif x < 0 then
    print("x is less than 0")
else
    print("x is between 0 and 10")
end

-- For loop
for i = 1, 10 do
    print(i)
end

-- While loop
local x = 5
while x > 0 do
    print(x)
    x = x - 1
end

-- Repeat until
local x = 5
repeat
    x = x - 1
    print(x)
until x == 0

-- Creating a table
local myTable = {
    ["name"] = "John",
    ["age"] = 25,
    [3] = "hello",
    -- Tables can be used as values of other tables
    ["nestedTable"] = {
        ["key"] = "value"
    }
}

-- Accessing table elements
print(myTable["name"]) -- Output: John
print(myTable.name)     -- Output: John
print(myTable[3])      -- Output: hello
print(myTable.nestedTable.key) -- Output: value

-- Creating a metatable
local myMetatable = {
    __add = function(table1, table2)
        local newTable = {}
        for k, v in pairs(table1) do
            newTable[k] = v
        end
        for k, v in pairs(table2) do
            newTable[k] = v
        end
        return newTable
    end
}

-- Setting the metatable
setmetatable(myTable, myMetatable)

-- Using the metamethod
local myOtherTable = {
    ["city"] = "New York",
    ["country"] = "USA"
}
local myCombinedTable = myTable + myOtherTable
print(myCombinedTable.name)     -- Output: John
print(myCombinedTable.city)     -- Output: New York

-- Define a class
local Player = {}
Player.__index = Player

function Player.new(name, health)
    local self = setmetatable({}, Player)
    self.name = name
    self.health = health
    return self
end

function Player:takeDamage(amount)
    self.health = self.health - amount
end

-- Creating an instance
local player = Player.new("Hero", 100)
player:takeDamage(10)
print(player.health) -- Output: 90

-- Base class
local Entity = {}
Entity.__index = Entity

function Entity.new(name)
    local self = setmetatable({}, Entity)
    self.name = name
    return self
end

-- Derived class
local Monster = setmetatable({}, {__index = Entity})
Monster.__index = Monster

function Monster.new(name, damage)
    local self = setmetatable(Entity.new(name), Monster)
    self.damage = damage
    return self
end

-- Using pcall for safe execution
local success, result = pcall(function()
    -- Potentially dangerous code
    error("Something went wrong!")
end)

if not success then
    print("Error caught: " .. result)
end

-- Creating and handling custom errors
function divide(a, b)
    if b == 0 then
        error("Division by zero!", 2)
    end
    return a / b
end

local success, result = pcall(divide, 10, 0)
if not success then
    print("Error in division: " .. result)
end

-- Using the debug library
local function trace()
    local level = 2
    local info = debug.getinfo(level, "Sl")
    while info do
        print(string.format("%s:%d", info.short_src, info.currentline))
        level = level + 1
        info = debug.getinfo(level, "Sl")
    end
end

function someFunction()
    trace() -- Print stack trace
end

-- config.lua
local Config = {
    VERSION = "1.0.0",
    MAX_PLAYERS = 10,
    DEBUG_MODE = true
}
return Config

-- player.lua
local Player = {}
local Config = require("config")

function Player.new(name)
    return {
        name = name,
        health = 100,
        maxPlayers = Config.MAX_PLAYERS
    }
end

return Player

-- Module/Class names (PascalCase)
local PlayerManager = {}
local GameState = {}

-- Variables and functions (camelCase)
local playerCount = 0
local function getCurrentPlayer()
    return activePlayer
end

-- Constants (UPPERCASE)
local MAX_HEALTH = 100
local DEFAULT_SPEED = 5

-- Clear, descriptive names
local isPlayerAlive = true
local function calculateDamage(baseDamage, armor)
    return baseDamage * (1 - armor)
end

--- Player class representing a game character
-- @class Player
-- @field name string The player's display name
-- @field health number Current health points
local Player = {}

--- Creates a new Player instance
-- @param name string The player's name
-- @param health number Initial health value
-- @return Player The new player instance
function Player.new(name, health)
    local self = setmetatable({}, Player)
    self.name = name
    self.health = health
    return self
end

--- Applies damage to the player
-- @param amount number The amount of damage to apply
-- @return number The remaining health
function Player:takeDamage(amount)
    self.health = math.max(0, self.health - amount)
    return self.health
end