Interface

Des formulaires que le joueur remplit et des éléments à l’écran : barres de boss et barre latérale. Tout cela fonctionne pour n’importe quel client, que Crafting y soit installé ou non.

Formulaires

Un formulaire a un titre, un texte, des champs et des boutons. Tu le déclares dans un fichier sous ui/ et tu l’affiches là où tu en as besoin (une commande, un événement, l’utilisation d’un objet) :

import { give_rubies } from "/lib/rewards"

const SHOP = form("Ruby shop", {
    body: "Rubies cost 10 emeralds each.",
    fields: [
        { slider: "amount", label: "Rubies", min: 1, max: 16, default: 1 },
        { toggle: "gift", label: "Wrap as a gift" },
        { choice: "pouch", label: "Pouch", options: ["leather", "silk"] },
        { text: "note", label: "Note" }
    ],
    buttons: [{ id: "buy", label: "Buy" }, "cancel"]
})

fun open_shop(p: Player) {
    p.show_form(SHOP, fun(r) {
        if r.button != "buy" { return }                  // closed with Esc or cancelled
        let n = int(r.number("amount") ?? 1)
        if p.inventory.count("minecraft:emerald") < n * 10 { p.send("&cNot enough emeralds"); return }
        give_rubies(p, n)
        if r.toggle("gift") { p.send("&dWrapped in {r.choice("pouch")}: {r.text("note")}") }
    })
}

import { open_shop } from "/ui/shop"

command shop describe "Buy rubies" {
    if player == null { return "Players only" }
    open_shop(player)
}

Champ	S’écrit	Se lit avec
Texte	{ text: "note", label: "Note", default: "" }	r.text("note")
Interrupteur	{ toggle: "gift", label: "C’est un cadeau", default: false }	r.toggle("gift")
Curseur	{ slider: "amount", label: "Quantité", min: 1, max: 64, step: 1, default: 8 }	r.number("amount")
Choix	{ choice: "color", label: "Couleur", options: ["red", "blue"], default: "red" }	r.choice("color")

• Chaque clé de champ utilise des lettres minuscules, des chiffres et _. label est ce que voit le joueur ; s’il manque, c’est la clé qui est utilisée.
• buttons est une liste de { id, label } ou simplement d’ids. Un formulaire sans boutons reçoit un bouton « OK ».
• Dans la réponse, r.button est l’id du bouton pressé, ou null si le joueur a fermé le formulaire (Échap). r.values est une map avec tous les champs.
• La réponse arrive dans la fonction que tu passes à show_form ; le reste du serveur continue de tourner pendant que le joueur se décide.

En Kotlin

package com.example.rubies.ui

object ShopForm {
    private val form = Form("Ruby shop").apply {
        body = "Rubies cost 10 emeralds each."
        slider("amount", "Rubies", 1.0, 16.0, default = 1.0)
        toggle("gift", "Wrap as a gift")
        choice("pouch", "Pouch", listOf("leather", "silk"))
        text("note", "Note")
        button("buy", "Buy")
        button("cancel", "Cancel")
    }

    fun show(player: Player) = player.showForm(form) { r ->
        if (r.button != "buy") return@showForm                 // closed with Esc or cancelled
        val n = (r.number("amount") ?: 1.0).toInt()
        if (player.inventory.count(Identifier.parse("minecraft:emerald")) < n * 10) { player.send("&cNot enough emeralds"); return@showForm }
        player.give(ItemStack.of(Items.RUBY, n))
        if (r.toggle("gift") == true) player.send("&dWrapped in ${r.choice("pouch")}: ${r.text("note")}")
    }
}

Form(title) avec body, text(key, label, default, maxLength), toggle(key, label, default), slider(key, label, min, max, step, default), choice(key, label, options, default) et button(id, label). player.showForm(form) { r -> … } reçoit une FormResponse avec button, values et text, toggle, number, choice.

Barres de boss

Une barre en haut de l’écran, avec un titre, une couleur, une progression et un style. Utilise-la pour un minuteur, un événement du serveur ou la santé de quelque chose :

const TIMER = server.boss_bar("rubies:countdown", "&cRuée vers le rubis", "red", "segments_10")
let left = 60

on join { TIMER.show(player) }

every 1 second {
    left = max(0, left - 1)
    TIMER.progress = left / 60
    TIMER.title = "&cRuée vers le rubis : {left} s"
    if left == 0 { TIMER.remove() }
}

Membre	Ce qu’il fait
server.boss_bar(id, title?, color?, style?)	Crée la barre ou renvoie celle qui existe déjà avec cet id. Un id par barre : recharger le mod ne la duplique pas.
bar.progress	De 0 à 1.
bar.title	Le texte, avec les couleurs &.
bar.color	pink, blue, red, green, yellow, purple, white.
bar.style	solid, segments_6, segments_10, segments_12, segments_20.
bar.show(player), bar.hide(player)	Qui la voit. bar.players les liste.
bar.remove()	La retire pour tout le monde et libère l’id.

En Kotlin : Crafting.server?.bossBar("rubies:countdown", "Time", BarColor.RED, BarStyle.SEGMENTS_10), avec les mêmes propriétés en camelCase.

Barre latérale

Une liste de 15 lignes au maximum sur le côté droit de l’écran, différente pour chaque joueur. Rappelle-la pour la mettre à jour :

import { visits } from "/lib/storage"

on join {
    player.set_sidebar("&6Rubis", [
        "&fVisites : &e{visits(player)}",
        "&fRubis : &c{player.inventory.count("rubies:ruby")}"
    ])
}

• player.set_sidebar(title, lines) l’affiche ou la met à jour ; seul ce joueur la voit. Couleurs avec &.
• player.clear_sidebar() la retire.
• En Kotlin : player.setSidebar(title, lines) et player.clearSidebar().

Touches d'un mod

Un mod peut ajouter ses propres touches. On les déclare avec key et on réagit avec on key, qui s'exécute sur le serveur pour le joueur qui l'a pressée. e.key est l'id avec l'espace de noms du mod (dashmod:dash).

key "dash" { label: "Dash", default: "R" }
key "heal" { label: "Second wind", default: "G" }

on key(e) {
    let p = e.player
    if e.key == "dashmod:dash" && !p.has_cooldown("minecraft:feather") {
        let d = p.direction
        p.velocity = vector(d.x * 1.6, 0.35, d.z * 1.6)
        p.set_cooldown("minecraft:feather", 2)
    }
    if e.key == "dashmod:heal" { p.heal(6) }
}

Les touches apparaissent dans Options > Contrôles > Touches, dans une section au nom du mod. Les joueurs peuvent les changer et leur choix est conservé. default est un nom de touche comme "R", "G", "F6" ou "LEFT_ALT".

Les joueurs doivent avoir Crafting installé sur leur jeu pour disposer des touches. En Kotlin : ContentBuilder.key("dash", label = "Dash", default = "R") et Crafting.events.on<PlayerKeyEvent> { e -> … }.

Bon à savoir

• Les formulaires, les barres et la barre latérale sont visibles par n’importe quel client Minecraft Java 26.3, avec ou sans Crafting. Un mod serveur peut les utiliser sans que personne n’installe quoi que ce soit.
• Les titres, la barre d’action et les messages du chat sont décrits dans Le monde et les joueurs.
• Les écrans personnalisés avec ta propre disposition (menus, inventaires de machines) n’existent pas encore ; consulte la feuille de route.