Aller au contenu

craft — Artisanat

API artisanat MoonBot Lua : crafter en série, choisir recettes, gestion des ateliers.

24 fonctions dans ce namespace.

Index

Référence

craft.isOpen

craft.isOpen()

returns boolean

True si une fenetre d'artisanat est ouverte, en atelier solo ou en artisanat cooperatif (artisan/client). Une simple invitation en attente retourne false.

craft.getState

craft.getState()

returns table

Copie de l'etat de l'atelier : {active, exchange_type, exchange_context, craft_skill_id, craft_job_level, craft_running, craft_quantity, craft_payment, craft_payment_on_success, craft_successes, craft_total, my_ready, their_ready, craft_public}. exchange_type vaut 3 en solo, 12 pour l'artisan cooperatif et 13 pour son client ; toujours verifier active et abandonner si exchange_context change. Les valeurs de paiement, quantite, verrou et objets sont confirmees par le serveur. En FM cooperative, cooperative_fm contient {inventory, bag, craft, bag_locked, pending, revision, rejected_revision, last_error}. Ses listes contiennent {uid, template_id, quantity, item_type, fm_allowed, name, effects}. pending indique une demande envoyee dont la confirmation est attendue ; false ne prouve pas qu'une commande Lua mise en file a deja ete traitee. revision avance lors d'une confirmation locale ; rejected_revision et last_error signalent un refus de traitement. Capturer les revisions AVANT la demande puis attendre la confirmation et l'etat voulu, ou un refus, avec un delai borne. En FM, craft_successes/craft_total cumulent les resultats depuis l'ouverture de la session et les paiements portent sur la session. Voir le guide docs/forgemagie-cooperative.md pour les attentes et les deux roles. Lecture sans envoi, compatible craft:getState().

craft.forgemagicAction

craft.forgemagicAction(operation: table, expectedContext?: string)

returns boolean

Actions de FM cooperative : {action='move_item', uid, quantity} depose (positif) ou reprend (negatif) dans le sac client ; {action='fm_lock', locked=true/false} verrouille (client) ou deverrouille (client/artisan) ; {action='fm_move', to_craft=true/false, uid, quantity} deplace entre sac et fusion (artisan) ; {action='fm_signature', add=true/false, uid} ajoute/retire la signature de l'artisan, ajout au niveau 100 ; {action='validate'} applique une rune ; {action='fm_auto', running=true/false} demarre/arrete la boucle artisan. expectedContext est le jeton lu avec les objets selectionnes : le fournir permet de refuser un changement d'atelier avant mise en file. S'il est omis, le contexte courant est capture. Retourne true a la mise en file, false si la demande est deja indisponible ; le moteur reverifie avant envoi. Attendre la progression de revision et l'etat voulu, ou rejected_revision/last_error, sans se contenter de pending=false. Conserver le meme contexte et borner l'attente ; voir docs/forgemagie-cooperative.md. Accepte aussi craft:forgemagicAction(operation, expectedContext).

Exemple — verrouiller le sac FM

local state = craft.getState()
local fm = state.cooperative_fm
assert(state.active and state.exchange_type == 13 and fm, "Atelier FM client requis")
if fm.bag_locked then return end
assert(not fm.pending and #fm.bag > 0, "Preparer le sac et attendre les confirmations")
local context = state.exchange_context
local revision, rejected = fm.revision, fm.rejected_revision
assert(craft.forgemagicAction({action="fm_lock", locked=true}, context), "Action indisponible")
for attempt = 1, 50 do
  global.delay(100)
  state = craft.getState()
  fm = state.cooperative_fm
  assert(state.active and fm and state.exchange_context == context, "Atelier change")
  assert(fm.rejected_revision == rejected, fm.last_error or "Action refusee")
  if fm.revision > revision and not fm.pending and fm.bag_locked then
    print("Verrou confirme par le serveur")
    return
  end
end
error("Confirmation absente apres 5 secondes ; aucune relance automatique")

Cote client, apres avoir prepare le sac et confirme le paiement : verrouille puis attend au maximum 5 secondes la confirmation. A executer avec un seul pilote des actions de ce personnage. Le contexte et les compteurs sont captures avant la commande ; pending=false seul ne suffit pas. Apres une erreur, relire l'etat ; pour une attente persistante, fermer puis rouvrir l'atelier. Le guide docs/forgemagie-cooperative.md fournit les mouvements, la fusion artisan, la signature et l'arret.

craft.setPublicMode

craft.setPublicMode(public: boolean)

returns boolean

Active/desactive le mode public d'artisanat. Le mode public est desactive par defaut dans le client officiel ; l'artisan doit se placer pres du plan de travail compatible puis l'activer pour que le serveur annonce ses competences aux joueurs. Retourne false si le personnage ou l'echange ne permet pas l'action, true si la demande est mise en file. Les competences ne sont disponibles qu'apres la reponse serveur : verifier craft.getPlayerSkills() avant d'inviter un client. Accepte aussi craft:setPublicMode(public).

craft.getPlayerSkills

craft.getPlayerSkills(target?: number | string)

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

Competences d'artisanat actuellement annoncees par le serveur pour ce joueur, triees par ID. Sans target (ou nil), renvoie celles de notre personnage ; sinon target est l'ID positif ou le nom exact d'un joueur visible (sans distinction de casse). Une table vide signifie qu'aucune competence n'est annoncee pour la carte courante. Ce ne sont pas tous les metiers appris : les possibilites d'invitation dependent de l'atelier et de l'etat courant. Accepte aussi craft:getPlayerSkills(target).

craft.invitePlayer

craft.invitePlayer(target: number | string, skillId: number)

returns boolean

Invite le joueur cible a fabriquer un objet avec notre personnage comme artisan. skillId est un ID de competence annonce pour nous par craft.getPlayerSkills(), pas un ID de metier ni de recette. Retourne false si la cible ou la competence n'est pas disponible pour une invitation, true si la demande est mise en file ; le destinataire doit ensuite l'accepter. La carte, la cible et la competence sont reverifiees avant envoi. target accepte un ID positif ou un nom exact sans distinction de casse. Accepte aussi craft:invitePlayer(target, skillId).

craft.requestPlayer

craft.requestPlayer(target: number | string, skillId: number)

returns boolean

Demande les services du joueur cible comme artisan ; notre personnage est le client. skillId doit etre annonce pour cette cible par craft.getPlayerSkills(target). Meme semantique que invitePlayer : false si indisponible, true si mis en file, avec revalidation avant envoi ; cela ne garantit pas l'acceptation par le joueur ou le serveur. Le destinataire utilise exchange.getPendingRequest() puis exchange.accept() ou exchange.refuse(). Accepte aussi craft:requestPlayer(target, skillId).

craft.setPayment

craft.setPayment(amount: number, kind?: number, expectedContext?: string)

returns boolean

Propose un paiement dans un atelier cooperatif ouvert, uniquement cote client. En craft classique, paiement PAR FABRICATION : kind=1 (defaut) normal, kind=2 supplement en cas de reussite ; (normal + supplement) multiplie par la quantite doit rester dans nos kamas. En FM cooperative, seul kind=1 est disponible : paiement TOTAL de la session, modifiable tant que le sac est deverrouille et aucune confirmation n'est attendue. amount est un entier entre 0 et 2147483647 ; 0 retire le paiement. Retourne false si les preconditions locales echouent, true a la mise en file ; le moteur reverifie et seule la confirmation serveur actualise le paiement. La proposition ne lance pas de fabrication. expectedContext est le jeton de l'atelier lu avant preparation ; s'il est fourni et devenu obsolete, la demande retourne false avant mise en file. En FM, le sac doit etre deverrouille, la boucle arretee et aucune confirmation en attente. Accepte aussi craft:setPayment(amount, kind, expectedContext).

Exemple — attendre un paiement confirme

local wanted = 100
local state = craft.getState()
if not state.active or state.exchange_type ~= 13 or state.craft_running or state.cooperative_fm then return end
local context = state.exchange_context
-- Eviter une nouvelle demande si la valeur est deja confirmee.
if state.craft_payment ~= wanted then
  if not craft.setPayment(wanted, 1, context) then return end
  local confirmed = false
  for attempt = 1, 20 do
    global.delay(250)
    state = craft.getState()
    if not state.active or state.exchange_type ~= 13 or state.exchange_context ~= context or state.craft_running then return end
    if state.craft_payment == wanted then
      confirmed = true
      break
    end
  end
  if not confirmed then
    craft.leave()
    return
  end
end
craft.combine()

Craft classique uniquement. Cote client, propose 100 kamas par fabrication et attend au maximum 5 secondes la confirmation avant de demander la validation. Arrete l'attente si l'atelier change ou si une fabrication commence. Ne change pas simultanement un autre parametre dans cet exemple. Pour une quantite, suivre le meme schema avec craft.setQuantity(wanted) et state.craft_quantity ; pour le supplement, utiliser setPayment(wanted, 2) et craft_payment_on_success. Si aucune confirmation n'arrive, ferme l'atelier et termine cette action, sans relance infinie. L'autre participant doit aussi valider. Pour la FM cooperative, suivre le guide docs/forgemagie-cooperative.md.

Exemple — solliciter un artisan

local artisan = "Nom-artisan"
local skills = craft.getPlayerSkills(artisan)
if #skills > 0 then
  local queued = craft.requestPlayer(artisan, skills[1].id)
  print(queued and "Demande envoyee au moteur" or "Artisan indisponible")
end

Demande la premiere competence annoncee par un artisan visible. Choisir explicitement le skillId voulu si plusieurs competences sont disponibles. Une invitation attend la reponse de l'autre joueur ; ne pas la relancer en boucle. Pour inviter un client avec notre personnage artisan, utiliser craft.getPlayerSkills() puis craft.invitePlayer(client, skillId).

Exemple — proposer ses services

if not craft.setPublicMode(true) then return end
local skills = craft.getPlayerSkills()
for attempt = 1, 20 do
  if #skills > 0 then break end
  global.delay(250)
  skills = craft.getPlayerSkills()
end
if #skills > 0 then
  craft.invitePlayer("Nom-client", skills[1].id)
end

Placer d'abord le personnage pres du plan de travail de son metier. Active le mode public, attend au maximum 5 secondes les competences annoncees puis invite le client visible. Si aucune competence n'arrive, verifier la position et le metier ; le script ne force pas une invitation indisponible. craft.setPublicMode(false) desactive ensuite le mode public lorsque l'atelier cooperatif est ferme.

craft.putItem / removeItem

craft.putItem(templateId, qty) / craft.removeItem(templateId, qty)

returns boolean

Ajoute/retire un ingredient dans un atelier ouvert. Au concasseur (competence 181), ces appels restent disponibles ; preferer crusher.putItem/removeItem et leurs variantes ByUid pour attendre les quantites confirmees. En cooperatif, seul le client fournit les ingredients : l'artisan retourne false. En FM cooperative, ces fonctions deplacent entre inventaire et sac client, uniquement sac deverrouille ; pour choisir un equipement par UID, utiliser craft.forgemagicAction. qty doit etre un entier entre 1 et 2147483647, sans arrondi. true indique une mise en file : attendre les conteneurs confirmes avant de continuer en FM. Accepte aussi craft:putItem(templateId, qty) / craft:removeItem(templateId, qty).

craft.setQuantity

craft.setQuantity(qty: number)

returns boolean

Nombre de repetitions d'une recette classique dans un atelier ouvert. Retourne false au concasseur (competence 181) : le brisage porte sur les quantites deposees et ne se repete pas avec cette fonction. En craft cooperatif classique, seul le client le modifie ; l'artisan retourne false. Retourne false en FM cooperative : l'artisan utilise craft.forgemagicAction({action='fm_auto', running=true}, context) pour sa boucle. qty doit etre un entier entre 1 et 2147483647, sans arrondi. Accepte aussi craft:setQuantity(qty).

craft.combine

craft.combine()

returns boolean

Demande la validation. Au concasseur (competence 181), lance le brisage des objets prepares, sans craft.setQuantity() ; meme action que exchange.ready(). En craft cooperatif classique, les deux participants doivent valider apres confirmation des quantites et paiements. En FM cooperative, seul l'artisan peut appliquer une rune, avec sac verrouille, equipement et rune dans la zone de fusion, boucle arretee et aucune confirmation en attente ; retourne false si ces conditions locales manquent. Les operations sont reverifiees par le moteur : true signifie mise en file, pas fabrication confirmee. Pour conserver explicitement le contexte lu avant preparation en FM, preferer craft.forgemagicAction({action='validate'}, context), puis l'attente d'etat du guide docs/forgemagie-cooperative.md.

craft.waitForResult

craft.waitForResult(timeout?: number)

blocking · returns table | nil

Attente historique d'un evenement de craft : {successes, total, failures}. Cette fonction ne rattache pas l'evenement a une demande ou un contexte ; un resultat ancien peut etre deja en file. En FM cooperative, elle peut aussi se terminer sur la premiere rune d'une boucle encore active. Pour confirmer une action ou la fin d'une boucle FM, utiliser l'attente d'etat avec contexte et revisions du guide docs/forgemagie-cooperative.md.

craft.leave

craft.leave()

returns boolean

Ferme l'atelier.

craft.getRecipe

craft.getRecipe(itemId: number)

returns table | nil

Recette : {{id, quantity, name}, ...}.

craft.canCraft

craft.canCraft(itemId: number)

returns boolean

True si les ingredients sont en inventaire.

craft.maxCraftable

craft.maxCraftable(itemId: number)

returns number

Nombre max de crafts possibles.

craft.recipesForSkill

craft.recipesForSkill(skillId: number)

returns table

Items craftables avec ce skill : {id, name}.

craft.lastResult

craft.lastResult()

returns table | nil

Compteurs connus : {successes, total, failures}, ou nil avant tout resultat. En FM cooperative, ils sont cumules depuis l'ouverture de la session ; ils ne decrivent pas seulement la derniere rune ni la derniere boucle. Comparer a une valeur de depart pour mesurer une operation.

craft.craftedItems

craft.craftedItems()

returns table

Ingredients des slots : {id, uid, quantity, name}. En craft cooperatif classique, retourne les ingredients du client pour les deux roles. En FM cooperative, retourne les objets de la zone de fusion pour les deux roles, avec le champ effects transmis par le serveur. Le sac et le clone d'inventaire FM se lisent dans craft.getState().cooperative_fm.bag et .inventory ; exchange.myItems()/theirItems() decrivent les echanges ordinaires.

Aliases historiques de craft

craft.PutItem(...) / RemoveItem(...) / ChangeQuantityToCraft(qty) / setRepeatCraft(qty) / Ready()

Aliases de putItem, removeItem, setQuantity et combine.