Trigger.lua.txt

local mod = {}

local HEX_SIDE = 50

-- Hex Implementation: https://stackoverflow.com/a/1838701
-- https://www.redblobgames.com/grids/hexagons/

local SKILL_TREE = {
    Robust = {
        {
            skillImage = "icon_catalyst_main_item3_blue_01",
            skillName = "Robust I",
            skillCost = 25,
            skillDescription = "Increase Dwarf Smith’s max health by 25",
            value = 25
        },
        {
            skillImage = "icon_catalyst_main_item3_blue_02",
            skillName = "Robust II",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s max health by 50",
            value = 50
        },
        {
            skillImage = "icon_catalyst_main_item3_blue_03",
            skillName = "Robust III",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s max health by 100",
            value = 100
        }
    },
    Invulnerability = {
        {
            skillImage = "icon_catalyst_main_item1_blue_01",
            skillName = "Invulnerability I",
            skillCost = 20,
            skillDescription = "Increase the amount of time Dwarf Smith does not take additional damage after being hit by 0.1",
            value = 0.1
        },
        {
            skillImage = "icon_catalyst_main_item1_blue_02",
            skillName = "Invulnerability II",
            skillCost = 40,
            skillDescription = "Increase the amount of time Dwarf Smith does not take additional damage after being hit by 0.2",
            value = 0.2
        },
        {
            skillImage = "icon_catalyst_main_item1_blue_03",
            skillName = "Invulnerability I",
            skillCost = 60,
            skillDescription = "Increase the amount of time Dwarf Smith does not take additional damage after being hit by 0.3",
            value = 0.3
        },
        {
            skillImage = "icon_catalyst_main_item1_blue_04",
            skillName = "Invulnerability IV",
            skillCost = 100,
            skillDescription = "Increase the amount of time Dwarf Smith does not take additional damage after being hit by 0.5",
            value = 0.5
        }
    },
    Surefooted = {
        {
            skillImage = "icon_catalyst_main_item4_blue_02",
            skillName = "Surefooted I",
            skillCost = 30,
            skillDescription = "Decrease the duration of any movement impairing effects by 10%",
            value = 0.10
        },
        {
            skillImage = "icon_catalyst_main_item4_blue_03",
            skillName = "Surefooted II",
            skillCost = 40,
            skillDescription = "Decrease the duration of any movement impairing effects by 20%",
            value = 0.20
        },
        {
            skillImage = "icon_catalyst_main_item4_blue_04",
            skillName = "Surefooted III",
            skillCost = 50,
            skillDescription = "Decrease the duration of any movement impairing effects by 30%",
            value = 0.30
        }
    },
    Arsenal = {
        skillImage = "icon_enhance_frosttower_shatter",
        skillName = "Arsenal",
        skillCost = 100,
        skillDescription = "Able to pick a Perk at the beginning of a run",
        value = 0
    },
    Preplan = {
        skillImage = "icon_enhance_iceman_yodel_taunt",
        skillName = "Preplan",
        skillCost = 50,
        skillDescription = "Level exit room will be revealed on your mini map",
        value = 0
    },
    QuickRecovery = {
        {
            skillImage = "icon_catalyst_main_item3_green_01",
            skillName = "Quick Recovery I",
            skillCost = 25,
            skillDescription = "Decrease Dwarf Smith’s stamina regeneration cooldown by 15%",
            value = 0.15
        },
        {
            skillImage = "icon_catalyst_main_item3_green_02",
            skillName = "Quick Recovery II",
            skillCost = 50,
            skillDescription = "Decrease Dwarf Smith’s stamina regeneration cooldown by 30%",
            value = 0.3
        },
        {
            skillImage = "icon_catalyst_main_item3_green_03",
            skillName = "Quick Recovery III",
            skillCost = 100,
            skillDescription = "Decrease Dwarf Smith’s stamina regeneration cooldown by 50%",
            value = 0.5
        }
    },
    Endurance = {
        {
            skillImage = "icon_catalyst_main_item1_green_02",
            skillName = "Endurance I",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s stamina by 1",
            value = 1
        },
        {
            skillImage = "icon_catalyst_main_item1_green_03",
            skillName = "Endurance II",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s stamina by 2",
            value = 2
        },
        {
            skillImage = "icon_catalyst_main_item1_green_04",
            skillName = "Endurance III",
            skillCost = 150,
            skillDescription = "Increase Dwarf Smith’s stamina by 3",
            value = 3
        }
    },
    BunnyHop = {
        skillImage = "icon_enhance_druidtower_wilds_shape",
        skillName = "Bunny Hop",
        skillCost = 50,
        skillDescription = "Increase Dwarf Smith’s jump distance by 30%",
        value = 0.3
    },
    ImprovedSlam = {
        {
            skillImage = "icon_catalyst_main_item4_green_02",
            skillName = "Improved Slam I",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s heavy attack impact radius by 10%",
            value = "_PlayerCharacter_Melee_HeavyAttack_ImprovedSlam_I"
        },
        {
            skillImage = "icon_catalyst_main_item4_green_03",
            skillName = "Improved Slam II",
            skillCost = 75,
            skillDescription = "Increase Dwarf Smith’s heavy attack impact radius by 20%",
            value = "_PlayerCharacter_Melee_HeavyAttack_ImprovedSlam_II"
        },
        {
            skillImage = "icon_catalyst_main_item4_green_04",
            skillName = "Improved Slam III",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s heavy attack impact radius by 30%",
            value = "_PlayerCharacter_Melee_HeavyAttack_ImprovedSlam_III"
        }
    },
    ExtraSpace = {
        skillImage = "icon_ingame_towerslot_druidtower",
        skillName = "Extra Space",
        skillCost = 100,
        skillDescription = "Increase Inventory Slot by 1",
        value = 1
    },
    WarMachine = {
        {
            skillImage = "icon_catalyst_main_item3_orange_01",
            skillName = "War Machine I",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s light attack damage by 2",
            value = "_PlayerCharacter_WarMachine_I"
        },
        {
            skillImage = "icon_catalyst_main_item3_orange_02",
            skillName = "War Machine II",
            skillCost = 75,
            skillDescription = "Increase Dwarf Smith’s light attack damage by 5",
            value = "_PlayerCharacter_WarMachine_II"
        },
        {
            skillImage = "icon_catalyst_main_item3_orange_03",
            skillName = "War Machine III",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s light attack damage by 10",
            value =  "_PlayerCharacter_WarMachine_III"
        }
    },
    Strength = {
        {
            skillImage = "icon_catalyst_main_item1_orange_02",
            skillName = "Strength I",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s heavy attack damage by 1",
            value = "_PlayerCharacter_Strength_I"
        },
        {
            skillImage = "icon_catalyst_main_item1_orange_03",
            skillName = "Strength II",
            skillCost = 75,
            skillDescription = "Increase Dwarf Smith’s heavy attack damage by 2",
            value = "_PlayerCharacter_Strength_II"
        },
        {
            skillImage = "icon_catalyst_main_item1_orange_04",
            skillName = "Strength III",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s heavy attack damage by 3",
            value = "_PlayerCharacter_Strength_III"
        }
    },
    Cruelty = {
        skillImage = "icon_enhance_dragoonbarracks_crush",
        skillName = "Cruelty",
        skillCost = 50,
        skillDescription = "Dwarf Smith will have 10% chance to critically strike enemies, using light attack",
        value = 0.1
    },
    LuckyStrike = {
        {
            skillImage = "icon_catalyst_main_item4_orange_02",
            skillName = "Lucky Strike I",
            skillCost = 50,
            skillDescription = "Increase Dwarf Smith’s critical strike chance by 2%",
            value = 0.02
        },
        {
            skillImage = "icon_catalyst_main_item4_orange_03",
            skillName = "Lucky Strike II",
            skillCost = 75,
            skillDescription = "Increase Dwarf Smith’s critical strike chance by 4%",
            value = 0.04
        },
        {
            skillImage = "icon_catalyst_main_item4_orange_04",
            skillName = "Lucky Strike III",
            skillCost = 100,
            skillDescription = "Increase Dwarf Smith’s critical strike chance by 6%",
            value = 0.06
        }
    },
    ConcussionBlow = {
        skillImage = "icon_enhance_crusader_zeal",
        skillName = "Concussion Blow",
        skillCost = 20,
        skillDescription = "Dwarf Smith’s light attack will now stun normal enemies for 0.1 second",
        value = 0.1
    },
    HeavyBlow = {
        skillImage = "icon_enhance_cannontower_concussiveblast",
        skillName = "Heavy Blow",
        skillCost = 100,
        skillDescription = "Dwarf Smith’s heavy attack now can stun BOSS enemy",
        value = 3
    },
    Hero = {
        skillImage = "icon_ingame_hero_tower_smith",
        skillName = "Hero",
        skillCost = 0,
        skillDescription = "Dwarf Smith Hero",
        value = 0
    }
}

local SKILL_TREE_MATRIX = {
    { "HeavyBlow", 0, 0, 0, 0, 0, 0 },
    { 0, "Strength", "LuckyStrike", 0, 0, 0, 0 },
    { 0, "WarMachine", "Cruelty", 0, "Endurance", 0, 0 },
    { 0, 0, 0, "Hero", "QuickRecovery", "ImprovedSlam", "ExtraSpace" },
    { 0, 0, "Invulnerability", "Robust", 0, "BunnyHop", 0 },
    { 0, 0, 0, "Preplan", "Surefooted", 0, 0 },
    { 0, 0, 0, "Arsenal", 0, 0, 0 }
}

local CENTER_SKILL = "Hero"
local NIL_SKILL = 0

local SKILL_NAMES = {
    Robust = "Robust",
    Invulnerability = "Invulnerability",
    Surefooted = "Surefooted",
    Arsenal = "Arsenal",
    Preplan = "Preplan",
    QuickRecovery = "QuickRecovery",
    Endurance = "Endurance",
    BunnyHop = "BunnyHop",
    ImprovedSlam = "ImprovedSlam",
    ExtraSpace = "ExtraSpace",
    WarMachine = "WarMachine",
    Strength = "Strength",
    Cruelty = "Cruelty",
    LuckyStrike = "LuckyStrike",
    ConcussionBlow = "ConcussionBlow",
    HeavyBlow = "HeavyBlow"
}

local MERCHANT_MALE = "__SpawnMerchantMaleUnit"
local MERCHANT_FEMALE = "__SpawnMerchantFemaleUnit"

-- #region Hex Generator

local HexGenerator = {
    hexUiMatrix = {},
    hexUiDisplay = {},
    skillStatusMatrix = {},

    skillCallbacks = {},
}
HexGenerator.__index = HexGenerator
function HexGenerator:new(uiLayer, callback)
    local hexGenerator = {}
    setmetatable(hexGenerator, HexGenerator)

    hexGenerator.hexUiMatrix = {}
    hexGenerator.hexUiDisplay = {}
    hexGenerator.skillStatusMatrix = {}
    hexGenerator.skillCallbacks = {}

    hexGenerator:GenerateHexMapPositions(SKILL_TREE_MATRIX)
    hexGenerator:DrawUI(uiLayer, SKILL_TREE_MATRIX, callback)
    hexGenerator:Load()
    hexGenerator:UpdateSkillDisplay()

    return hexGenerator
end
function HexGenerator:Save()
    local stringValue = mod.ConvertSkillStatusToString(self.skillStatusMatrix)
    mod.SaveSkillTree(stringValue)
end
function HexGenerator:Load()
    local stringValue = mod.GetSkillTree()

    if stringValue == nil then
        self:CreateInitialSkillMatrix(SKILL_TREE_MATRIX)

    else
        local skillStatusMatrix = mod.ConvertStringToSkillStatus(stringValue)
        self.skillStatusMatrix = skillStatusMatrix
    end
end
function HexGenerator:Clear()
    mod.ClearSkillTree()
end
function HexGenerator:AddCallback(callback)
    table.insert(self.skillCallbacks, callback)
end
function HexGenerator:GenerateHexMapPositions(hexMatrix)
    local currentX = 0
    local currentY = 0

    self.hexUiMatrix[1] = {}
    self.hexUiMatrix[1][1] = { x = currentX, y = currentY }

    for i = 1, #hexMatrix do
        if self.hexUiMatrix[i] == nil then
            self.hexUiMatrix[i] = {}
        end

        for j = 1, #hexMatrix[i] do

            local lSide = { x = j - 1, y = i }
            local tSide = { x = j, y = i - 1 }
            local ltSide = { x = j - 1, y = i - 1 }

            local rSide = { x = j + 1, y = i }
            local bSide = { x = j, y = i + 1 }
            local rbSide = { x = j + 1, y = i + 1 }

            if self.hexUiMatrix[i][j] ~= nil then
                local tempData = self.hexUiMatrix[i][j]
                currentX = tempData.x
                currentY = tempData.y
            end

            if mod.IsSideValid(lSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = -mod.GetHexHorizontalSpacing(HEX_SIDE) + currentX
                local yPosition = mod.GetHexHalfVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[lSide.y][lSide.x] == nil then
                    self.hexUiMatrix[lSide.y][lSide.x] = { x = xPosition, y = yPosition }
                end
            end

            if mod.IsSideValid(tSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = mod.GetHexHorizontalSpacing(HEX_SIDE) + currentX
                local yPosition = mod.GetHexHalfVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[tSide.y] == nil then
                    self.hexUiMatrix[tSide.y] = {}
                end

                if self.hexUiMatrix[tSide.y][tSide.x] == nil then
                    self.hexUiMatrix[tSide.y][tSide.x] = { x = xPosition, y = yPosition }
                end
            end

            if mod.IsSideValid(ltSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = currentX
                local yPosition = mod.GetHexVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[ltSide.y] == nil then
                    self.hexUiMatrix[ltSide.y] = {}
                end

                if self.hexUiMatrix[ltSide.y][ltSide.x] == nil then
                    self.hexUiMatrix[ltSide.y][ltSide.x] = { x = xPosition, y = yPosition }
                end
            end

            if mod.IsSideValid(rSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = mod.GetHexHorizontalSpacing(HEX_SIDE) + currentX
                local yPosition = -mod.GetHexHalfVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[rSide.y][rSide.x] == nil then
                    self.hexUiMatrix[rSide.y][rSide.x] = { x = xPosition, y = yPosition }
                end
            end

            if mod.IsSideValid(bSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = -mod.GetHexHorizontalSpacing(HEX_SIDE) + currentX
                local yPosition = -mod.GetHexHalfVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[bSide.y] == nil then
                    self.hexUiMatrix[bSide.y] = {}
                end

                if self.hexUiMatrix[bSide.y][bSide.x] == nil then
                    self.hexUiMatrix[bSide.y][bSide.x] = { x = xPosition, y = yPosition }
                end
            end

            if mod.IsSideValid(rbSide, #hexMatrix[i], #hexMatrix) then
                local xPosition = currentX
                local yPosition = -mod.GetHexVerticalSpacing(HEX_SIDE) + currentY

                if self.hexUiMatrix[rbSide.y] == nil then
                    self.hexUiMatrix[rbSide.y] = {}
                end

                if self.hexUiMatrix[rbSide.y][rbSide.x] == nil then
                    self.hexUiMatrix[rbSide.y][rbSide.x] = { x = xPosition, y = yPosition }
                end
            end
        end
    end
end
function HexGenerator:DrawUI(uiLayer, hexMatrix, callback)
    local baseFrame = DCEI.NewFrame(uiLayer)
    DCEI.SetMinSize(baseFrame, HEX_SIDE * 11, HEX_SIDE * 10)
    DCEI.SetLeftAlignmentInParent(baseFrame)

    for i = 1, #self.hexUiMatrix do
        if self.hexUiDisplay[i] == nil then
            self.hexUiDisplay[i] = {}
        end

        for j = 1, #self.hexUiMatrix[i] do
            local xPosition = self.hexUiMatrix[i][j].x
            local yPosition = self.hexUiMatrix[i][j].y

            local tileFrame = DCEI.NewButton(baseFrame)
            DCEI.SetBackgroundImage(tileFrame, "Hexagon")
            DCEI.SetMinSize(tileFrame, HEX_SIDE * 2, HEX_SIDE * 2)
            DCEI.SetMaxSize(tileFrame, HEX_SIDE * 2, HEX_SIDE * 2)

            DCEI.SetHorizontalOffsetInParent(tileFrame, xPosition)
            DCEI.SetVerticalOffsetInParent(tileFrame, yPosition)
            DCEI.SetTopAlignmentInParent(tileFrame)

            local imageFrame

            if hexMatrix[i][j] ~= 0 then
                imageFrame = DCEI.NewFrame(tileFrame)
                DCEI.SetMinSize(imageFrame, HEX_SIDE, HEX_SIDE)
                DCEI.SetBackgroundImage(imageFrame, "frame_shape00")

            else
                DCEI.SetActive(tileFrame, false)
            end

            DCEI.SetOnClickCallback(
                tileFrame,
                function()
                    callback(hexMatrix[i][j])
                end
            )

            self.hexUiDisplay[i][j] = {
                button = tileFrame,
                image = imageFrame   
            }
        end
    end
end
function HexGenerator:CreateInitialSkillMatrix(hexMatrix)
    for i = 1, #hexMatrix do
        if self.skillStatusMatrix[i] == nil then
            self.skillStatusMatrix[i] = {}
        end

        for j = 1, #hexMatrix[i] do

            local skillData = {
                skillName = hexMatrix[i][j]
            }

            DCEI.LogMessage("Skill Name: " .. skillData.skillName)

            if hexMatrix[i][j] == CENTER_SKILL then
                skillData.skillLevel = 1
                skillData.maxSkillLevel = 1
                skillData.isUnlocked = true
                skillData.isDisplayed = true

            elseif hexMatrix[i][j] == NIL_SKILL then
                skillData.skillLevel = 1
                skillData.maxSkillLevel = 1
                skillData.isUnlocked = false
                skillData.isDisplayed = false

            else
                if SKILL_TREE[hexMatrix[i][j]][1] ~= nil then
                    skillData.skillLevel = 1
                    skillData.maxSkillLevel = #SKILL_TREE[hexMatrix[i][j]]
                else
                    skillData.skillLevel = 1
                    skillData.maxSkillLevel = 1
                end
                skillData.isUnlocked = false
                skillData.isDisplayed = false
            end

            self.skillStatusMatrix[i][j] = skillData
        end
    end

    self:UnlockSkill(SKILL_TREE_MATRIX, CENTER_SKILL)    
end
function HexGenerator:UnlockSkill(hexMatrix, skillName)
    for i = 1, #self.skillStatusMatrix do
        for j = 1, #self.skillStatusMatrix[i] do

            if self.skillStatusMatrix[i][j].skillName == skillName then
                self.skillStatusMatrix[i][j].isUnlocked = true

                local lSide = { x = j - 1, y = i }
                local tSide = { x = j, y = i - 1 }
                local ltSide = { x = j - 1, y = i - 1 }

                local rSide = { x = j + 1, y = i }
                local bSide = { x = j, y = i + 1 }
                local rbSide = { x = j + 1, y = i + 1 }

                if mod.IsSideValid(lSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[lSide.y][lSide.x].isDisplayed = true
                end
    
                if mod.IsSideValid(tSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[tSide.y][tSide.x].isDisplayed = true
                end
    
                if mod.IsSideValid(ltSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[ltSide.y][ltSide.x].isDisplayed = true
                end
    
                if mod.IsSideValid(rSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[rSide.y][rSide.x].isDisplayed = true
                end
    
                if mod.IsSideValid(bSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[bSide.y][bSide.x].isDisplayed = true
                end
    
                if mod.IsSideValid(rbSide, #hexMatrix[i], #hexMatrix) then
                    self.skillStatusMatrix[rbSide.y][rbSide.x].isDisplayed = true
                end

            end
        end
    end

    for _, callback in ipairs(self.skillCallbacks) do
        callback(skillName)
    end
end
function HexGenerator:UpgradeSkill(skillName)
    for i = 1, #self.skillStatusMatrix do
        for j = 1, #self.skillStatusMatrix[i] do
            if self.skillStatusMatrix[i][j].skillName == skillName then

                local skill = self.skillStatusMatrix[i][j]
                if skill.skillLevel < skill.maxSkillLevel then
                    skill.skillLevel = skill.skillLevel + 1
                    self.skillStatusMatrix[i][j].skillLevel = skill.skillLevel
                end

            end
        end
    end

    for _, callback in ipairs(self.skillCallbacks) do
        callback(skillName)
    end
end
function HexGenerator:UpdateSkillDisplay()
    for i = 1, #self.skillStatusMatrix do
        for j = 1, #self.skillStatusMatrix[i] do
            if not self.skillStatusMatrix[i][j].isDisplayed then
                DCEI.SetActive(self.hexUiDisplay[i][j].button, false)

            elseif self.skillStatusMatrix[i][j].skillName == 0 then
                DCEI.SetActive(self.hexUiDisplay[i][j].button, false)

            else
                DCEI.SetActive(self.hexUiDisplay[i][j].button, true)

                local skillStatus = self.skillStatusMatrix[i][j]
                DCEI.LogMessage("Skill Name: " .. skillStatus.skillName)
                
                if skillStatus.maxSkillLevel ~= 1 then
                    DCEI.SetBackgroundImage(
                        self.hexUiDisplay[i][j].image,
                        SKILL_TREE[skillStatus.skillName][skillStatus.skillLevel].skillImage
                    )

                else
                    DCEI.SetBackgroundImage(
                        self.hexUiDisplay[i][j].image,
                        SKILL_TREE[skillStatus.skillName].skillImage
                    )
                end
            end
        end
    end
end
function HexGenerator:GetSkillStatus(skillName)
    for i = 1, #self.skillStatusMatrix do
        for j = 1, #self.skillStatusMatrix[i] do
            
            if self.skillStatusMatrix[i][j].skillName == skillName then
                return self.skillStatusMatrix[i][j]
            end
        end
    end

    DCEI.LogError("No such skill found!!!")
    return nil
end

-- #endregion Hex Generator

-- #region Skill Display

local SkillDisplay = {
    leftSideStack = nil,
    rightSideStack = nil,

    skillName = nil,
    skillImage = nil,
    skillDescription = nil,
    skillNextDescription = nil,
    skillCost = nil,

    unlockButton = nil,
    unlockText = nil,
    cancelButton = nil,
    
    skillTreeFrame = nil,

    hexGenerator = nil,
    player = nil,

    selectedSkill = nil,
}
SkillDisplay.__index = SkillDisplay
function SkillDisplay:new(uiLayer)
    local skillDisplay = {}
    setmetatable(skillDisplay, SkillDisplay)

    skillDisplay.leftSideStack = nil
    skillDisplay.rightSideStack = nil

    skillDisplay.skillName = nil
    skillDisplay.skillImage = nil
    skillDisplay.skillDescription = nil
    skillDisplay.skillNextDescription = nil
    skillDisplay.skillCost = nil

    skillDisplay.unlockButton = nil
    skillDisplay.unlockText = nil
    skillDisplay.cancelButton = nil

    skillDisplay.skillTreeFrame = nil

    skillDisplay.hexGenerator = nil
    skillDisplay.player = nil

    skillDisplay.selectedSkill = nil

    skillDisplay:CreateSkillTree(uiLayer)
    skillDisplay:Hide()

    return skillDisplay
end
function SkillDisplay:CreateSkillTree(uiLayer)
    local skillTreeFrame = DCEI.NewFrame(uiLayer)
    DCEI.SetBackgroundImage(skillTreeFrame, "frame_slot00")
    DCEI.SetMatchParent(skillTreeFrame, true, true)

    self.skillTreeFrame = skillTreeFrame

    -- #region Left Side

    local leftSideStack = DCEI.NewVStack(skillTreeFrame)
    DCEI.SetLeftAlignmentInParent(leftSideStack)
    DCEI.SetTopAlignmentInParent(leftSideStack)
    DCEI.SetHorizontalOffsetInParent(leftSideStack, 50)
    DCEI.SetVerticalOffsetInParent(leftSideStack, -50)
    DCEI.SetSpacing(leftSideStack, 21)

    -- Skill Header
    local skillHeader = DCEI.NewFrame(leftSideStack)
    DCEI.SetMinSize(skillHeader, 200, 50)
    DCEI.SetBackgroundImage(skillHeader, "frame_shape00")
    DCEI.SetBackgroundImageColor(skillHeader, 0.67, 0.67, 0.67, 1)
    
    local headerText = DCEI.NewText(skillHeader)
    DCEI.SetText(headerText, "SKILL TREE")

    DCEI.SetLeftAlignmentInParent(skillHeader)
    DCEI.SetTopAlignmentInParent(skillHeader)

    DCEI.SetHorizontalOffsetInParent(skillHeader, 50)
    DCEI.SetVerticalOffsetInParent(skillHeader, -100)

    -- Skill Tree
    local hexGenerator = HexGenerator:new(
        leftSideStack,
        function(skillName)
            self:SkillCallback(skillName)
        end
    )

    self.leftSideStack = leftSideStack
    self.hexGenerator = hexGenerator

    -- #endregion Left Side

    -- #region Right Side

    local rightSideStack = DCEI.NewVStack(skillTreeFrame)
    DCEI.SetRightAlignmentInParent(rightSideStack)
    DCEI.SetTopAlignmentInParent(rightSideStack)
    DCEI.SetHorizontalOffsetInParent(rightSideStack, -50)
    DCEI.SetVerticalOffsetInParent(rightSideStack, -50)
    DCEI.SetSpacing(rightSideStack, 21)

    -- Skill Display
    local skillDisplayFrame = DCEI.NewFrame(rightSideStack)
    DCEI.SetMinSize(skillDisplayFrame, 500, 400)
    DCEI.SetMaxSize(skillDisplayFrame, 500, 400)
    DCEI.SetBackgroundImage(skillDisplayFrame, "frame_shape00")
    DCEI.SetBackgroundImageColor(skillDisplayFrame, 0.67, 0.67, 0.67, 1)
    DCEI.SetPadding(skillDisplayFrame, 14)

    local skillDisplayStack = DCEI.NewVStack(skillDisplayFrame)
    DCEI.SetSpacing(skillDisplayStack, 50)
    DCEI.SetTopAlignmentInParent(skillDisplayStack)

    -- Display Header
    local headHStack = DCEI.NewHStack(skillDisplayStack)
    DCEI.SetSpacing(headHStack, 21)

    local skillName = DCEI.NewText(headHStack)
    DCEI.SetText(skillName, "War Machine I")
    
    local skillImage = DCEI.NewFrame(headHStack)
    DCEI.SetBackgroundImage(skillImage, "icon_enhance_druidtower_lightning_lure")
    DCEI.SetMinSize(skillImage, 50, 50)

    -- Display Description
    local skillDescription = DCEI.NewText(skillDisplayStack)
    DCEI.SetText(skillDescription, "Some description for skills")
    DCEI.SetMaxSize(skillDescription, 350, 200)

    local skillNextDescription = DCEI.NewText(skillDisplayStack)
    DCEI.SetText(skillNextDescription, "Some upgrade description")
    DCEI.SetMaxSize(skillNextDescription, 350, 200)
    
    -- Unlock Button
    
    local unlockButton = DCEI.NewButton(rightSideStack)
    DCEI.SetBackgroundImage(unlockButton, "frame_shape00")
    DCEI.SetMinSize(unlockButton, 200, 50)

    local buttonFrame = DCEI.NewHStack(unlockButton)
    DCEI.SetSpacing(buttonFrame, 14)

    local unlockText = DCEI.NewText(buttonFrame)
    DCEI.SetText(unlockText, "UNLOCK")

    local costImage = DCEI.NewFrame(buttonFrame)
    DCEI.SetBackgroundImage(costImage, "ui_ingame_coin")
    DCEI.SetMinSize(costImage, 30, 30)

    local costText = DCEI.NewText(buttonFrame)
    DCEI.SetText(costText, "20")

    -- Cancel Button
    local cancelButton = DCEI.NewButton(rightSideStack)
    DCEI.SetBackgroundImage(cancelButton, "frame_shape00")
    DCEI.SetMinSize(cancelButton, 150, 50)

    local cancelText = DCEI.NewText(cancelButton)
    DCEI.SetText(cancelText, "CANCEL")

    self.rightSideStack = rightSideStack
    self.skillName = skillName
    self.skillImage = skillImage

    self.skillDescription = skillDescription
    self.skillNextDescription = skillNextDescription
    self.skillCost = costText
    
    self.unlockButton = unlockButton
    self.unlockText = unlockText
    self.cancelButton = cancelButton

    DCEI.SetActive(rightSideStack, false)

    DCEI.SetOnClickCallback(
        cancelButton,
        function()
            self:Hide()
        end
    )

    DCEI.SetOnClickCallback(
        unlockButton,
        function()
            self:HandleUnlockButtonClicked(self.selectedSkill)
        end
    )

    -- #endregion Right Side
end
function SkillDisplay:SkillCallback(skillName)
    DCEI.SetActive(self.rightSideStack, true)

    local skill = SKILL_TREE[skillName]
    local skillStatus = self.hexGenerator:GetSkillStatus(skillName)

    if skill[1] ~= nil then
        local skillLevel = skillStatus.skillLevel
        local maxSkillLevel = skillStatus.maxSkillLevel
        
        DCEI.SetText(self.skillName, skill[skillLevel].skillName)
        DCEI.SetText(self.skillDescription, skill[skillLevel].skillDescription)
        DCEI.SetBackgroundImage(self.skillImage, skill[skillLevel].skillImage)

        if not skillStatus.isUnlocked then
            DCEI.SetText(self.skillCost, skill[skillLevel].skillCost)
            DCEI.SetText(self.unlockText, "UNLOCK")

            DCEI.SetActive(self.skillNextDescription, false)
            DCEI.SetActive(self.unlockButton, true)

        else
            if skillLevel < maxSkillLevel then
                DCEI.SetText(self.skillCost, skill[skillLevel + 1].skillCost)
                DCEI.SetText(self.skillNextDescription, "Next Level\n" .. skill[skillLevel + 1].skillDescription)
                DCEI.SetText(self.unlockText, "UPGRADE")
                
                DCEI.SetActive(self.skillNextDescription, true)
                DCEI.SetActive(self.unlockButton, true)

            else
                DCEI.SetActive(self.skillNextDescription, false)
                DCEI.SetActive(self.unlockButton, false)
            end
        end

    else
        DCEI.SetText(self.skillName, skill.skillName)
        DCEI.SetText(self.skillDescription, skill.skillDescription)
        DCEI.SetBackgroundImage(self.skillImage, skill.skillImage)

        if not skillStatus.isUnlocked then
            DCEI.SetText(self.skillCost, skill.skillCost)
            DCEI.SetText(self.unlockText, "UNLOCK")

            DCEI.SetActive(self.skillNextDescription, false)
            DCEI.SetActive(self.unlockButton, true)

        else
            DCEI.SetActive(self.skillNextDescription, false)
            DCEI.SetActive(self.unlockButton, false)
        end
    end

    self.selectedSkill = skillName
end
function SkillDisplay:ShowSkillTree(player)
    DCEI.SetActive(self.leftSideStack, true)
    DCEI.SetActive(self.skillTreeFrame, true)

    self.player = player
    self.player:HidePlayerUI()

    DCEI.HideJoystick(0)
    DCEI.HideJoystick(0)
    for i = 0, 2 do
        DCEI.HideJoystickButton(i)
    end
end
function SkillDisplay:Hide()
    DCEI.SetActive(self.leftSideStack, false)
    DCEI.SetActive(self.rightSideStack, false)
    DCEI.SetActive(self.skillTreeFrame, false)

    self.selectedSkill = nil
    
    if self.player ~= nil then
        self.player:ShowPlayerUI()
    end
    
    DCEI.ShowJoystick(0)
    for i = 0, 2 do
        DCEI.ShowJoystickButton(i)
    end
end
function SkillDisplay:HandleUnlockButtonClicked(skillName)
    local goldAmount = self.player:GetPlayerGold()
    local skillStatus = self.hexGenerator:GetSkillStatus(skillName)

    if skillStatus.isUnlocked then
        local nextLevelGoldAmount = SKILL_TREE[skillName][skillStatus.skillLevel + 1].skillCost
        if goldAmount >= nextLevelGoldAmount then
            self.hexGenerator:UpgradeSkill(skillName)
            self.player:UseGold(nextLevelGoldAmount)

        else
            DCEI.LogMessage("Not Enough Gold for Upgrading")
        end

    else
        local skillCost

        if skillStatus.maxSkillLevel == 1 then
            skillCost = SKILL_TREE[skillName].skillCost
        else
            skillCost = SKILL_TREE[skillName][1].skillCost
        end

        if goldAmount >= skillCost then
            self.hexGenerator:UnlockSkill(SKILL_TREE_MATRIX, skillName)
            self.player:UseGold(skillCost)

        else
            DCEI.LogMessage("Not Enough Gold for Unlocking")
        end
    end

    self:SkillCallback(skillName) -- Update the UI
    self.hexGenerator:UpdateSkillDisplay()
end
function SkillDisplay:SaveSkillTree()
    self.hexGenerator:Save()
end
function SkillDisplay:ClearSkillTree()
    self.hexGenerator:Clear()
end

-- #endregion Skill Display

function mod.GetSkillValue(skillName, skillLevel)
    local skill = SKILL_TREE[skillName]
    
    if skill == nil then
        DCEI.LogError("Invalid Skill Requested")
        return nil
    end

    if skill[1] == nil then
        return skill.value

    else
        return skill[skillLevel].value
    end
end

function mod.ConvertSkillStatusToString(skillStatusMatrix)
    local stringValue = ""

    for i = 1, #skillStatusMatrix do
        for j = 1, #skillStatusMatrix[i] do

        local skillStatus = skillStatusMatrix[i][j]
        
        stringValue = stringValue .. i .. "," .. j .. ","
        stringValue = stringValue .. skillStatus.skillName .. ","
        stringValue = stringValue .. skillStatus.skillLevel .. "," .. skillStatus.maxSkillLevel .. ","
        stringValue = stringValue .. tostring(skillStatus.isUnlocked) .. "," .. tostring(skillStatus.isDisplayed) .. ":"

        end

        stringValue = stringValue .. "|"
    end

    return stringValue
end

function mod.ConvertStringToSkillStatus(stringValue)
    local matrix = {}
    local rows = mod.split(stringValue, "|")

    for _, value in pairs(rows) do
        local columns = mod.split(value, ":")

        for _, colValue in pairs(columns) do
            local data = mod.split(colValue, ",")

            local i = tonumber(data[1])
            local j = tonumber(data[2])

            if matrix[i] == nil then
                matrix[i] = {}
            end

            local skillName = data[3]
            if skillName == "0" then
                skillName = 0
            end

            local skillLevel = tonumber(data[4])
            local maxSkillLevel = tonumber(data[5])
            
            local isUnlocked = mod.ToBoolean(data[6])
            local isDisplayed = mod.ToBoolean(data[7])

            local skillStatus = {
                skillName = skillName,
                skillLevel = skillLevel,
                maxSkillLevel = maxSkillLevel,
                isUnlocked = isUnlocked,
                isDisplayed = isDisplayed
            }

            matrix[i][j] = skillStatus
        end
    end

    return matrix
end

function mod.IsSideValid(side, width, height)
    if side.x < 1 or side.x > width then
        return false
    end

    if side.y < 1 or side.y > height then
        return false
    end

    return true
end

function mod.GetHexHorizontalSpacing(side)
    return 2 * side * 3 / 4
end

function mod.GetHexVerticalSpacing(side)
    return math.sqrt(3) * side
end

function mod.GetHexHalfVerticalSpacing(side)
    return mod.GetHexVerticalSpacing(side) / 2
end

mod.SkillDisplay = SkillDisplay
mod.SkillNames = SKILL_NAMES
mod.MerchantMale = MERCHANT_MALE
mod.MerchantFemale = MERCHANT_FEMALE

mod.IsEqual = nil
mod.split = nil
mod.ToBoolean = nil

mod.SaveSkillTree = nil
mod.GetSkillTree = nil
mod.ClearSkillTree = nil

return mod