BattleUi.ttslua

local Check = require("Kdm/Util/Check")
local EventManager = require("Kdm/Util/EventManager")
local Location = require("Kdm/Location")
local log = require("Kdm/Log").ForModule("BattleUi")
local Monster = require("Kdm/Monster")
local NamedObject = require("Kdm/NamedObject")
local Player = require("Kdm/Player")
local Survivor = require("Kdm/Survivor")
local Ui = require("Kdm/Ui")
local Util = require("Kdm/Util/Util")

---------------------------------------------------------------------------------------------------

local BattleUi = {}

BattleUi.MAX_WEAPONS = 3
BattleUi.PLAYER_SPACING = 0
BattleUi.TEXT_COLOR = "#ffffffdc"
BattleUi.DISABLED_TEXT_COLOR = "#ffffff60"
BattleUi.DARK_COLORS = "#00000000|#ffffff10|#ffffff20|#ffffffff"
BattleUi.DARK_SELECTED_COLORS = "#ffffff20|#ffffff30|#ffffff40|#ffffffff"

---------------------------------------------------------------------------------------------------

function BattleUi.Init(saveState)
    BattleUi.hiddenWeaponsBySurvivor = {}

    for survivorId, hiddenWeapons in pairs(saveState or {}) do
        local survivor = Survivor.SurvivorForId(survivorId)
        if survivor == nil then
            log:Debugf("No survivor with ID %d doesn't exist", survivorId)
        else
            BattleUi.hiddenWeaponsBySurvivor[survivor] = hiddenWeapons
        end
    end

    BattleUi.InitUi(ui)
end

function BattleUi.InitUi(ui)
    local ui = Ui.Get2d()
    BattleUi.ui = ui

    ui:Image({ id = "BattleUi", rectAlignment = "MiddleLeft", x = 10, y = -20, width = 50, height = 50, image = "BattleUi" })
    ui:Button({ id = "BattleUi", rectAlignment = "MiddleLeft", x = 10-1, y = -20+1, width = 50+2, height = 50+2, colors = BattleUi.DARK_COLORS, onClick = function()
        if BattleUi.uiOpen then
            BattleUi.Hide()
        else
            BattleUi.Show()
        end
    end })

    ui:Image({ id = "NextTurn", rectAlignment = "MiddleLeft", x = 10, y = -80, width = 50, height = 50, image = "NextTurn" })
    ui:Button({ id = "NextTurn", rectAlignment = "MiddleLeft", x = 10-1, y = -80+1, width = 50+2, height = 50+2, colors = BattleUi.DARK_COLORS, onClick = BattleUi.NextTurn })

    BattleUi.uiOpen = false
    BattleUi.panel = ui:Panel({ id = "BattleUi", x = 70, y = -210, width = 436, height = 608, color = "#00000000", active = BattleUi.uiOpen })
    BattleUi.panel.attributes.allowDragging = true
    BattleUi.panel.attributes.returnToOriginalPositionWhenReleased = false

    BattleUi.playerUis = {}
    for _, player in ipairs(Player.Players()) do
        local playerUi = { height = 140 }
        local ordinal = player:Ordinal()
        BattleUi.playerUis[ordinal] = playerUi

        playerUi.open = true
        local panel = BattleUi.panel:Panel({ id = "Player"..ordinal, x = 0, y = -(playerUi.height + BattleUi.PLAYER_SPACING) * (ordinal - 1), width = 436, height = playerUi.height, color = "#121212ff" })
        playerUi.panel = panel
        playerUi.playerCircleImage = panel:Image({ id = "PlayerCircle", x = 8, y = -8, width = 25, height = 25, image = "WhiteCircle" })
        playerUi.nameText = panel:Text({ id = "Name", x = 38, y = -8, width = 280, height = 25, fontSize = 16, color = BattleUi.TEXT_COLOR, text = "Survivor with a very long name" })

        playerUi.turnEnded = false
        panel:Image({ id = "EndTurn", x = 324, y = -8, width = 48, height = 25, image = "BR_Sleep" })
        playerUi.endTurnButton = panel:Button({ id = "EndTurn", x = 324-1, y = -8+1, width = 48+2, height = 25+2, colors = BattleUi.DARK_COLORS, onClick = function()
            playerUi.turnEnded = not playerUi.turnEnded
            if playerUi.turnEnded then
                log:Printf("Player %d: %s turn ended", ordinal, player:SurvivorSheet():Survivor():NameOrUnnamed())
                playerUi.playerCircleImage:SetImage("GreyCircle")
                playerUi.nameText:SetColor(BattleUi.DISABLED_TEXT_COLOR)
                playerUi.nameText:SetFontStyle("Italic")
                playerUi.endTurnButton:SetColors(BattleUi.DARK_SELECTED_COLORS)
            else
                log:Printf("Player %d: %s next turn", ordinal, player:SurvivorSheet():Survivor():NameOrUnnamed())
                playerUi.playerCircleImage:SetImage("WhiteCircle")
                playerUi.nameText:SetColor(BattleUi.TEXT_COLOR)
                playerUi.nameText:SetFontStyle("Normal")
                playerUi.endTurnButton:SetColors(BattleUi.DARK_COLORS)
            end
        end})

        playerUi.showWeaponsImage = panel:Image({ id = "ShowWeapons", x = 380, y = -8, width = 48, height = 25, image = "BR_Show" })
        playerUi.showWeaponsButton = panel:Button({ id = "ShowWeapons", x = 380-1, y = -8+1, width = 48+2, height = 25+2, colors = BattleUi.DARK_COLORS, onClick = function()
            local survivor = player:SurvivorSheet():Survivor()
            log:Printf("Showing all weapons for %s", survivor:NameOrUnnamed())
            BattleUi.hiddenWeaponsBySurvivor[survivor] = nil
            BattleUi.UpdatePlayer(player)
        end})

        playerUi.weaponImages = {}
        playerUi.weaponHideWeaponsButtons = {}
        playerUi.weaponNameTexts = {}
        playerUi.weaponSpeedTexts = {}
        playerUi.weaponHitTexts = {}
        playerUi.weaponWoundTexts = {}
        playerUi.weaponCritTexts = {}
        local y = -41
        for i = 1, BattleUi.MAX_WEAPONS do
            playerUi.weaponImages[i] = panel:Image({ id = "Weapon"..i, x = 8, y = y, width = 420, height = 25, image = "BR_Weapon" })
            playerUi.weaponHideWeaponsButtons[i] = panel:Button({ id = "WeaponName"..i, x = 8-1, y = y+1, width = 8+19+8+2, height = 25+2, colors = BattleUi.DARK_COLORS, onClick = function()
                local text = playerUi.weaponNameTexts[i]
                local weaponName = text.object.UI.getAttribute(text.attributes.id, "text")
                local survivor = player:SurvivorSheet():Survivor()
                log:Printf("Hiding %s for %s", weaponName, survivor:NameOrUnnamed())
                if not BattleUi.hiddenWeaponsBySurvivor[survivor] then
                    BattleUi.hiddenWeaponsBySurvivor[survivor] = {}
                end
                BattleUi.hiddenWeaponsBySurvivor[survivor][weaponName] = true
                BattleUi.UpdatePlayer(player)
            end })
            playerUi.weaponNameTexts[i]  = panel:Text({ id = "WeaponName"..i,  x =  43, y = y, width = 172, height = 25, color = BattleUi.TEXT_COLOR, fontSize = 14, text = "Calcified Juggernaut Blade" })
            playerUi.weaponSpeedTexts[i] = panel:Text({ id = "WeaponSpeed"..i, x = 243, y = y, width = 20, height = 25, color = BattleUi.TEXT_COLOR, fontSize = 16, text = "44" })
            playerUi.weaponHitTexts[i]   = panel:Text({ id = "WeaponHit"..i,   x = 288, y = y, width = 20, height = 25, color = BattleUi.TEXT_COLOR, fontSize = 16, text = "44" })
            playerUi.weaponWoundTexts[i] = panel:Text({ id = "WeaponWound"..i, x = 334, y = y, width = 55, height = 25, color = BattleUi.TEXT_COLOR, fontSize = 16, text = "44 (+44)" })
            playerUi.weaponCritTexts[i]  = panel:Text({ id = "WeaponCrit"..i,  x = 407, y = y, width = 20, height = 25, color = BattleUi.TEXT_COLOR, fontSize = 16, text = "44" })
            y = y - 33
        end
    end
end

---------------------------------------------------------------------------------------------------

BattleUi.RELEVANT_SURVIVOR_STATS = {
    ["name"] = true,
    ["modifiedSpeed"] = true,
    ["modifiedAccuracy"] = true,
    ["modifiedStrength"] = true,
    ["modifiedEvasion"] = true,
    ["modifiedLuck"] = true,
}

BattleUi.RELEVANT_MONSTER_STATS = {
    ["toughness"] = true,
    ["evasion"] = true,
    ["luck"] = true,
}

function BattleUi.PostInit()
    -- We specifically delay registering event handlers until PostInit() to avoid redundant UpdatePlayer() calls from
    -- the ON_PLAYER_SURVIVOR_LINKED events emitted from Player.Init()
    EventManager.AddHandler(EventManager.ON_SHOWDOWN_STARTED, BattleUi.Show)
    EventManager.AddHandler(EventManager.ON_SHOWDOWN_ENDED, BattleUi.Hide)
    EventManager.AddHandler(EventManager.ON_PLAYER_SURVIVOR_LINKED, function(player) BattleUi.UpdatePlayer(player) end)
    EventManager.AddHandler(EventManager.ON_PLAYER_SURVIVOR_UNLINKED, function(player) BattleUi.UpdatePlayer(player) end)
    EventManager.AddHandler(EventManager.ON_SURVIVOR_STAT_CHANGED, function(survivor, stat, value)
        if BattleUi.RELEVANT_SURVIVOR_STATS[stat] then
            BattleUi.Update()
        end
    end)
    EventManager.AddHandler(EventManager.ON_MONSTER_STAT_CHANGED, function(stat)
        if BattleUi.RELEVANT_MONSTER_STATS[stat] then
            BattleUi.Update()
        end
    end)
    EventManager.AddHandler(EventManager.ON_PLAYER_WEAPONS_CHANGED, function(player) BattleUi.UpdatePlayer(player) end)
    EventManager.AddHandler(EventManager.ON_SURVIVOR_DESTROYED, function(survivor) BattleUi.hiddenWeaponsBySurvivor[survivor] = nil end)
    EventManager.AddHandler(EventManager.ON_PLAYER_COLOR_CHANGED, function(player, colorTable, colorStr)
        BattleUi.playerUis[player:Ordinal()].playerCircleImage:SetColor(colorStr)
    end)

    BattleUi.Update()
end

---------------------------------------------------------------------------------------------------

function BattleUi.Save()
    local hiddenWeaponsBySurvivorId = {}
    for survivor, hiddenWeapons in pairs(BattleUi.hiddenWeaponsBySurvivor) do
        hiddenWeaponsBySurvivorId[survivor:Id()] = hiddenWeapons
    end
    return hiddenWeaponsBySurvivorId
end

---------------------------------------------------------------------------------------------------

function BattleUi.CalcWeapons(player, survivor)
    -- dedup and consolidate weapons
    local hiddenWeapons = BattleUi.hiddenWeaponsBySurvivor[survivor] or {}
    local weaponsAndModifiers = {}
    local weaponCounts = {}
    for _, weaponAndModifiers in pairs(player:WeaponsAndModifiers()) do
        local weapon = weaponAndModifiers.weapon
        if not hiddenWeapons[weapon.name] then
            local count = weaponCounts[weapon.name] or 0
            weaponCounts[weapon.name] = count + 1
            if count == 0 then
                table.insert(weaponsAndModifiers, weaponAndModifiers)
            end
        end
    end
    table.sort(weaponsAndModifiers, function(wm1, wm2) return wm1.weapon.name < wm2.weapon.name end)

    local survivorSpeed = survivor:ModifiedSpeed()
    local survivorAccuracy = survivor:ModifiedAccuracy()
    local survivorStrength = survivor:ModifiedStrength()
    local survivorLuck = survivor:ModifiedLuck()

    local monsterEvasion = Monster.Evasion()
    local monsterToughness = Monster.Toughness()
    local monsterLuck = Monster.Luck()

    local results = {}
    for _, weaponAndModifiers in ipairs(weaponsAndModifiers) do
        local weapon = weaponAndModifiers.weapon

        local speed = Util.Max(1, weapon.speed + survivorSpeed + (weaponAndModifiers.modifiers["speed"] or 0))
        -- accuracy goes the opposite way
        local accuracy = weapon.accuracy - survivorAccuracy - (weaponAndModifiers.modifiers["accuracy"] or 0)  -- accuracy goes the opposite way
        local strength = weapon.strength + survivorStrength + (weaponAndModifiers.modifiers["strength"] or 0)
        local luck = (weapon.deadly or 0) + survivorLuck + (weaponAndModifiers.modifiers["luck"] or 0)

        local hit = Util.Clamp(accuracy + monsterEvasion, 2, 10)
        local wound = Util.Max(monsterToughness - strength, 2)    -- sharp weapons means we need to show the target roll if it's past 10
        local crit = Util.Clamp(10 - luck + monsterLuck, 2, 10)

        if weapon.paired and weaponCounts[weapon.name] > 1 then
            speed = speed + weapon.speed
        end
        if weapon.slow then
            speed = 1
        end

        table.insert(results, {
            name = weapon.name,
            speed = speed,
            hit = hit,
            wound = wound,
            strength = strength,
            crit = crit,
        })
    end

    return results
end

---------------------------------------------------------------------------------------------------

function BattleUi.UpdatePositions()
    local y = 0
    for ordinal, _ in ipairs(Player.Players()) do
        local playerUi = BattleUi.playerUis[ordinal]
        playerUi.panel:SetOffsetXY("0 "..y)
        if playerUi.open then
            y = y - BattleUi.playerUis[ordinal].height - BattleUi.PLAYER_SPACING
        end
    end
    BattleUi.panel:SetHeight(-y - 16)
end

---------------------------------------------------------------------------------------------------

function BattleUi.UpdatePlayerInternal(player)
    local playerUi = BattleUi.playerUis[player:Ordinal()]

    if not player:SurvivorSheet() then
        log:Debugf("Hiding %s", player)
        playerUi.open = false
        playerUi.height = 0
        playerUi.panel:Hide()
        return
    end

    local survivor = player:SurvivorSheet():Survivor()

    log:Debugf("Updating %s", player)

    playerUi.open = true
    playerUi.panel:Show()

    playerUi.nameText:SetText(survivor:NameOrUnnamed())
    playerUi.showWeaponsButton:Show()
    local weapons = BattleUi.CalcWeapons(player, survivor)
    local numShownWeapons = Util.Min(#weapons, BattleUi.MAX_WEAPONS)
    for i = 1, numShownWeapons do
        local weapon = weapons[i]
        playerUi.weaponImages[i]:Show()
        playerUi.weaponHideWeaponsButtons[i]:Show()
        playerUi.weaponNameTexts[i]:Show()
        playerUi.weaponNameTexts[i]:SetText(weapon.name)
        playerUi.weaponSpeedTexts[i]:Show()
        playerUi.weaponSpeedTexts[i]:SetText(weapon.speed)
        playerUi.weaponHitTexts[i]:Show()
        playerUi.weaponHitTexts[i]:SetText(weapon.hit)
        playerUi.weaponWoundTexts[i]:Show()
        playerUi.weaponWoundTexts[i]:SetText(string.format("%d (%s%d)", weapon.wound, weapon.strength > 0 and "+" or "", weapon.strength))
        playerUi.weaponCritTexts[i]:Show()
        playerUi.weaponCritTexts[i]:SetText(weapon.crit)
    end
    for i = numShownWeapons + 1, BattleUi.MAX_WEAPONS do
        playerUi.weaponImages[i]:Hide()
        playerUi.weaponHideWeaponsButtons[i]:Hide()
        playerUi.weaponNameTexts[i]:Hide()
        playerUi.weaponSpeedTexts[i]:Hide()
        playerUi.weaponHitTexts[i]:Hide()
        playerUi.weaponWoundTexts[i]:Hide()
        playerUi.weaponCritTexts[i]:Hide()
    end
    playerUi.height = 8 + (numShownWeapons + 1) * 33
    playerUi.panel:SetHeight(playerUi.height)
end

---------------------------------------------------------------------------------------------------

function BattleUi.UpdatePlayer(player)
    BattleUi.UpdatePlayerInternal(player)
    BattleUi.UpdatePositions()
end

---------------------------------------------------------------------------------------------------

function BattleUi.Update()
    for _, player in ipairs(Player.Players()) do
        BattleUi.UpdatePlayerInternal(player)
    end
    BattleUi.UpdatePositions()
end

---------------------------------------------------------------------------------------------------

function BattleUi.NextTurn()
    log:Printf("Starting next turn")

    local monsterControllerObject = nil
    local monsterControllerPlayer = nil

    local players = Player.Players()
    for i, _ in ipairs(players) do
        local playerPrefix = "Player "..i
        local survivalTokens = Location.Get(playerPrefix.." Survival Tokens"):AllObjects("Survival Tokens")
        for _, token in ipairs(survivalTokens) do
            rot = token.getRotation()
            if rot.z >= 15 and rot.z <= 345    then
                token.flip()
            end
        end

        local playerUi = BattleUi.playerUis[i]
        playerUi.turnEnded = false
        playerUi.playerCircleImage:SetImage("WhiteCircle")
        local color = NamedObject.Get(playerPrefix.." Marker").getColorTint()
        playerUi.playerCircleImage:SetColor("#"..Color(color):toHex())
        playerUi.nameText:SetColor(BattleUi.TEXT_COLOR)
        playerUi.nameText:SetFontStyle("Normal")
        playerUi.endTurnButton:SetColors(BattleUi.DARK_COLORS)

        if not monsterControllerObject then
            for _, hit in ipairs(Location.Get(playerPrefix.." Upper"):BoxCast()) do
                local object = hit.hit_object
                if object.getGMNotes() == "Monster Controller" then
                    log:Debugf("Found monster controller %s at player %d", object.getGUID(), i)
                    monsterControllerObject = object
                    monsterControllerPlayer = i
                    break
                end
            end
        end
    end

    if monsterControllerObject then
        monsterControllerPlayer = monsterControllerPlayer + 1
        if monsterControllerPlayer > #players then
            monsterControllerPlayer = 1
        end
        local survivorSheet = players[monsterControllerPlayer]:SurvivorSheet()
        if survivorSheet then
            log:Printf("%s is now the monster controller.", survivorSheet:Survivor():NameOrUnnamed())
        else
            log:Printf("Player %d is now the monster controller.", monsterControllerPlayer)
        end
        local newPosition = Location.Get("Player "..monsterControllerPlayer.." Monster Controller"):Center()
        monsterControllerObject.setPositionSmooth(newPosition, false, false)
    else
        log:Debugf("No monster controller found")
    end
end

---------------------------------------------------------------------------------------------------

function BattleUi.Show()
    BattleUi.panel:Show()
    BattleUi.uiOpen = true
end

---------------------------------------------------------------------------------------------------

function BattleUi.Hide()
    BattleUi.panel:Hide()
    BattleUi.uiOpen = false
end

---------------------------------------------------------------------------------------------------

return {
    Init = BattleUi.Init,
    PostInit = BattleUi.PostInit,
    Save = BattleUi.Save,
}