Scripts Lua : Pour commencer

Cette page vous apprend à écrire votre premier script Lua pour un prop FreeMinecraftModels, d'un fichier vide jusqu'à un prop interactif fonctionnel. À la fin, vous comprendrez les hooks, le contexte, l'API prop et la structure générale de chaque fichier de script de prop.

Une fois à l'aise avec les bases, poursuivez avec les pages complémentaires :

API Prop -- les API context.prop, context.event, context.world et autres API de contexte
Exemples et patterns -- des scripts complets fonctionnels que vous pouvez étudier et adapter
Dépannage -- erreurs courantes, astuces de débogage et la liste de vérification QC

Fonctionnalité expérimentale

Les scripts Lua pour les props sont actuellement expérimentaux. Les noms de hooks, les méthodes utilitaires et le comportement peuvent encore changer à mesure que FreeMinecraftModels évolue, alors testez soigneusement avant de les utiliser sur un serveur de production.

Relation avec le Lua d'EliteMobs

FreeMinecraftModels partage le même moteur Lua (Magmacore) qu'EliteMobs. Si vous écrivez déjà des pouvoirs Lua pour EliteMobs, les concepts fondamentaux -- hooks, context, api_version, scheduler, zones et le bac à sable -- sont identiques. La différence est :

Les scripts EliteMobs s'exécutent sur les boss et ont des hooks comme on_boss_damaged_by_player, on_enter_combat, etc.
Les scripts FMM s'exécutent sur les props et ont des hooks comme on_right_click, on_left_click, on_projectile_hit, etc.

Les API context.world, context.zones, context.scheduler, context.state et context.log sont les mêmes dans les deux plugins. Cette page ne couvre que ce qui est spécifique aux props FMM.

Ce que sont les scripts de props

Les scripts de props sont des fichiers .lua autonomes qui se trouvent dans le dossier plugins/FreeMinecraftModels/scripts/. Ils sont référencés depuis un fichier de configuration YAML qui se trouve à côté du fichier de modèle, et ils s'exécutent chaque fois que le prop est généré dans le monde.

Ce pour quoi les scripts de props excellent

Les scripts de props brillent lorsque vous avez besoin de :

Props interactifs qui réagissent aux clics des joueurs (portes, leviers, boutons)
Props décoratifs invulnérables qui ne peuvent pas être cassés par les joueurs
Déclencheurs de proximité qui détectent quand les joueurs entrent ou quittent une zone
Props animés qui jouent des animations lors d'interactions ou sur un minuteur
Props émetteurs de sons qui jouent des sons lorsqu'on clique dessus ou qu'on s'en approche
Tout comportement de prop nécessitant une logique au-delà de la décoration statique

Si votre prop est purement décoratif et n'a pas besoin d'interaction, vous n'avez pas besoin de script.

Ce que sont les scripts d'objets

Les scripts d'objets utilisent le même format de fichier .lua et le même dossier scripts/ que les scripts de props. La différence est qu'ils sont attachés à des objets personnalisés — des modèles dont le fichier de configuration YML définit un champ material:. Alors que les scripts de props s'exécutent lorsqu'une entité prop apparaît dans le monde, les scripts d'objets s'exécutent lorsqu'un joueur équipe l'objet personnalisé (main principale, main secondaire ou emplacement d'armure) et s'arrêtent lorsque l'objet est déséquipé.

Comment fonctionnent les scripts d'objets

Activation : une instance de script est créée lorsqu'un joueur équipe un objet FMM personnalisé. Les scripts sont par joueur et par type d'objet — une ScriptInstance par paire (joueur, itemId).
Désactivation : l'instance de script est détruite lorsque l'objet est déséquipé (sorti de l'emplacement actif, jeté, ou déconnexion du joueur).
Identification de l'objet : les objets personnalisés sont identifiés par la clé PDC (PersistentDataContainer) fmm_item_id, qui est différente du model_id du prop. Pour obtenir un objet correctement taggé, utilisez /fmm giveitem <id> ou le menu admin.
Contexte : les hooks d'objet reçoivent un context avec context.player, context.item, context.world, context.state, context.scheduler, context.log et, le cas échéant, context.event.

Ce pour quoi les scripts d'objets excellent

Les scripts d'objets brillent lorsque vous avez besoin de :

Armes personnalisées dotées de capacités spéciales (épées de givre, baguettes magiques)
Outils avec des actions uniques au clic droit ou au shift+clic
Objets consommables aux effets personnalisés
Armures aux effets passifs lorsqu'elles sont portées
Objets qui suivent leur utilisation ou disposent d'une durabilité limitée
Tout comportement d'objet tenu en main allant au-delà des mécaniques vanilla

À qui s'adresse cette page

Cette page est écrite pour trois types de lecteurs :

Quelqu'un qui connaît déjà les scripts Lua d'EliteMobs et veut apprendre les hooks et API spécifiques à FMM
Quelqu'un qui est nouveau dans les scripts Lua et a besoin d'une référence complète avec les noms exacts pour les props
Quelqu'un qui utilise l'IA pour rédiger des scripts de props et a besoin de suffisamment de détails pour détecter quand l'IA invente quelque chose de faux

Vous n'avez pas besoin de devenir un développeur Lua complet avant d'écrire des scripts de props utiles. Pour la plupart des scripts pratiques de props, les seules choses dont vous avez vraiment besoin sont :

Comment placer un hook valide dans la table retournée
Comment lire les valeurs depuis context
Comment arrêter l'exécution avec if ... then return end
Comment appeler quelques méthodes utilitaires exactement

Mini-introduction à Lua

Vous n'avez pas besoin d'être un expert Lua pour écrire des scripts FMM. La plupart des scripts n'utilisent qu'une poignée de concepts : les variables (local x = 5), les fonctions (function foo() end), les vérifications if (if x then ... end), les tables ({key = value}) et nil (la valeur « rien » de Lua). La syntaxe est légère — pas de point-virgule, pas d'accolades, juste end pour fermer les blocs.

Pour un parcours complet avec exemples, voir le Moteur de scripts Lua MagmaCore — Mini-introduction à Lua. Cette introduction est partagée par tous les plugins Nightbreak : l'apprendre une fois vaut partout.

Où placer les fichiers

Fichiers de script

Placez les fichiers .lua dans le dossier central de scripts :

plugins/
  FreeMinecraftModels/
    scripts/
      invulnerable.lua
      interactive_door.lua
      proximity_sound.lua

FMM découvre tous les fichiers .lua dans plugins/FreeMinecraftModels/scripts/ au démarrage.

Dans la liste scripts: d'un modèle, incluez l'extension .lua par souci de clarté. FMM accepte aussi les entrées sans extension et ajoute .lua en interne. Le fichier sur le disque doit malgré tout se terminer par .lua, et les noms restent sensibles à la casse.

Fichiers de modèle et fichiers de configuration

Chaque fichier de modèle peut avoir un fichier de configuration .yml adjacent dans le même répertoire :

plugins/
  FreeMinecraftModels/
    models/
      torch_01.fmmodel
      torch_01.yml          <-- configuration de script pour torch_01
    scripts/
      invulnerable.lua      <-- référencé par torch_01.yml

Le fichier de configuration .yml est ce qui connecte un modèle à ses scripts.

Format du fichier de configuration

Le fichier de configuration YAML qui se trouve à côté d'un fichier de modèle comporte ces champs :

isEnabled: true
voxelize: false
solidify: false
scripts:
  - invulnerable.lua

Pour les objets personnalisés (modèles que les joueurs peuvent tenir ou équiper), vous définissez également le champ material et, optionnellement, name, lore et enchantments :

isEnabled: true
material: DIAMOND_SWORD
name: "&bFrost Blade"
lore:
  - "&7A sword forged in eternal ice"
  - "&7Slows enemies on hit"
enchantments:
  - "SHARPNESS,5"
  - "UNBREAKING,3"
scripts:
  - frost_sword.lua

Champ	Type	Défaut	Notes
`isEnabled`	boolean	`true`	Si les scripts sont actifs pour ce prop/objet
`scripts`	liste de chaînes	`[]`	Noms de fichiers de scripts `.lua` dans le dossier `scripts/`
`voxelize`	boolean	`false`	Aligne le placement sur des rotations de 90 degrés et sur la grille de blocs
`solidify`	boolean	`false`	Place des blocs barrière uniquement par paquets dans l'empreinte du prop (nécessite `voxelize`)
`material`	string	`""`	Un nom de Material Bukkit valide (par ex. `DIAMOND_SWORD`). Le définir transforme le modèle en objet personnalisé que les joueurs peuvent tenir ou équiper, ce qui active le système de scripts d'objet
`name`	string	`""`	Nom d'affichage de l'objet personnalisé. Supporte les codes de couleur `&`
`lore`	liste de chaînes	`[]`	Lignes de lore affichées dans l'infobulle de l'objet. Supporte les codes de couleur `&`
`enchantments`	liste de chaînes	`[]`	Enchantements appliqués à l'objet. Format : `"ENCHANTMENT_NAME,LEVEL"` (par ex. `"SHARPNESS,5"`)

Vous pouvez attacher plusieurs scripts au même prop. Chaque script est sa propre instance indépendante.

ID d'objet et limite de scripts

L'ID d'objet est dérivé du nom du fichier YML sans son extension. Par exemple, frost_sword.yml produit l'ID d'objet frost_sword. C'est l'ID utilisé par /fmm giveitem et par la clé PDC fmm_item_id.
Les objets ne lient qu'un seul script de la liste scripts:. FMM parcourt les entrées dans l'ordre, utilise le premier script qu'il parvient à résoudre, puis ignore les suivantes. Contrairement aux objets, les props exécutent chaque script listé qu'ils peuvent résoudre, comme instance indépendante.
L'extension .lua est ajoutée automatiquement aux noms de fichiers de script si vous l'omettez : frost_sword et frost_sword.lua sont donc équivalents dans la liste scripts:.

Génération paresseuse de la configuration

Lorsqu'un prop apparaît et qu'aucun fichier .yml adjacent n'existe, FMM crée automatiquement un fichier de configuration par défaut avec isEnabled: true et une liste scripts: vide. Cela se fait de manière asynchrone, donc le prop n'aura pas de scripts lors de sa première apparition -- seulement après que la configuration soit créée et que vous l'éditiez pour ajouter les noms de fichiers de scripts.

Cela signifie :

Placez votre fichier de modèle dans models/
Faites apparaître le prop une fois (FMM crée le .yml automatiquement)
Éditez le .yml généré pour ajouter vos noms de fichiers de scripts
Refaites apparaître le prop ou rechargez (les scripts sont maintenant actifs)

Référence des hooks

Chaque fichier de script Lua pour prop retourne une table. Chaque clé de cette table (en dehors de api_version et priority) doit être l'un des hooks listés ci-dessous. Le moteur d'exécution appelle la fonction correspondante chaque fois que l'événement de jeu associé se déclenche.

Hook	Se déclenche quand	Notes
`on_spawn`	Le prop apparaît dans le monde	S'exécute une fois lorsque le script est lié
`on_game_tick`	Une fois par tick serveur (50 ms)	Actif uniquement si le script définit ce hook
`on_destroy`	Le prop est supprimé du monde	Hook de nettoyage
`on_left_click`	Un joueur fait un clic gauche (frappe) sur le prop	`context.event` est l'événement de dégâts
`on_right_click`	Un joueur fait un clic droit sur le prop	`context.event` est l'événement d'interaction
`on_zone_enter`	Un joueur entre dans une zone surveillée	Nécessite qu'une surveillance de zone soit configurée
`on_zone_leave`	Un joueur quitte une zone surveillée	Nécessite qu'une surveillance de zone soit configurée

Hook de prop réservé

Le validateur de scripts actuel accepte on_projectile_hit pour les scripts de prop, mais le runtime actuel ne distribue pas encore les impacts de projectiles aux scripts de prop. Utilisez le on_projectile_hit d'objet pour un comportement de projectile lié à un objet scripté, ou l'API Bukkit ModeledEntityHitByProjectileEvent pour une gestion des projectiles sur les entités modélisées côté plugin.

Référence des hooks d'objet

Les scripts d'objet retournent une table tout comme les scripts de prop, avec api_version = 1 et des fonctions de hook. Les hooks suivants sont disponibles pour les scripts d'objet. Tous les hooks d'objet reçoivent context avec context.player, context.item et (le cas échéant) context.event.

La colonne Notes nomme la famille d'événements Bukkit sous-jacente. Le wrapper Lua n'expose pas les champs bruts spécifiques à Bukkit tels que target, block, projectile ou item ; utilisez context.player, context.event.player et les requêtes d'aide sur les entités/le monde lorsque vous avez besoin de contexte supplémentaire.

Hooks de combat

Hook	Se déclenche quand	Notes
`on_attack_entity`	Le joueur attaque une entité en tenant l'objet	`context.event` est l'événement de dégâts
`on_kill_entity`	Le joueur tue une entité en tenant l'objet	`context.event` est l'événement de mort
`on_take_damage`	Le joueur subit des dégâts alors que l'objet est équipé	`context.event` est l'événement de dégâts
`on_shield_block`	Le joueur bloque des dégâts avec un bouclier	`context.event` est l'événement de dégâts
`on_shoot_bow`	Le joueur tire à l'arc	`context.event` est l'événement de tir à l'arc
`on_projectile_hit`	Un projectile tiré par le joueur touche quelque chose	`context.event` est l'événement d'impact de projectile
`on_projectile_launch`	Le joueur lance un projectile	`context.event` est l'événement de lancement de projectile

Hooks d'interaction

Hook	Se déclenche quand	Notes
`on_right_click`	Le joueur fait un clic droit en tenant l'objet	`context.event` est l'événement d'interaction
`on_left_click`	Le joueur fait un clic gauche en tenant l'objet	`context.event` est l'événement d'interaction
`on_shift_right_click`	Le joueur fait un clic droit + shift en tenant l'objet	`context.event` est l'événement d'interaction
`on_shift_left_click`	Le joueur fait un clic gauche + shift en tenant l'objet	`context.event` est l'événement d'interaction
`on_interact_entity`	Le joueur fait un clic droit sur une entité en tenant l'objet	`context.event` est l'événement d'interaction avec l'entité

Hooks d'équipement

Hook	Se déclenche quand	Notes
`on_equip`	L'objet est équipé (déplacé dans un emplacement actif)	Bon endroit pour initialiser l'état
`on_unequip`	L'objet est déséquipé (déplacé hors d'un emplacement actif)	Bon endroit pour faire le nettoyage
`on_swap_hands`	Le joueur échange l'objet entre la main principale et la main secondaire	`context.event` est l'événement d'échange
`on_drop`	Le joueur lâche l'objet	`context.event` est l'événement de lâcher

Hooks utilitaires

Hook	Se déclenche quand	Notes
`on_break_block`	Le joueur casse un bloc en tenant l'objet	`context.event` est l'événement de cassage de bloc
`on_consume`	Le joueur consomme l'objet (nourriture/potion)	`context.event` est l'événement de consommation
`on_item_damage`	L'objet subit des dégâts de durabilité	`context.event` est l'événement de dégâts d'objet
`on_fish`	Le joueur utilise une canne à pêche	`context.event` est l'événement de pêche
`on_death`	Le joueur meurt alors que l'objet est équipé	`context.event` est l'événement de mort

Hook de cycle de vie

Hook	Se déclenche quand	Notes
`on_game_tick`	À chaque tick serveur tant que l'objet est équipé	À utiliser avec parcimonie -- s'exécute 20 fois par seconde

Contrat minimal du fichier

Chaque script Lua de prop doit return une table.

Champs de premier niveau requis et optionnels

Champ	Requis	Type	Notes
`api_version`	Oui	Number	Doit actuellement être `1`
`priority`	Non	Number	Validé s'il est présent, mais FMM ne trie pas actuellement les scripts par ce champ. Les props s'exécutent dans l'ordre de la liste `scripts:` ; les objets ne lient que le premier script valide
clés de hook supportées	Non	Function	Doit utiliser l'un des noms de hook exacts listés dans la référence des hooks

Règles de validation

Le fichier doit retourner une table.
api_version est requis et doit actuellement être 1.
priority doit être numérique s'il est présent.
Chaque clé de premier niveau supplémentaire doit être un nom de hook supporté.
Chaque clé de hook doit pointer vers une fonction.
Les clés de premier niveau inconnues sont rejetées.

remarque

priority est utile pour garder les scripts portables entre les runtimes basés sur MagmaCore, mais l'ordre d'exécution actuel de FreeMinecraftModels est piloté par la configuration. Placez les scripts de prop dans la liste scripts: du modèle dans l'ordre où vous voulez qu'ils s'exécutent.

Les fonctions utilitaires et les constantes locales doivent être déclarées au-dessus du return final, pas à l'intérieur de la table retournée.

Votre premier script de prop fonctionnel, construit progressivement

Avant l'étape 1 : Configurer le fichier de configuration

Placez votre fichier de modèle (ex : my_prop.fmmodel) dans plugins/FreeMinecraftModels/models/
Faites apparaître le prop une fois pour générer la configuration .yml
Créez votre fichier de script dans plugins/FreeMinecraftModels/scripts/first_test.lua
Éditez plugins/FreeMinecraftModels/models/my_prop.yml :

isEnabled: true
scripts:
  - first_test.lua

Refaites apparaître le prop ou rechargez le serveur

Étape 1 : Faire charger le fichier

return {
  api_version = 1,

  on_spawn = function(context)
  end
}

Si cela se charge sans erreurs dans la console, vous avez prouvé :

Le fichier est du Lua valide
FMM l'a trouvé dans le dossier scripts/
La configuration le référence correctement
La forme de la table retournée est correcte

Étape 2 : Faire faire quelque chose de visible au prop

return {
  api_version = 1,

  on_spawn = function(context)
    context.log:info("Script de prop chargé pour : " .. (context.prop.model_id or "inconnu"))
  end
}

Vérifiez la console du serveur. Si vous voyez le message de log, votre hook fonctionne.

Étape 3 : Réagir à un clic de joueur

return {
  api_version = 1,

  on_right_click = function(context)
    context.log:info("Le prop a reçu un clic droit !")
  end
}

Faites un clic droit sur le prop en jeu. Si la console affiche le message, le hook de clic fonctionne.

Étape 4 : Annuler les dégâts pour rendre le prop invulnérable

return {
  api_version = 1,

  on_left_click = function(context)
    if context.event then
      context.event.cancel()
    end
  end
}

C'est le pattern utilisé par le script pré-configuré invulnerable.lua. Il annule l'événement de dégâts pour que le support d'armure du prop ne puisse pas être détruit.

Étape 5 : Jouer une animation au clic

return {
  api_version = 1,

  on_right_click = function(context)
    context.prop:play_animation("open", true, false)
  end
}

Cela joue l'animation "open" sur le modèle du prop, avec mélange et sans boucle.

Qu'est-ce que `context` ?

Chaque fonction de hook reçoit un argument appelé context. Considérez-le comme une boîte à outils que FMM vous donne chaque fois que quelque chose se produit -- elle contient tout ce dont vous avez besoin pour interagir avec le prop, le monde, les zones et plus encore.

Vous ne créez pas context vous-même -- FMM le crée et le passe à votre hook. Pour tous les détails sur les API de contexte partagées (context.state, context.log, context.cooldowns, context.scheduler, context.world, context.zones), voir la page Moteur de scripts Lua MagmaCore.

API `context` clés

Voici un résumé de ce qui est disponible. Pour les détails complets, consultez API Prop.

context.prop -- (Scripts de prop uniquement) L'entité prop. Fournit model_id, current_location, play_animation() et stop_animation().
context.item -- (Scripts d'objet uniquement) L'objet personnalisé. Fournit id, material(), get_amount(), set_amount(), consume(), get_uses(), set_uses(), get_name(), set_name(), get_lore(), set_lore(), get_durability(), get_durability_percentage(), use_durability() et use_durability_percentage(). Voir API Prop et Item pour tous les détails.
context.player -- Le joueur, pour les hooks pilotés par un joueur. Les scripts d'objet le résolvent depuis le propriétaire de l'objet ; les hooks de clic sur prop et les hooks de zone génériques le résolvent depuis le joueur déclencheur. Il vaut nil dans les hooks de cycle de vie du prop, dans les callbacks planifiés de prop, et dans les hooks n'impliquant pas de joueur.
context.event -- Un petit wrapper autour de l'événement Bukkit ou de l'acteur joueur qui a déclenché ce hook. Disponible dans les hooks de clic, de combat, d'interaction et de zone générique. Fournit event.player, is_cancelled et, lorsque l'événement Bukkit sous-jacent est annulable, cancel() / uncancel() ; il n'expose pas les champs spécifiques à Bukkit tels que target, block, projectile ou item. Vaut nil dans les hooks sans événement ni acteur joueur (comme on_spawn, on_game_tick et on_equip).
context.state -- Une table Lua simple qui persiste pendant la durée de vie de l'instance de script. Voir context.state.
context.cooldowns -- Aides pour les temps de recharge locaux et globaux. Utilisez context.cooldowns:check_local("key", ticks) pour les temps de recharge normaux par script. Voir context.cooldowns.
context.log -- Journalisation console. Voir context.log.
context.scheduler -- Tâches différées et répétitives. Voir context.scheduler.
context.world -- Interaction avec le monde : particules, sons, requêtes de blocs, foudre, entités à proximité. Voir context.world.
context.zones -- Créer et surveiller des zones spatiales (sphères, cylindres, cuboïdes). Voir context.zones.

Syntaxe des méthodes : `:` vs `.`

Pour une explication de la syntaxe de méthode : vs . en Lua, voir la page Moteur de scripts Lua MagmaCore. Les deux formes sont acceptées par l'API FMM.

Modèles de démarrage à copier-coller

Plus petit script de prop valide

return {
  api_version = 1,

  on_spawn = function(context)
  end
}

Modèle de prop invulnérable

return {
  api_version = 1,

  on_left_click = function(context)
    if context.event then
      context.event.cancel()
    end
  end
}

Modèle de prop interactif

return {
  api_version = 1,

  on_spawn = function(context)
    context.state.is_active = false
  end,

  on_right_click = function(context)
    context.state.is_active = not context.state.is_active

    if context.state.is_active then
      context.prop:play_animation("activate", true, true)
    else
      context.prop:stop_animation()
    end
  end
}

Plus petit script d'objet valide

return {
  api_version = 1,

  on_equip = function(context)
  end
}

Modèle d'objet avec action au clic droit

return {
  api_version = 1,

  on_right_click = function(context)
    if not context.cooldowns:check_local("activate", 40) then return end

    -- Your action here
    context.player:send_message("&aItem activated!")
  end
}

Structure de fichier plus grande

local ANIMATION_NAME = "idle"

local function do_something(context)
  context.log:info("En train de faire quelque chose !")
end

return {
  api_version = 1,
  priority = 0,

  on_spawn = function(context)
    context.state.task_id = nil
  end,

  on_right_click = function(context)
    do_something(context)
  end,

  on_destroy = function(context)
    if context.state.task_id ~= nil then
      context.scheduler:cancel(context.state.task_id)
    end
  end
}

Premier flux de travail réel

Lors de la construction d'un tout nouveau script de prop, suivez cet ordre :

Créez le fichier .lua et faites fonctionner on_spawn.
Ajoutez le nom du fichier de script à la configuration .yml du prop.
Changez pour le hook réel que vous voulez (ex : on_right_click).
Ajoutez un message de log d'abord, avant les animations ou effets.
Ajoutez un seul effet réel (animation, son, particule).
Seulement après cela, ajoutez les utilitaires, l'état, la logique de scheduler ou les zones.

Cet ordre rend le débogage considérablement plus facile car une seule chose change à la fois.

Scripts pré-configurés

FMM est livré avec quatre scripts Lua pré-configurés :

invulnerable.lua -- Annule les événements de dégâts de clic gauche, rendant le prop indestructible. C'est le script de prop utile le plus simple.
pickupable.lua -- Permet aux joueurs de ramasser un prop en le frappant trois fois. Chaque coup joue une animation de dégâts sur le prop, et au troisième coup, le prop est supprimé et lâche son objet de placement pour que le joueur le récupère.
storage_double.lua -- Transforme un prop en double coffre (54 emplacements). Le clic droit ouvre une GUI d'inventaire persistante. Joue des animations et des sons d'ouverture/fermeture. Le contenu est sauvegardé sur le prop et survit aux redémarrages du serveur. À la destruction, tout le contenu est lâché.
storage_single.lua -- Identique à storage_double, mais avec 3 rangées (27 emplacements) au lieu de 6.

Vous pouvez trouver plus d'exemples sur la page Exemples et patterns.

Bac à sable Lua

Les scripts de props et d'objets s'exécutent dans le même environnement LuaJ sandboxé qu'EliteMobs. Les restrictions du bac à sable sont identiques. Pour la liste complète des globales supprimées et des fonctions de bibliothèque standard disponibles, consultez la page Moteur de scripts Lua MagmaCore.

Prochaines étapes

API Prop et Item -- référence complète de context.prop, context.item, context.event, context.world, context.zones et context.scheduler
Exemples et patterns -- scripts complets et fonctionnels pour props et objets, avec explications pas à pas
Dépannage -- problèmes courants, astuces de débogage et checklist de contrôle qualité

Si vous écrivez également des pouvoirs Lua de boss EliteMobs, le bac à sable, api_version, la table d'état, les concepts de temps de recharge et la structure pilotée par les hooks vous seront familiers, mais le contexte de boss utilise des noms de méthodes spécifiques à EliteMobs. Voir la documentation Lua d'EliteMobs pour les API de boss exactes.

Ce que sont les scripts de props​

Ce pour quoi les scripts de props excellent​

Ce que sont les scripts d'objets​

Comment fonctionnent les scripts d'objets​

Ce pour quoi les scripts d'objets excellent​

À qui s'adresse cette page​

Mini-introduction à Lua​

Où placer les fichiers​

Fichiers de script​

Fichiers de modèle et fichiers de configuration​

Format du fichier de configuration​

Génération paresseuse de la configuration​

Référence des hooks​

Référence des hooks d'objet​

Hooks de combat​

Hooks d'interaction​

Hooks d'équipement​

Hooks utilitaires​

Hook de cycle de vie​

Contrat minimal du fichier​

Champs de premier niveau requis et optionnels​

Règles de validation​

Votre premier script de prop fonctionnel, construit progressivement​

Avant l'étape 1 : Configurer le fichier de configuration​

Étape 1 : Faire charger le fichier​

Étape 2 : Faire faire quelque chose de visible au prop​

Étape 3 : Réagir à un clic de joueur​

Étape 4 : Annuler les dégâts pour rendre le prop invulnérable​

Étape 5 : Jouer une animation au clic​

Qu'est-ce que context ?​

API context clés​

Syntaxe des méthodes : : vs .​

Modèles de démarrage à copier-coller​

Plus petit script de prop valide​

Modèle de prop invulnérable​

Modèle de prop interactif​

Plus petit script d'objet valide​

Modèle d'objet avec action au clic droit​

Structure de fichier plus grande​

Premier flux de travail réel​

Scripts pré-configurés​

Bac à sable Lua​

Prochaines étapes​