level.lua

local ldtk = require 'lib.ldtk'

local World = require("core.World")
local Camera = require("core.Camera")

---@class Level
---@field world World|nil
---@field entities table<Entity>
---@field ui_elements table<any>
---@field levelScript table
---@field camera Camera
---@field player Player
---@field LayerGround ldtk.Layer|nil
---@field LayerBackground ldtk.Layer|nil
local level = {
    world = nil,
    entities = {},
    ui_elements = {},

    levelScript = {
        onUpdate = nil,
        onLevelCreated = nil,
        onLevelDestroyed = nil,
    },

    camera = Camera:new(),

    LayerGround = nil,
    LayerBackground = nil,
}

local Parallax = require("core.Parallax")

local background = Parallax:new()

background:addLayer("assets/background/industrial/1.png", 0.05, 1.4)
background:addLayer("assets/background/industrial/2.png", 0.10, 1.4)
background:addLayer("assets/background/industrial/3.png", 0.20, 1.4)
background:addLayer("assets/background/industrial/4.png", 0.35, 1.4)
background:addLayer("assets/background/industrial/5.png", 0.50, 1.4)

function ldtk.onEntity(entity)
    local id = entity.id

    local entityClassName = "entities." .. id
    local status, entityClass = pcall(require, entityClassName)
    if status and entityClass then
        local e = entityClass:new(entity, entity.x, entity.y)
        if id == "Player" then
            level.player = e
            level.camera:follow(e)
        end
        table.insert(level.entities, e)
    else
        print("Unknown entity type: " .. id)
    end
end

function ldtk.onLayer(layer)
    -- A new layer is created.
    if layer.id == "Ground" then
        level.LayerGround = layer
        level.world:addGroundLayer(layer)
    elseif layer.id == "Background" then
        layer.color = { 0.6, 0.6, 0.6, 1 }
        level.LayerBackground = layer
    else
        print("Unknown layer type: " .. layer.id)
    end
end

function ldtk.onLevelLoaded(ldtkLevel)
    -- Current level is about to be changed.
    if level.levelScript and level.levelScript.onLevelDestroyed then
        level.levelScript:onLevelDestroyed(level)
    end
    level.levelScript = nil
    level.entities = {}
    level.ui_elements = {}
    level.player = nil
    level.world = World:new(ldtkLevel)
    level.camera:setBounds(0, 0, level.world.width, level.world.height)
end

function ldtk.onLevelCreated(ldtkLevel)
    -- Current level has been created and is ready to be used.
    print("Level created: " .. ldtkLevel.id)
    table.insert(level.ui_elements, require("ui.HUD"):new(level.player))

    local scriptName = ldtkLevel.id
    if scriptName then
        local status, levelScript = pcall(require, "levels." .. scriptName)
        if status then
            level.levelScript = levelScript
            level.levelScript.scriptName = scriptName
            if levelScript and levelScript.onLevelCreated then
                levelScript:onLevelCreated(level)
            end
        end
    end
end

function level:Draw()
    if self.camera then
        self.camera:apply()
    end

    background:draw(self.camera.x, self.camera.y)

    if self.LayerBackground then
        self.LayerBackground:draw()
    end
    if self.LayerGround then
        self.LayerGround:draw()
    end

    for _, e in ipairs(self.entities) do
        -- Draw non-player entities first
        if e ~= self.player and e.draw then
            e:draw()
        end
    end

    -- Draw player last so it appears on top
    if self.player and self.player.draw then
        self.player:draw()
    end

    Debug:draw(self.world.physics)

    for _, ui in ipairs(self.ui_elements) do
        if ui.draw then
            ui:draw()
        end
    end

    if self.camera then
        self.camera:clear()
    end
end

function level:Update(dt)
    if self.world == nil then
        return
    end

    if self.levelScript and self.levelScript.onUpdate then
        self.levelScript:onUpdate(self, dt)
    end

    for _, entity in ipairs(self.entities) do
        entity:update(dt)
    end

    for _, ui in ipairs(self.ui_elements) do
        if ui.update then
            ui:update(dt)
        end
    end

    self.world.physics:update(dt)

    Debug:update(dt)

    if self.camera then
        self.camera:update(dt)
    end
end

function level:keypressed(key)
    for _, entity in ipairs(self.entities) do
        if entity.keypressed then
            entity:keypressed(key)
        end
    end
end

function level:load(levelName)
    ldtk:level(levelName)
end

function level:reload()
    ldtk:reload()
end

ldtk:load('levels.ldtk')

return level