level.lua

local ldtk = require 'lib.ldtk'

local World = require("core.World")

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

    LayerGround = nil,
}

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
        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.
    level.loaded = false
    level.entities = {}
    level.ui_elements = {}
    level.player = nil
    level.world = World:new(ldtkLevel)
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))

    level.loaded = true
end

function level:Draw()
    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
end

function level:Update(dt)
    if self.world == nil then
        return
    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)
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)
    Helpers.codeLeft = true
    ldtk:level(levelName)
end

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

return level