game_snake.lua

print("Snake Game")

local COLOR_WHITE = RGB(255, 255, 255)
local COLOR_BLACK = RGB(0, 0, 0)
local COLOR_GREEN = RGB(50, 200, 50)
local COLOR_DARK_GREEN = RGB(30, 150, 30)
local COLOR_RED = RGB(255, 50, 50)
local COLOR_BLUE = RGB(100, 150, 255)

local GRID_SIZE = 20
local MOVE_INTERVAL = 0.15

local screenWidth = 640
local screenHeight = 480
local gridWidth = 0
local gridHeight = 0

local gameState = "menu" -- "menu", "playing", "win", "lose"
local score = 0
local moveTimer = 0.0
local deltaTime = 0.0

local directionX = 1
local directionY = 0
local nextDirX = 1
local nextDirY = 0

--- @class SnakeSegment
--- @field x number
--- @field y number
--- @field hitRegion HitRegion

--- @type SnakeSegment[]
local snake = {}


--- @class Food
--- @field x number
--- @field y number
--- @field hitRegion HitRegion
local food = nil

local playButton = nil
local backgroundImage = nil


--- Creates a new snake segment
--- @param gridX number
--- @param gridY number
--- @return SnakeSegment
function CreateSegment(gridX, gridY)
    local segment = {}
    segment.x = gridX
    segment.y = gridY
    local px = gridX * GRID_SIZE
    local py = gridY * GRID_SIZE
    segment.hitRegion = HitRegion(Shape.Rectangle, px, py, px + GRID_SIZE, py + GRID_SIZE)
    return segment
end

--- Updates segment hit region position
--- @param segment SnakeSegment
function UpdateSegmentHitRegion(segment)
    local px = segment.x * GRID_SIZE
    local py = segment.y * GRID_SIZE
    segment.hitRegion = HitRegion(Shape.Rectangle, px, py, px + GRID_SIZE, py + GRID_SIZE)
end

--- Creates food at random position
function SpawnFood()
    local valid = false
    local fx, fy

    while not valid do
        fx = math.random(0, gridWidth - 1)
        fy = math.random(0, gridHeight - 1)
        valid = true

        for _, segment in ipairs(snake) do
            if segment.x == fx and segment.y == fy then
                valid = false
                break
            end
        end
    end

    food = {}
    food.x = fx
    food.y = fy
    local px = fx * GRID_SIZE
    local py = fy * GRID_SIZE
    food.hitRegion = HitRegion(Shape.Rectangle, px, py, px + GRID_SIZE, py + GRID_SIZE)
end

--- Initializes the snake
function InitSnake()
    snake = {}
    local startX = math.floor(gridWidth / 2)
    local startY = math.floor(gridHeight / 2)

    table.insert(snake, CreateSegment(startX, startY))
    table.insert(snake, CreateSegment(startX - 1, startY))
    table.insert(snake, CreateSegment(startX - 2, startY))

    directionX = 1
    directionY = 0
    nextDirX = 1
    nextDirY = 0
end

--- Checks if position collides with snake body
--- @param x number
--- @param y number
--- @param skipHead boolean
--- @return boolean
function CollidesWithSnake(x, y, skipHead)
    local startIdx = 1
    if skipHead then
        startIdx = 2
    end

    for i = startIdx, #snake do
        if snake[i].x == x and snake[i].y == y then
            return true
        end
    end
    return false
end

--- Called once when the game initializes
function Initialize()
    print("Initialize called")

    screenWidth = GAME_ENGINE:GetWidth()
    screenHeight = GAME_ENGINE:GetHeight()
    deltaTime = 1.0 / GAME_ENGINE:GetFrameRate()

    gridWidth = math.floor(screenWidth / GRID_SIZE)
    gridHeight = math.floor(screenHeight / GRID_SIZE)

    math.randomseed(os.time())

    backgroundImage = Bitmap("resources/background.png")
end

--- Called once after Initialize
function Start()
    print("Start called")
    InitSnake()
    SpawnFood()
    CreateUI()
end

--- Called every frame for game logic updates
function Tick()
    if gameState ~= "playing" then
        return
    end

    moveTimer = moveTimer + deltaTime

    if moveTimer >= MOVE_INTERVAL then
        moveTimer = 0.0

        directionX = nextDirX
        directionY = nextDirY

        local head = snake[1]
        local newX = head.x + directionX
        local newY = head.y + directionY

        if newX < 0 or newX >= gridWidth or newY < 0 or newY >= gridHeight then
            gameState = "lose"
            return
        end

        if CollidesWithSnake(newX, newY, true) then
            gameState = "lose"
            return
        end

        local newHead = CreateSegment(newX, newY)
        table.insert(snake, 1, newHead)

        if newHead.hitRegion:HitTest(food.hitRegion) then
            score = score + 10
            SpawnFood()
        else
            table.remove(snake)
        end
    end
end

--- Called every frame for rendering
function Paint()
    if backgroundImage then
        GAME_ENGINE:DrawBitmap(backgroundImage, 0, 0)
    end

    if gameState == "menu" then
        DrawMenuScreen()
    else
        for i, segment in ipairs(snake) do
            if i == 1 then
                GAME_ENGINE:SetColor(COLOR_DARK_GREEN)
            else
                GAME_ENGINE:SetColor(COLOR_GREEN)
            end
            local px = segment.x * GRID_SIZE
            local py = segment.y * GRID_SIZE
            GAME_ENGINE:FillRect(px + 1, py + 1, px + GRID_SIZE - 1, py + GRID_SIZE - 1)
        end

        if food then
            GAME_ENGINE:SetColor(COLOR_RED)
            local px = food.x * GRID_SIZE
            local py = food.y * GRID_SIZE
            GAME_ENGINE:FillOval(px + 2, py + 2, px + GRID_SIZE - 2, py + GRID_SIZE - 2)
        end

        DrawUI()

        if gameState == "lose" then
            DrawLoseScreen()
        end
    end
end

--- Called once when the game ends
function End()
    print("End called")
end

--- Called every frame to check keyboard input
function CheckKeyboard()
    if gameState == "playing" then
        if (GAME_ENGINE:IsKeyDown(LEFT) or GAME_ENGINE:IsKeyDown(A)) and directionX ~= 1 then
            nextDirX = -1
            nextDirY = 0
        end

        if (GAME_ENGINE:IsKeyDown(RIGHT) or GAME_ENGINE:IsKeyDown(D)) and directionX ~= -1 then
            nextDirX = 1
            nextDirY = 0
        end

        if (GAME_ENGINE:IsKeyDown(UP) or GAME_ENGINE:IsKeyDown(W)) and directionY ~= 1 then
            nextDirX = 0
            nextDirY = -1
        end

        if (GAME_ENGINE:IsKeyDown(DOWN) or GAME_ENGINE:IsKeyDown(S)) and directionY ~= -1 then
            nextDirX = 0
            nextDirY = 1
        end
    elseif gameState == "lose" then
        if GAME_ENGINE:IsKeyDown(R) then
            ResetGame()
        end
    end

    if GAME_ENGINE:IsKeyDown(ESCAPE) then
        GAME_ENGINE:Quit()
    end
end

--- Called when a mouse button is pressed or released
--- @param isLeft boolean
--- @param isDown boolean
--- @param x number
--- @param y number
function MouseButtonAction(isLeft, isDown, x, y)
end

--- Called when the mouse wheel is scrolled
--- @param x number
--- @param y number
--- @param distance number
function MouseWheelAction(x, y, distance)
end

--- Called when the mouse moves
--- @param x number
--- @param y number
function MouseMove(x, y)
end

--- Called when a key is pressed (character input)
--- @param key string
function KeyPressed(key)
end

--- Called when a UI control triggers an action
--- @param caller Caller
function CallAction(caller)
    if caller == playButton then
        StartGame()
    end
end


--- Creates UI elements
function CreateUI()
    playButton = Button.new("PLAY")
    playButton:SetBounds(math.floor((screenWidth - 150) / 2), math.floor(screenHeight / 2), math.floor((screenWidth + 150) / 2), math.floor(screenHeight / 2 + 50))
    playButton:Show()
end

--- Starts the game from menu
function StartGame()
    gameState = "playing"
    playButton:Hide()
end

--- Resets the game state
function ResetGame()
    score = 0
    moveTimer = 0.0
    gameState = "playing"

    InitSnake()
    SpawnFood()

    playButton:Hide()
end

--- Draws the UI elements
function DrawUI()
    GAME_ENGINE:SetColor(COLOR_WHITE)
    GAME_ENGINE:DrawString("Score: " .. score, 10, 10)
    GAME_ENGINE:DrawString("Arrow Keys or WASD    Esc to Quit", 10, screenHeight - 20)
end

--- Draws the menu screen
function DrawMenuScreen()
    GAME_ENGINE:SetColor(COLOR_WHITE)
    local centerX = math.floor(screenWidth / 2)
    local titleY = math.floor(screenHeight / 2 - 100)

    local title = "=== SNAKE ==="
    local titleWidth = #title * 8
    GAME_ENGINE:DrawString(title, centerX - math.floor(titleWidth / 2), titleY)

    local instruction = "Click PLAY to Start"
    local instructionWidth = #instruction * 7
    GAME_ENGINE:DrawString(instruction, centerX - math.floor(instructionWidth / 2), titleY + 40)
end

--- Draws the lose screen
function DrawLoseScreen()
    GAME_ENGINE:SetColor(COLOR_RED)
    local centerX = math.floor(screenWidth / 2)
    local centerY = math.floor(screenHeight / 2)
    GAME_ENGINE:DrawString("GAME OVER! Score: " .. score, centerX - 100, centerY)
    GAME_ENGINE:DrawString("Press R to Restart", centerX - 80, centerY + 30)
end