fightAction

Actions, sorts et déplacements en comba

castSpellOnCell

🎮Méthode

fightAction:castSpellOnCell(spell, cell)

Lance un sort sur une cellule cible. Envoie une demande de lancer au serveur et attend la confirmation. Si le lancer est reussi, les PA sont automatiquement mis a jour.

Paramètres:

Nom	Type	Description
spell	number	ID du sort a lancer
cell	number	ID de la cellule cible (0-559)

Retourne: boolean - true si le sort a ete lance avec succes

Exemple:

-- Lancer un sort sur un ennemi
local enemyCellId = fightAction:getNearestEnemy()
local success = fightAction:castSpellOnCell(12345, enemyCellId)
if success then
    global:printSuccess("Sort lance!")
else
    global:printError("Echec du lancer")
end

-- Boucle d'attaque tant qu'on a des PA
while fightCharacter:getAP() >= 3 do
    local enemy = fightAction:getNearestEnemy()
    if enemy ~= -1 then
        fightAction:castSpellOnCell(sortId, enemy)
    else
        break
    end
end

Note: Le sort est lance uniquement si le combat est actif. Les PA sont automatiquement mis a jour apres le lancer.

---

canCastSpellOnCell

🎮Méthode

fightAction:canCastSpellOnCell(startCell, spell, cell, needToCheckInvoc, needToCheckLOS)

Vérifie si un sort peut être lancé sur une cellule cible depuis une position donnée. Effectue de nombreuses vérifications : PA suffisants, portée du sort, ligne de vue (LdV), temps de relance, nombre de lancers par tour/par cible, états interdisant le lancement, etc. Retourne un code d’erreur.

Paramètres:

Nom	Type	Description
startCell	number	Cellule de depart (position du lanceur)
spell	number	ID du sort
cell	number	Cellule cible
needToCheckInvoc	boolean	Verifier si les invocations bloquent (defaut: true)
needToCheckLOS	boolean	Verifier la ligne de vue (defaut: true)

Retourne: number - Code SpellInabilityReason: 0 = possible, autres = raison de l'impossibilite

Exemple:

-- Verifier avant de lancer
local myCell = fightCharacter:getCellId()
local result = fightAction:canCastSpellOnCell(myCell, 12345, targetCell, true, true)

if result == 0 then
    fightAction:castSpellOnCell(12345, targetCell)
elseif result == 1 then
    global:printWarning("Pas assez de PA")
elseif result == 2 then
    global:printWarning("Hors de portee")
elseif result == 3 then
    global:printWarning("Ligne de vue bloquee")
end

-- Codes SpellInabilityReason courants:
-- 0 = CAN_CAST (possible)
-- 1 = ACTION_POINTS (PA insuffisants)
-- 2 = TOO_FAR (trop loin)
-- 3 = LINE_OF_SIGHT (LOS bloquee)
-- 4 = COOLDOWN (en recharge)
-- 5 = MAX_CAST_PER_TURN (max lancer/tour atteint)
-- 6 = MAX_CAST_PER_TARGET (max lancer/cible atteint)

Note : Très utile pour optimiser l’IA en vérifiant la faisabilité avant de tenter le lancement. Évite les échecs inutiles.

---

moveTowardCell

🎮Méthode

fightAction:moveTowardCell(cellid)

Deplace le personnage vers une cellule cible. Calcule automatiquement le chemin optimal via le pathfinding. Si la cellule cible est occupee, trouve une cellule adjacente libre. Attend la confirmation du mouvement.

Paramètres:

Nom	Type	Description
cellid	number	ID de la cellule cible (0-559)

Retourne: boolean - true si le déplacement a été effectué.

Exemple:

-- Se deplacer vers l'ennemi le plus proche
local enemyCellId = fightAction:getNearestEnemy()
if enemyCellId ~= -1 then
    local success = fightAction:moveTowardCell(enemyCellId)
    if success then
        global:printMessage("Deplacement effectue")
    end
end

-- Se rapprocher puis attaquer
if fightCharacter:getMP() > 0 then
    fightAction:moveTowardCell(targetCell)
end
if fightAction:isHandToHand(fightCharacter:getCellId(), targetCell) then
    fightAction:castSpellOnCell(sortCaC, targetCell)
end

Note: Le pathfinding evite automatiquement les obstacles et les autres combattants. Si la cible est occupee, le bot se place sur une case adjacente.

---

passTurn

🎮Méthode

fightAction:passTurn()

Termine le tour du personnage. Envoie le signal de fin de tour au serveur. Le prochain combattant dans l'ordre de timeline prendra son tour.

Exemple:

-- Fin de tour apres avoir joue
function fightManagement()
    -- Actions de combat...
    while fightCharacter:getAP() >= 3 do
        fightAction:castSpellOnCell(sortId, cible)
    end

    -- Fin du tour
    fightAction:passTurn()
end

-- Passer le tour si vie trop basse
if fightCharacter:getLifePointsP() < 10 then
    global:printWarning("Vie critique, je passe")
    fightAction:passTurn()
    return
end

Note: IMPORTANT: Toujours appeler passTurn() a la fin de la logique de combat pour ne pas bloquer le combat.

---

chooseCell

🎮Méthode

fightAction:chooseCell(cell)

Choisit une cellule de placement en phase de pre-combat. Envoie la demande au serveur et attend la confirmation avec un timeout de 50 secondes. Affiche le message "Placement sur la cellule: X" dans le chat.

Paramètres:

Nom	Type	Description
cell	number	ID de la cellule de placement souhaitee

Exemple:

-- Dans prefightManagement()
function prefightManagement(positionsChallengers, positionsDefenders)
    -- Choisir une cellule eloignee des ennemis
    local meilleureCellule = nil
    local maxDistance = 0

    for cellId, _ in pairs(positionsChallengers) do
        local distMin = 1000
        for cellDef, _ in pairs(positionsDefenders) do
            local dist = fightAction:getDistance(cellId, cellDef)
            if dist < distMin then
                distMin = dist
            end
        end
        if distMin > maxDistance then
            maxDistance = distMin
            meilleureCellule = cellId
        end
    end

    if meilleureCellule then
        fightAction:chooseCell(meilleureCellule)
    end
end

Note: Uniquement utilisable pendant la phase de placement, avant le debut du combat.

---

getNearestEnemy

🎮Méthode

fightAction:getNearestEnemy()

Retourne l'ID de cellule de l'ennemi le plus proche. Parcourt tous les combattants, filtre les ennemis et calcule la distance Manhattan. Retourne -1 si aucun ennemi trouve ou si le combat n'est pas actif.

Retourne: number - ID de la cellule de l'ennemi le plus proche, ou -1 si aucun

Exemple:

-- Cibler l'ennemi le plus proche
local enemyCellId = fightAction:getNearestEnemy()
if enemyCellId ~= -1 then
    global:printMessage("Ennemi le plus proche sur cellule: " .. enemyCellId)

    -- Se rapprocher si trop loin
    local distance = fightAction:getDistance(fightCharacter:getCellId(), enemyCellId)
    if distance > 3 then
        fightAction:moveTowardCell(enemyCellId)
    end

    -- Attaquer
    fightAction:castSpellOnCell(sortId, enemyCellId)
end

Note: Retourne la CELLULE de l'ennemi, pas son ID de combattant. Utiliser getFighter(cellId) pour obtenir le combattant.

---

getNearestAlly

🎮Méthode

fightAction:getNearestAlly()

Retourne l’ID de la cellule de l’allié le plus proche (hors soi-même). Parcourt les combattants de la même équipe et renvoie la cellule de l’allié le plus proche.

Retourne: number - ID de la cellule de l'allie le plus proche

Exemple:

-- Rejoindre l'allie le plus proche
local allieCellId = fightAction:getNearestAlly()
if allieCellId ~= -1 then
    fightAction:moveTowardCell(allieCellId)
end

-- Soigner l'allie le plus proche
local allieCellId = fightAction:getNearestAlly()
if allieCellId ~= -1 then
    fightAction:castSpellOnCell(sortSoin, allieCellId)
end

Note: Utile pour les classes support qui doivent rester pres de leurs allies.

---

getAllEntities

🎮Méthode

fightAction:getAllEntities()

Retourne la liste de tous les combattants presents dans le combat. Chaque combattant contient: Id, CellId, LifePoints, MaxLifePoints, Team, AP, MP, Level, etc.

Retourne: table - Liste de PlugCombat (tous les combattants)

Exemple:

-- Lister tous les combattants
local entities = fightAction:getAllEntities()
for _, entity in ipairs(entities) do
    local type = entity.Team and "Ennemi" or "Allie"
    global:printMessage(type .. " - PV: " .. entity.LifePoints .. "/" .. entity.MaxLifePoints ..
                       " - Cell: " .. entity.CellId)
end

-- Trouver l'ennemi le plus faible
local plusFaible = nil
local minHP = 999999
for _, entity in ipairs(fightAction:getAllEntities()) do
    if entity.Team and entity.LifePoints > 0 and entity.LifePoints < minHP then
        minHP = entity.LifePoints
        plusFaible = entity
    end
end
if plusFaible then
    fightAction:castSpellOnCell(sortId, plusFaible.CellId)
end

Note: PlugCombat.Team = true pour les defenders (ennemis dans getNearestEnemy), false pour les challengers (notre equipe). ATTENTION: La logique peut varier selon le contexte de combat.

---

getEntitiesCount

🎮Méthode

fightAction:getEntitiesCount()

Retourne le nombre total de combattants dans le combat.

Retourne: number - Nombre de combattants

Exemple:

local count = fightAction:getEntitiesCount()
global:printMessage("Combattants: " .. count)

-- Verifier si combat presque termine
local entities = fightAction:getAllEntities()
local ennemisVivants = 0
for _, e in ipairs(entities) do
    if e.Team and e.LifePoints > 0 then
        ennemisVivants = ennemisVivants + 1
    end
end
global:printMessage("Ennemis restants: " .. ennemisVivants)

---

getDistance

🎮Méthode

fightAction:getDistance(cellStart, cellEnd)

Calcule la distance Manhattan entre deux cellules (|x1-x2| + |y1-y2|). Retourne -1 si le combat n'est pas actif.

Paramètres:

Nom	Type	Description
cellStart	number	Cellule de depart
cellEnd	number	Cellule d'arrivee

Retourne: number - Distance en cases (Manhattan), ou -1 si erreur

Exemple:

-- Verifier si a portee
local maCellule = fightCharacter:getCellId()
local enemyCellule = fightAction:getNearestEnemy()
local distance = fightAction:getDistance(maCellule, enemyCellule)

global:printMessage("Distance a l'ennemi: " .. distance)

if distance <= 3 then
    fightAction:castSpellOnCell(sortDistance, enemyCellule)
elseif distance == 1 then
    fightAction:castSpellOnCell(sortCaC, enemyCellule)
end

Note: Distance Manhattan = somme des distances horizontale et verticale. Une case adjacente = distance 1.

---

isHandToHand

🎮Méthode

fightAction:isHandToHand(firstCell, secondCell)

Verifie si deux cellules sont au corps a corps (adjacentes, distance <= 1).

Paramètres:

Nom	Type	Description
firstCell	number	Premiere cellule
secondCell	number	Deuxieme cellule

Retourne: boolean - true si les cellules sont adjacentes (CaC)

Exemple:

-- Verifier si au corps a corps avec l'ennemi
local maCellule = fightCharacter:getCellId()
local enemyCellule = fightAction:getNearestEnemy()

if fightAction:isHandToHand(maCellule, enemyCellule) then
    global:printMessage("Au corps a corps!")
    fightAction:castSpellOnCell(sortCaC, enemyCellule)
else
    global:printMessage("Trop loin pour le CaC")
    fightAction:moveTowardCell(enemyCellule)
end

---

cellsAligned

🎮Méthode

fightAction:cellsAligned(cell1, cell2)

Verifie si deux cellules sont alignees (meme ligne ou meme colonne).

Paramètres:

Nom	Type	Description
cell1	number	Premiere cellule
cell2	number	Deuxieme cellule

Retourne: boolean - true si les cellules sont alignees

Exemple:

-- Verifier l'alignement pour un sort en ligne
local maCellule = fightCharacter:getCellId()
local enemyCellule = fightAction:getNearestEnemy()

if fightAction:cellsAligned(maCellule, enemyCellule) then
    global:printSuccess("Cibles alignees - sort en ligne possible!")
    fightAction:castSpellOnCell(sortEnLigne, enemyCellule)
end

Note: Important pour les sorts qui necessitent un lancer en ligne (pas de diagonale).

---

cellsInDiagonal

🎮Méthode

fightAction:cellsInDiagonal(int_0, int_1)

Verifie si deux cellules sont en diagonale (meme difference en X et Y).

Signature: fightAction:cellsInDiagonal(int_0, int_1)

Paramètres:

Nom	Type	Description
int_0	number	Premiere cellule
int_1	number	Deuxieme cellule

Retourne: boolean - true si les cellules sont en diagonale

Exemple:

-- Verifier pour un sort diagonal
if fightAction:cellsInDiagonal(maCellule, cible) then
    global:printMessage("En diagonale!")
    fightAction:castSpellOnCell(sortDiagonal, cible)
end

Note: Utile pour les sorts qui ne peuvent etre lances qu'en diagonale.

---

inLineOfSight

🎮Méthode

fightAction:inLineOfSight(firstCell, secondCell, diagonal)

Verifie si une ligne de vue (LOS) existe entre deux cellules. Trace une ligne entre les deux points et verifie qu'aucun obstacle ne bloque la vue. Si diagonal=true, verifie aussi que les cellules sont en diagonale.

Paramètres:

Nom	Type	Description
firstCell	number	Cellule de depart
secondCell	number	Cellule cible
diagonal	boolean	Exiger une diagonale stricte (defaut: false)

Retourne: boolean - true si la cible est visible

Exemple:

-- Verifier la LOS avant de lancer
local maCellule = fightCharacter:getCellId()
local enemyCellule = fightAction:getNearestEnemy()

if fightAction:inLineOfSight(maCellule, enemyCellule, false) then
    global:printSuccess("Cible visible!")
    fightAction:castSpellOnCell(sortLOS, enemyCellule)
else
    global:printWarning("Ligne de vue bloquee - deplacement necessaire")
    -- Chercher une meilleure position
end

Note: Les obstacles (murs, elements de decor) bloquent la ligne de vue. Les autres combattants peuvent aussi bloquer selon le sort.

---

isWalkable

🎮Méthode

fightAction:isWalkable(cellId)

Verifie si une cellule est marchable (pas un obstacle).

Paramètres:

Nom	Type	Description
cellId	number	ID de la cellule a verifier

Retourne: boolean - true si la cellule est marchable

Exemple:

-- Verifier avant de se deplacer
if fightAction:isWalkable(targetCell) then
    fightAction:moveTowardCell(targetCell)
else
    global:printWarning("Cellule non marchable (obstacle)")
end

Note: Une cellule peut etre marchable mais occupee par un combattant. Utilisez isFreeCell() pour verifier les deux.

---

isFreeCell

🎮Méthode

fightAction:isFreeCell(cellId)

Verifie si une cellule est libre (marchable ET non occupee par un combattant).

Signature: fightAction:isFreeCell(cellId)

Paramètres:

Nom	Type	Description
cellId	number	ID de la cellule

Retourne: boolean - true si la cellule est libre

Exemple:

-- Trouver une cellule libre adjacente
local adjacentes = fightAction:getAdjacentCells(maCellule)
for _, cell in ipairs(adjacentes) do
    if fightAction:isFreeCell(cell) then
        global:printMessage("Cellule libre: " .. cell)
        fightAction:moveTowardCell(cell)
        break
    end
end

Note: Combine la verification de marchabilite et d'occupation.

---

getReachableCells

🎮Méthode

fightAction:getReachableCells()

Retourne la liste des cellules atteignables avec les PM actuels. Parcourt toutes les cellules (0-559), filtre les cellules libres, et verifie que la distance Manhattan est <= PM.

Retourne: table - Liste des IDs de cellules atteignables

Exemple:

-- Obtenir les cellules ou je peux me deplacer
local cellules = fightAction:getReachableCells()
global:printMessage("Cellules atteignables: " .. #cellules)

-- Choisir la meilleure position
for _, cell in ipairs(cellules) do
    if fightAction:inLineOfSight(cell, enemyCellule, false) then
        fightAction:moveTowardCell(cell)
        break
    end
end

---

getRealReachableCells

🎮Méthode

fightAction:getRealReachableCells()

Retourne les cellules reellement atteignables en tenant compte du pathfinding complet. Plus precis que getReachableCells() car prend en compte les obstacles et les chemins bloques.

Retourne: table - Liste des cellules reellement atteignables

Exemple:

-- Cellules vraiment accessibles
local cellules = fightAction:getRealReachableCells()
global:printMessage("Cellules reellement accessibles: " .. #cellules)

Note: Plus lent que getReachableCells() mais plus precis.

---

accessibleCells

🎮Méthode

fightAction:accessibleCells(id)

Retourne les cellules accessibles pour une entite specifique. Si id=-1, utilise le personnage actuel.

Signature: fightAction:accessibleCells(id)

Paramètres:

Nom	Type	Description
id	number	ID du combattant (defaut: -1 = soi-meme)

Retourne: table - Liste d'AccessibleCell avec les infos de chaque cellule

Exemple:

-- Cellules accessibles pour moi
local cells = fightAction:accessibleCells(-1)

-- Cellules accessibles pour un ennemi specifique
local enemyId = 123456
local enemyCells = fightAction:accessibleCells(enemyId)

---

getAdjacentCells

🎮Méthode

fightAction:getAdjacentCells(cellId)

Retourne les cellules adjacentes a une cellule donnee. Retourne les 4 cellules cardinales (haut, bas, gauche, droite) si elles existent sur la grille.

Paramètres:

Nom	Type	Description
cellId	number	Cellule centrale

Retourne: table - Liste des IDs de cellules adjacentes

Exemple:

-- Obtenir les cellules autour de moi
local adjacentes = fightAction:getAdjacentCells(fightCharacter:getCellId())
global:printMessage("Cellules adjacentes: " .. #adjacentes)

-- Chercher une cellule libre adjacente
for _, cell in ipairs(adjacentes) do
    if fightAction:isFreeCell(cell) then
        global:printMessage("Cellule adjacente libre: " .. cell)
    end
end

---

getCells_cross

🎮Méthode

fightAction:getCells_cross(centerCell, minRadius, radius)

Retourne les cellules en forme de croix (+) autour d'une cellule centrale. Les cellules sont sur les axes cardinaux (haut, bas, gauche, droite) entre minRadius et radius.

Paramètres:

Nom	Type	Description
centerCell	number	Cellule centrale
minRadius	number	Rayon minimum (distance minimale)
radius	number	Rayon maximum (distance maximale)

Retourne: table - Liste des cellules en croix

Exemple:

-- Cellules en croix a 1-3 cases de distance
local crossCells = fightAction:getCells_cross(maCellule, 1, 3)
for _, cell in ipairs(crossCells) do
    if fightAction:getFighter(cell) ~= -1 then
        global:printMessage("Combattant sur la croix!")
    end
end

---

getCells_diagonal

🎮Méthode

fightAction:getCells_diagonal(centerCell, minRadius, radius)

Retourne les cellules en diagonale (X) autour d'une cellule centrale. Les cellules sont sur les axes diagonaux entre minRadius et radius.

Paramètres:

Nom	Type	Description
centerCell	number	Cellule centrale
minRadius	number	Rayon minimum
radius	number	Rayon maximum

Retourne: table - Liste des cellules en diagonale

Exemple:

-- Cellules en diagonale
local diagCells = fightAction:getCells_diagonal(maCellule, 1, 3)

---

getCells_lozenge

🎮Méthode

fightAction:getCells_lozenge(centerCell, minRadius, radius)

Retourne les cellules en losange autour d'une cellule centrale. Le losange est la zone classique de Dofus (toutes les cellules a distance Manhattan entre minRadius et radius).

Paramètres:

Nom	Type	Description
centerCell	number	Cellule centrale
minRadius	number	Rayon minimum
radius	number	Rayon maximum

Retourne: table - Liste des cellules en losange

Exemple:

-- Zone de sort en losange (portee 0-4)
local zoneCells = fightAction:getCells_lozenge(targetCell, 0, 4)
local ennemisZone = 0
for _, cell in ipairs(zoneCells) do
    if fightAction:getFighter(cell) ~= -1 then
        ennemisZone = ennemisZone + 1
    end
end
global:printMessage("Ennemis dans la zone: " .. ennemisZone)

Note: Le losange est la forme de zone la plus courante dans Dofus.

---

getCells_square

🎮Méthode

fightAction:getCells_square(centerCell, minRadius, radius)

Retourne les cellules en carre autour d'une cellule centrale. Le carre inclut toutes les cellules dont la distance Chebyshev (max de |dx| et |dy|) est entre minRadius et radius.

Paramètres:

Nom	Type	Description
centerCell	number	Cellule centrale
minRadius	number	Rayon minimum
radius	number	Rayon maximum

Retourne: table - Liste des cellules en carre

Exemple:

-- Zone carree
local squareCells = fightAction:getCells_square(maCellule, 0, 2)

---

getSpellZone

🎮Méthode

fightAction:getSpellZone(spellId, cellId)

Retourne la zone d'effet d'un sort lance sur une cellule. Calcule les cellules affectees selon le type de zone et le rayon definis dans les effets du sort.

Paramètres:

Nom	Type	Description
spellId	number	ID du sort
cellId	number	Cellule cible du sort

Retourne: table - Liste des cellules affectees par le sort

Exemple:

-- Voir la zone d'effet d'un sort
local zone = fightAction:getSpellZone(12345, targetCell)
if zone then
    global:printMessage("Cellules affectees: " .. #zone)

    -- Compter les ennemis dans la zone
    local ennemis = 0
    for _, cell in ipairs(zone) do
        local fighter = fightAction:getFighter(cell)
        -- Verifier si c'est un ennemi
    end
end

Note: Utile pour optimiser les sorts de zone en ciblant la cellule qui touche le plus d'ennemis.

---

getFighter

🎮Méthode

fightAction:getFighter(cellId)

Retourne l'ID du combattant sur une cellule donnee. Retourne -1 si la cellule est vide.

Paramètres:

Nom	Type	Description
cellId	number	ID de la cellule

Retourne: number - ID du combattant, ou -1 si cellule vide

Exemple:

-- Verifier qui est sur une cellule
local fighterId = fightAction:getFighter(256)
if fighterId ~= -1 then
    global:printMessage("Combattant ID: " .. fighterId .. " sur cellule 256")
else
    global:printMessage("Cellule 256 vide")
end

---

GetShortestPath

🎮Méthode

fightAction:GetShortestPath(int_0, int_1, list_0)

Calcule le chemin le plus court entre deux cellules en evitant les obstacles. Utilise le Pathfinder interne pour trouver le chemin optimal.

Paramètres:

Nom	Type	Description
int_0	number	Cellule de depart
int_1	number	Cellule d'arrivee
list_0	table	Liste de cellules a eviter (obstacles additionnels)

Retourne: table - Liste des cellules du chemin, ou nil si impossible

Exemple:

-- Calculer un chemin
local path = fightAction:GetShortestPath(maCellule, targetCell, {})
if path then
    global:printMessage("Chemin de " .. #path .. " cases")
    for i, cell in ipairs(path) do
        global:printMessage("Etape " .. i .. ": cellule " .. cell)
    end
end

---

getCurrentTurn

🎮Méthode

fightAction:getCurrentTurn()

Retourne le numero du tour actuel du combat. Incremente a chaque nouveau tour.

Retourne: number - Numero du tour (commence a 1)

Exemple:

local tour = fightAction:getCurrentTurn()
global:printMessage("Tour " .. tour)

-- Adapter la strategie selon le tour
if tour == 1 then
    -- Premier tour: buff et positionnement
elseif tour > 5 then
    -- Tours avances: focus DPS
end

---

getCurrentMapId

🎮Méthode

fightAction:getCurrentMapId()

Retourne l'ID de la map de combat.

Retourne: number - ID de la carte de combat

Exemple:

local mapId = fightAction:getCurrentMapId()
global:printMessage("Combat sur map: " .. mapId)

---

forceCellidEntity

🎮Méthode

fightAction:forceCellidEntity(entity, newCellid)

Force la position d'une entite localement. ATTENTION: Modification locale uniquement, n'affecte pas le serveur.

Paramètres:

Nom	Type	Description
entity	number	ID du combattant
newCellid	number	Nouvelle cellule

Exemple:

-- Forcer la position d'un ennemi (local uniquement)
fightAction:forceCellidEntity(enemyId, 200)

Note: ATTENTION: Ne modifie pas la position reelle sur le serveur. Utile pour des simulations ou du debug.

---