Aller au contenu

map — Carte & Déplacement

API carte et déplacement MoonBot Lua : se déplacer, changer de map, pathfinding, zaaps, cellules.

48 fonctions dans ce namespace.

Index

Référence

map.currentMap

map.currentMap()

returns string

Coordonnees "x,y".

map.currentMapId / id

map.currentMapId() / map.id()

returns number

ID de la map.

map.x / y

map.x() / map.y()

returns number

Coordonnees x et y.

map.dimensions / width / height

map.dimensions() / map.width() / map.height()

returns table {width, height} / number / number

Dimensions de la map actuelle. dimensions() renvoie une table {width, height}. width()/height() renvoient directement le nombre. Standard Retro = 15x17, mais les maps non-standard sont gerees (valeurs lues depuis le SWF).

map.currentCell / cellId

map.currentCell() / map.cellId()

returns number

Cellule actuelle.

map.currentArea / currentSubArea

map.currentArea() / map.currentSubArea()

returns string

Zone et sous-zone.

map.onMap

map.onMap(coords: string | number)

returns boolean

Verifie si sur la map ("x,y" ou ID).

map.changeMap

map.changeMap(direction: string)

blocking · returns boolean

Change de map : "right", "left", "top", "bottom".

map.moveToCell

map.moveToCell(cellId: number)

blocking · returns boolean

Deplace vers une cellule (attend l'arrivee).

map.gather

map.gather()

blocking · returns boolean

Recolte toutes les ressources.

map.gatherResource

map.gatherResource(cellId: number)

blocking · returns boolean

Recolte la ressource de la cellule cible avec le sequenceur dedie (portee de l'outil, approche et confirmation serveur). Retourne true uniquement apres confirmation de la recolte ; false si la ressource est indisponible, refusee ou si aucune confirmation n'arrive sous 30 s.

map.fight

map.fight()

blocking · returns boolean

Attaque le groupe de monstres le plus proche.

map.moveToward

map.moveToward(x: number, y: number)

blocking · returns boolean

Un pas de map vers les coordonnees cibles.

map.moveTowardMap

map.moveTowardMap(mapId: number)

blocking · returns boolean

Un pas de map vers la map cible.

map.worldDistance

map.worldDistance(x: number, y: number)

returns number

Distance en maps vers les coordonnees (-1 si inaccessible).

map.waitForMapChange

map.waitForMapChange(timeout?: number)

blocking · returns boolean

Attend un changement de map.

map.monsterGroups

map.monsterGroups()

returns table of {id: number, cellId: number, name: string, level: number, count: number, monsters: table of {id: number, name: string, level: number}}

Groupes de monstres sur la map. name = noms des monstres, level = niveau du groupe, count = nombre de monstres, monsters = détail de chaque monstre (template ID, nom, niveau individuel).

map.fightGroup

map.fightGroup(groupId: number)

blocking · returns boolean

Attaque un groupe de monstres spécifique par son ID (récupéré via map.monsterGroups()). Bloquant : attend la fin du combat. Retourne true si victoire, false si défaite ou groupe introuvable.

map.players

map.players()

returns table of {id: number, cellId: number, name: string, level: number}

Joueurs visibles sur la map.

map.npcs

map.npcs()

returns table of {id: number, cellId: number, name: string, templateId: number}

PNJ sur la map. id = ID acteur, templateId = ID du modele PNJ.

map.getActors / getActorById

map.getActors() / map.getActorById(id: number)

returns table / table | nil

Tous les acteurs (monstres + joueurs + PNJ) : {id, cellId, name, type}. type = 'monster'/'player'/'npc'.

map.getResources

map.getResources()

returns table of {cellId: number, gfxId: number, name: string}

Ressources recoltables sur la map.

map.interactiveObjects

map.interactiveObjects()

returns table of {cellId: number, gfxId: number}

Objets interactifs (ateliers, portes, etc).

map.useInteractive

map.useInteractive(cellId: number, skillIndex?: number)

blocking · returns boolean

Utilise un objet interactif avec deplacement automatique. Le trajet cible la cellule exacte de l'objet ; le serveur peut confirmer un arret sur une cellule adjacente valide. skillIndex: 1=premier skill (defaut), 2=deuxieme, etc. Pour une recolte, utiliser de preference map.gatherResource(). Pour un menu (zaap, atelier, porte, enclos), l'action peut reussir sans evenement GatherComplete : le boolean generique ne confirme donc pas toujours l'ouverture et peut retourner false apres une attente allant jusqu'a 30 s. Preferer l'API specialisee lorsqu'elle existe.

Limites des interactifs generiques

-- maisons et enclos multi-instance

Les objets ordinaires (zaaps, zaapis, ateliers, portes, coffres et enclos simples) partagent le meme pathfinding officiel. Les maisons ou enclos qui exigent un troisieme parametre instanceId ne sont pas pris en charge par l'API Lua generique ; utiliser le bouton Client natif pour ces variantes.

map.isWalkable / getWalkableCells

map.isWalkable(cellId) / map.getWalkableCells()

returns boolean / table

Verifie si une cellule est marchable / liste des cellules marchables.

map.getX / getY

map.getX(mapId) / map.getY(mapId)

returns number

Coordonnees d'une map depuis son ID (game data).

map.hasChanged

map.hasChanged()

returns boolean

True si la map a change. Se remet a false automatiquement.

map.openZaap / openZaapi

map.openZaap() / map.openZaapi()

blocking · returns boolean

Approche le zaap/zaapi avec le pathfinding officiel, ouvre son menu et attend la liste des destinations. Retourne true quand la liste est recue, false si aucune liste n'arrive sous 10 s.

map.useZaap / useZaapi

map.useZaap(mapId) / map.useZaapi(mapId)

blocking · returns boolean

Selectionne une destination dans le menu deja ouvert (WU pour un zaap, Wu pour un zaapi) et attend le changement de carte. Ces fonctions n'approchent pas de l'objet et ne l'ouvrent pas : appeler openZaap()/openZaapi() juste avant. En cas de timeout de 10 s, useZaapi() retourne false tandis que useZaap() leve actuellement une erreur Lua ; utiliser pcall pour un script tolerant aux echecs.

Sequence zaap recommandee

if not map.openZaap() then return false end
local ok, result = pcall(map.useZaap, mapId)
return ok and result == true

blocking · returns boolean

Enchainement autonome et tolerant aux echecs recommande. Pour un zaapi, utiliser openZaapi() puis useZaapi(mapId).

map.getZaapDestinations

map.getZaapDestinations()

returns table of {map_id: number, cost: number, name: string, area: string, x: number, y: number}

Liste des destinations disponibles apres openZaap() ou openZaapi().

map.saveZaap

map.saveZaap()

Sauvegarde le zaap actuel.

map.sendEmote / sit

map.sendEmote(emoteId) / map.sit()

Envoie une emote. sit() = emote 1.

Deplacement et combat — aliases

map.moveTo(cellId) / tryFight() / tryFightGroup(groupId) / tryFightGroupOnCell(cellId)

returns boolean

moveTo est un alias de moveToCell. Les fonctions tryFight ne lancent le combat que si le groupe cible est toujours present.

Informations de zone et distance

map.zoneInfo() / map.worldDistanceToMap(mapId) / map.neighbourId(direction)

returns table / number / number

zoneInfo decrit la zone courante et worldDistanceToMap calcule une distance de monde. neighbourId est un stub historique et retourne 0.

Utilitaires de carte

map.closeZaap() / map.slap()

returns boolean

Ferme l'interface zaap/zaapi ou envoie l'emote texte historique de slap.

Groupe de jeu

map.inviteToGroup(name) / leaveGroup() / acceptGroupInvite() / declineGroupInvite()

returns boolean

Inviter un joueur au groupe, quitter, accepter/refuser l'invitation en attente. acceptGroupInvite et declineGroupInvite retournent true seulement si une invitation etait reellement en attente ; sinon rien n'est envoye et le retour est false.

map.getPendingGroupInvite

map.getPendingGroupInvite()

returns inviterId: number, inviterName: string | nil

Invitation de groupe recue et pas encore traitee. Retourne 0, nil s'il n'y en a pas. Le paquet du jeu ne porte que des noms : inviterId vaut l'ID du joueur s'il est visible sur la map courante, sinon -1 (l'invitation est bien en attente, testez ~= 0). Les invitations traitees automatiquement (chef de groupe MoonBot, mode prive) ne sont pas exposees. L'invitation disparait quand elle est acceptee/refusee, quand le bot rejoint un groupe ou quand l'inviteur l'annule.

map.waitForGroupInvite

map.waitForGroupInvite(timeout?: number)

blocking · returns inviterId: number, inviterName: string | nil

Attend une invitation de groupe (retour immediat si une est deja en attente). Retourne 0, nil au bout du timeout (defaut 60000 ms). Exemple : local id, name = map.waitForGroupInvite(30000) if id ~= 0 then delay(math.random(1500, 4000)) map.declineGroupInvite() end

Infos groupe de jeu

map.getPartyMembers() / getPartyCount() / isInParty() / getPartyLeaderId() / isPartyLeader()

returns table / number / boolean / number / boolean

getPartyMembers()→table of {id: number, name: string, class_id: number, sex: boolean, level: number, life_percent: number}. getPartyCount()→number. isInParty()→boolean. getPartyLeaderId()→number. isPartyLeader()→boolean.

Defis entre joueurs

map.challengePlayer(id) / acceptChallenge(id?) / declineChallenge(id?) / cancelChallenge()

returns boolean

Proposer un defi amical, accepter/refuser le defi en attente, annuler son propre defi. acceptChallenge et declineChallenge visent le defi en attente (id optionnel pour ne repondre qu'a ce joueur) et retournent true seulement si un defi etait reellement en attente ; sinon rien n'est envoye et le retour est false.

map.aggressPlayer

map.aggressPlayer(target: number | string)

returns boolean

Demande une agression PvP contre un autre joueur visible sur la carte courante. target est son ID positif ou son nom exact (sans distinction de casse). L'appel Lua lance directement la demande ; le bouton de la MapViewer demande une confirmation. Retourne false si la cible ou l'action est indisponible, true si la commande est mise en file (le serveur peut encore la refuser). Les restrictions d'agression, l'etat du personnage et la presence de la cible sont reverifies avant envoi ; une commande devenue perimee lors d'un changement de carte est abandonnee. Exemple : local queued = map.aggressPlayer(123456). Accepte aussi map:aggressPlayer(target).

map.getPendingChallenge

map.getPendingChallenge()

returns challengerId: number, challengerName: string | nil

Defi PvP recu et pas encore traite. Retourne 0, nil s'il n'y en a pas. Le defi disparait quand il est accepte/refuse/annule, au changement de map et au debut d'un combat. En mode prive le defi est refuse automatiquement et n'est pas expose.

map.waitForChallenge

map.waitForChallenge(timeout?: number)

blocking · returns challengerId: number, challengerName: string | nil

Attend un defi PvP (retour immediat si un defi est deja en attente). Retourne 0, nil au bout du timeout (defaut 60000 ms). Exemple : local id, name = map.waitForChallenge(30000) if id ~= 0 then delay(math.random(2000, 5000)) map.declineChallenge(id) end

map.joinableFights

map.joinableFights()

returns table of {fightId: number, teamId: number, fighters: table of {id: number, name: string, level: number}}

Liste les combats joignables visibles sur la map (1 entree par equipe, teamId negatif). fightId est synthetique : plus petit |teamId| de la paire (les 2 equipes d'un meme combat partagent le meme fightId).

map.joinFight

map.joinFight(teamId: number)

returns boolean

Rejoint une equipe d'un combat en cours sur la map. teamId vient de joinableFights() (ex: -862).

map.exchangePlayer

map.exchangePlayer(playerId: number)

Demande un echange avec un joueur.