Piloter l'IA de combat avancée en Lua

local SORT_PRINCIPAL = 123456

function onFightStart(context)
    global:AddInGlobalMemory("combat-" .. context.sessionId, true)
end

function onPlacement(context)
    local cellules = context.challengerCells
    for _, entite in ipairs(fightAction:getAllEntities()) do
        if entite.Id == context.characterId and entite.Team then
            cellules = context.defenderCells
            break
        end
    end

    local cellule = cellules[1]
    if cellule == nil then
        return false
    end

    return fightAction:chooseCell(cellule)
end

function onTurn(context)
    if not fightCharacter:isItMyTurn() then
        return
    end

    local maCellule = fightCharacter:getCellId()
    local entites = fightAction:getAllEntities()
    local monCamp = nil

    for _, entite in ipairs(entites) do
        if entite.Id == context.characterId then
            monCamp = entite.TeamId
            break
        end
    end

    for _, entite in ipairs(entites) do
        if monCamp ~= nil and entite.TeamId ~= monCamp
            and entite.IsAlive and entite.IsPositionKnown then
            if fightAction:canCastSpellOnCell(
                maCellule,
                SORT_PRINCIPAL,
                entite.CellId
            ) == 0 then
                fightAction:castSpellOnCell(SORT_PRINCIPAL, entite.CellId)
                break
            end
        end
    end

    fightAction:passTurn()
end

function onFightEnd(context)
    global:printSuccess("Combat terminé : " .. tostring(context.sessionId))
end

function onPlacement(context)
    local entites = fightAction:getAllEntities()
    local moi = nil
    for _, entite in ipairs(entites) do
        if entite.Id == context.characterId then
            moi = entite
            break
        end
    end

    local disponibles = moi ~= nil and moi.Team
        and context.defenderCells
        or context.challengerCells
    if #disponibles == 0 then
        return false
    end

    local place = fightAction:chooseCell(disponibles[1])

    -- Exemple générique : répartir les autres alliés sur les places restantes.
    local index = 2
    for _, entite in ipairs(entites) do
        if moi ~= nil and entite.TeamId == moi.TeamId
            and entite.Id ~= context.characterId and disponibles[index] then
            fightAction:chooseAllyCell(entite.Id, disponibles[index])
            index = index + 1
        end
    end

    return place
end

local SORT_MENEUR = 123456
local SORT_MEMBRE = 123457

local function combattantCourant()
    local personnageId = character:id()
    for _, entite in ipairs(fightAction:getAllEntities()) do
        if entite.Id == personnageId then
            return entite
        end
    end
    return nil
end

local function cibleEnnemieLaPlusProche()
    local moi = combattantCourant()
    if moi == nil then
        return nil
    end

    local origine = fightCharacter:getCellId()
    local meilleure = nil
    local meilleureDistance = 999

    for _, entite in ipairs(fightAction:getAllEntities()) do
        if entite.TeamId ~= moi.TeamId
            and entite.IsAlive and entite.IsPositionKnown then
            local distance = fightAction:getDistance(origine, entite.CellId)
            if distance < meilleureDistance then
                meilleure = entite
                meilleureDistance = distance
            end
        end
    end

    return meilleure
end

local function essayerSort(sortId)
    local cible = cibleEnnemieLaPlusProche()
    if cible == nil then
        return false
    end

    local origine = fightCharacter:getCellId()
    if fightAction:canCastSpellOnCell(origine, sortId, cible.CellId) ~= 0 then
        return false
    end

    return fightAction:castSpellOnCell(sortId, cible.CellId)
end

function onPlacement(context)
    local moi = combattantCourant()
    local cellules = moi ~= nil and moi.Team
        and context.defenderCells
        or context.challengerCells
    local indexEquipe = character:getInTeamIndex()
    local cellulePersonnelle = cellules[indexEquipe] or cellules[1]

    if cellulePersonnelle == nil then
        return false
    end

    local place = fightAction:chooseCell(cellulePersonnelle)

    -- Le meneur réserve les premières cellules aux personnages connectés,
    -- puis place les compagnons sur les cellules encore disponibles.
    if global:isBoss() then
        local reservees = {}
        local membres = global:getTeamMembersIds()
        for index = 1, #membres do
            if cellules[index] ~= nil then
                reservees[cellules[index]] = true
            end
        end

        local indexCellule = #cellules
        for _, entite in ipairs(fightAction:getAllEntities()) do
            if moi ~= nil and entite.TeamId == moi.TeamId
                and entite.IsAlive and entite.IsCompanion then
                while indexCellule > 0 and reservees[cellules[indexCellule]] do
                    indexCellule = indexCellule - 1
                end

                local destination = cellules[indexCellule]
                if destination ~= nil then
                    if fightAction:chooseAllyCell(entite.Id, destination) then
                        reservees[destination] = true
                    end
                    indexCellule = indexCellule - 1
                end
            end
        end
    end

    return place
end

function onTurn(context)
    if not fightCharacter:isItMyTurn() then
        return
    end

    local sortId = global:isBoss() and SORT_MENEUR or SORT_MEMBRE

    if essayerSort(sortId) then
        fightAction:passTurn()
        return
    end

    -- Chaque membre délègue uniquement son propre tour.
    fightBasic:playTurn(2)
end

local plan = fightAction:getSpellCastPlan(123456, 250)

if plan.status == "cast-now" then
    fightAction:castSpellOnCell(plan.spellId, plan.castCell)
elseif plan.status == "cast-after-move" then
    if fightAction:moveToCellSafely(plan.moveCell) then
        local origine = fightCharacter:getCellId()
        if fightAction:canCastSpellOnCell(origine, plan.spellId, plan.castCell) == 0 then
            fightAction:castSpellOnCell(plan.spellId, plan.castCell)
        end
    end
elseif plan.status == "progress" then
    fightAction:moveToCellSafely(plan.moveCell)
else
    global:printWarning("Aucun plan : " .. tostring(plan.reason))
end

local SORT_ZONE = 123456
local plan = fightAction:planBestAreaCast(SORT_ZONE, {
    safeCells = { 500, 501 },
    maxAdvance = 3,
    mustReturn = true,
    avoidAllies = true
})

if plan.status ~= "impossible" and plan.actionCount > 0 then
    local resultat = fightAction:executeCombatPlan(plan)
    global:printMessage(
        "Actions réussies : " .. tostring(resultat.successfulActions) ..
        ", retour : " .. tostring(resultat.returned)
    )
end

local plan = fightAction:planAttackAndReturn(
    { 123456, 123457, 123458 },
    {
        safeCells = { fightCharacter:getCellId() },
        maxAdvance = 4,
        avoidAllies = true
    }
)

if plan.status ~= "impossible" then
    local resultat = fightAction:executeCombatPlan(plan)
    if not resultat.success then
        global:printWarning("Plan interrompu : " .. tostring(resultat.reason))
    end
end

function onTurn(context)
    local tourSpecial = context.round == 1

    if tourSpecial then
        -- Actions particulières du premier tour.
        fightAction:passTurn()
        return
    end

    -- Les autres tours utilisent les sorts configurés dans l'interface.
    fightBasic:playTurn(2)
end