La façade ov.* : référence Luau

Générée par tools/ov_apigen/apigen.py depuis data/ov/api/ov.d.luau : ne pas modifier à la main. Le guide est docs/CREATEURS.md ; dans le jeu, F1 dans le Studio montre la même chose.

Player

Player

class Player

Un joueur connecté. Ses fonctions s'appellent avec « : » (p:send).

Player.name

string

Son pseudo.

Player.uuid

string

Son identifiant stable, qui ne change pas avec le pseudo.

Player:is_online

(self): boolean

Encore connecté ?

Player:position

(self): { x: number, y: number, z: number }

Où il est, en blocs.

Player:dimension

(self): string

Le monde où il est ("ov:overworld", un monde du Multivers…).

Player:gamemode

(self): Gamemode

Son mode de jeu.

Player:role

(self): Role

Son rôle de Créateur : player, creator, admin ou owner.

Player:send

(self, text: Text): ()

Un message dans son chat, avec le balisage <gold>…</gold>.

p:send("<green>Bienvenue</green> dans l'arène !")

Player:actionbar

(self, text: Text): ()

Un texte au-dessus de la barre d'objets.

Player:title

(self, title: Text, subtitle: Text?, times: { fade_in: number?, stay: number?, fade_out: number? }?): ()

Un grand titre au centre de l'écran, et un sous-titre.

p:title("<gold>Victoire !</gold>", "3 manches gagnées")

Player:teleport

(self, to: Position, dimension: string?): boolean

Le téléporter. Demande la permission players.teleport.

p:teleport({ x = 0, y = 80, z = 0 })

Player:set_gamemode

(self, mode: Gamemode): boolean

Changer son mode de jeu. Demande la permission players.gamemode.

Player:kick

(self, reason: Text?): ()

L'expulser du serveur. Demande la permission players.kick.

Player:sound

(self, id: string, volume: number?, pitch: number?): ()

Jouer un son pour lui seul, celui du jeu ou d'un mod (frost:chime).

Player:look

(self): { yaw: number, pitch: number }

Où il regarde, en degrés (api 2).

Player:direction

(self): { x: number, y: number, z: number }

La direction de son regard, un vecteur de longueur 1 (api 2).

Player:eyes

(self): { x: number, y: number, z: number }

La position de ses yeux, d'où part un tir (api 2).

Player:locale

(self): string

La langue de son jeu, "fr_fr", "en_us"… (api 2).

Player:lang

(self): "fr" | "en"

"fr" ou "en" : la langue dans laquelle lui parler (api 2).

Player:health

(self): number

Sa vie, en demi-cœurs (api 2).

Player:max_health

(self): number

Sa vie au plus (api 2).

Player:food

(self): number

Sa faim, de 0 à 20 (api 2).

Player:set_health

(self, health: number): boolean

Changer sa vie. Demande players.state (api 2).

Player:heal

(self): boolean

Le soigner tout à fait. Demande players.state (api 2).

Player:set_food

(self, food: number): boolean

Changer sa faim. Demande players.state (api 2).

Player:held_item

(self): string?

L'objet dans sa main ("ov:compass"), ou nil (api 2).

Player:held_slot

(self): number

La case de la barre d'objets qu'il tient, de 0 à 8 (api 2).

Player:set_velocity

(self, velocity: Position): boolean

Lui donner une vitesse, en blocs par tick : un tremplin. Demande players.teleport (api 2).

p:set_velocity({ x = 0, y = 1.2, z = 0 })

Player:launch

(self, power: number?, lift: number?): boolean

Le lancer là où il regarde. Demande players.teleport (api 2).

Player:inventory

(self): { { slot: string, item: string, count: number } }

Tout ce qu'il porte : case, objet, nombre (api 2).

Player:count

(self, item: string): number

Combien il porte d'un objet (api 2).

Player:give

(self, item: string, count: number?, options: ItemOptions?): (boolean, string)

Lui donner un objet, nommé, décrit, incassable, enchanté. Demande players.inventory (api 2).

p:give("ov:iron_sword", 1, { name = "<gold>Lame</gold>", unbreakable = true })

Player:set_slot

(self, slot: string, item: string, count: number?, options: ItemOptions?): (boolean, string)

Mettre un objet dans une case : hotbar.0, armor.head… Demande players.inventory (api 2).

Player:clear_items

(self, item: string?, count: number?): boolean

Vider son inventaire, ou retirer un objet. Demande players.inventory (api 2).

Player:effect

(self, id: string, seconds: number?, amplifier: number?, hide: boolean?): boolean

Lui donner un effet (ov:speed…). Demande players.state (api 2).

Player:clear_effects

(self): boolean

Lui retirer tous ses effets. Demande players.state (api 2).

Player:set_tab

(self, header: Text?, footer: Text?): ()

Les deux lignes de sa liste des joueurs (Tab), en haut et en bas (api 2).

Bossbar

Bossbar

class Bossbar

Une barre de boss, créée par ov.bossbar.create.

Bossbar.id

string

Bossbar:set_text

(self, text: Text): ()

Changer son texte.

Bossbar:set_progress

(self, progress: number): ()

Son remplissage, de 0 à 1.

Bossbar:set_color

(self, color: "blue" | "green" | "pink" | "purple" | "red" | "white" | "yellow"): ()

Sa couleur.

Bossbar:set_style

(self, style: "progress" | "notched_6" | "notched_10" | "notched_12" | "notched_20"): ()

Son découpage en segments.

Bossbar:show_to

(self, players: { Player } | "all"): ()

Qui la voit : une liste de joueurs, ou "all".

Bossbar:remove

(self): ()

La retirer.

Match

Match

class Match

Une partie d'un mini-jeu, telle que ses règles la reçoivent (ov.minigame).

Match.id

number

Son numéro.

Match.phase

string

Où elle en est : preparing, playing ou ending.

Match:players

(self): { Player }

Ses joueurs encore en ligne.

Match:alive_players

(self): { Player }

Ceux qui ne sont pas éliminés.

Match:is_alive

(self, player: Player): boolean

Ce joueur est-il encore en course ?

Match:team_of

(self, player: Player): string?

L'équipe d'un joueur (l'id donné dans teams).

Match:dimension

(self): string

Le monde de la partie, pour placer des blocs ou téléporter.

ov.world.set_block({ x = 0, y = 64, z = 0 }, "ov:tnt", match:dimension())

Match:elapsed

(self): number

Les secondes écoulées depuis le départ.

Match:get

(self, key: string): any

Une valeur du jeu, gardée avec la partie (rechargements compris).

Match:set

(self, key: string, value: any): ()

Garder une valeur avec la partie.

Match:broadcast

(self, text: Text): ()

Un message à tous les joueurs de la partie.

Match:title

(self, title: Text, subtitle: Text?): ()

Un titre pour toute la partie.

Match:sound

(self, id: string): ()

Un son pour toute la partie.

Match:score

(self, player: Player, delta: number?): number

Ajouter au score d'un joueur ; rend le nouveau score.

Match:spawn

(self, player: Player): ()

Remettre un joueur à son point de départ.

Match:eliminate

(self, player: Player, why: string?): ()

Éliminer un joueur (une vie de moins, ou spectateur) ; la victoire suit d'elle-même.

Match:win

(self, winners: (Player | { Player } | string)?): ()

Terminer : un joueur, une liste, une équipe, ou nil.

Minigame

Minigame

class Minigame

Un mini-jeu défini par ov.minigame.define.

Minigame.id

string

Minigame:join

(self, player: Player): string?

Mettre un joueur dans la file ; rend la raison d'un refus, ou nil.

Minigame:leave

(self, player: Player): string

Sortir de la file ou de la partie.

Minigame:match_of

(self, player: Player): Match?

La partie où joue ce joueur.

Minigame:setting

(self, key: string): any

Un réglage du jeu : celui choisi par un Créateur (/<jeu> reglages), sinon celui du jeu.

Minigame:set_setting

(self, key: string, value: any): ()

Changer un réglage, comme le panneau.

Minigame:status

(self): { id: string, name: string, queue: number, playing: number, matches: number, min: number, max: number }

La file et les parties, comme le lobby les voit.

ov

ov

{ … }

Tout ce qu'un mod peut faire : la façade du jeu, version 1.

ov.api

ov.api

number

La version de la façade que le serveur parle.

ov.log

ov.log

{ … }

ov.log.info

(...any) -> ()

Une ligne dans la console du mod.

ov.log.warn

(...any) -> ()

Un avertissement, en jaune dans la console et dans le journal du serveur.

ov.log.error

(...any) -> ()

Une erreur, en rouge.

ov.events

ov.events

{ … }

ov.events.on

((name: "player_join", handler: (player: Player) -> ()) -> number) & ((name: "player_leave", handler: (player: Player) -> ()) -> number) & ((name: "chat", handler: (player: Player, message: string) -> (boolean | string)?) -> number) & ((name: "tick", handler: (tick: number) -> ()) -> number) & ((name: "block_break", handler: (player: Player, at: Place, block: string) -> boolean?) -> number) & ((name: "block_use", handler: (player: Player, at: Place, block: string, item: string?) -> boolean?) -> number) & ((name: "entity_use", handler: (player: Player, entity: number, kind: string) -> boolean?) -> number) & ((name: "player_death", handler: (player: Player, info: DeathInfo) -> ()) -> number) & ((name: "player_damage", handler: (player: Player, info: DamageInfo) -> (boolean | number)?) -> number) & ((name: "player_respawn", handler: (player: Player) -> ()) -> number) & ((name: "block_place", handler: (player: Player, at: Place, block: string, item: string) -> boolean?) -> number) & ((name: "item_use", handler: (player: Player, item: string, count: number) -> boolean?) -> number) & ((name: "block_tick", handler: (kind: "random" | "scheduled" | "neighbour", at: Place, block: string) -> ()) -> number) & ((name: "item_drop", handler: (player: Player, item: string, count: number) -> boolean?) -> number) & ((name: "region_enter", handler: (player: Player, region: string) -> ()) -> number) & ((name: "region_leave", handler: (player: Player, region: string) -> ()) -> number) & ((name: "explosion", handler: (at: Place, blocks: number) -> boolean?) -> number) & ((name: "village_founded", handler: (village: Village) -> ()) -> number) & ((name: "villager_born", handler: (child: Villager, village: number?) -> ()) -> number) & ((name: "villager_died", handler: (villager: Villager, village: number?) -> ()) -> number) & ((name: "feud", handler: (village: Village, other: Village, feud: string) -> ()) -> number) & ((name: "quest_opened", handler: (village: Village, quest: { id: number, kind: string, item: string, need: number }) -> ()) -> number) & ((name: "house_built", handler: (village: Village) -> ()) -> number)

Écouter un événement. Rendre false depuis block_break, block_use, block_place, entity_use, item_use, item_drop, player_damage, explosion ou chat l'annule ; un nombre rendu par player_damage change les dégâts. Rend un jeton pour ov.events.off.

ov.events.on("player_join", function(p) p:send("Salut " .. p.name) end)

ov.events.off

(token: number) -> boolean

Ne plus écouter (avec le jeton rendu par on).

ov.commands

ov.commands

{ … }

ov.commands.register

(spec: CommandSpec) -> ()

Ajouter une commande au serveur. Ce que run rend est dit au joueur.

ov.commands.register({ name = "salut", run = function(p) return "Salut " .. p.name end })

ov.players

ov.players

{ … }

ov.players.all

() -> { Player }

Les joueurs en ligne.

for _, p in ov.players.all() do p:send("Hop") end

ov.players.get

(who: string | Player) -> Player?

Un joueur par son pseudo ou son uuid, ou nil s'il n'est pas là.

ov.players.count

() -> number

Combien de joueurs sont en ligne.

ov.players.raycast

(from: Position, direction: Position, reach: number?, dimension: string?, except: (Player | string)?) -> (Player?, number?)

Le joueur le plus proche qu'un rayon touche avant un bloc, et à quelle distance (api 2).

local hit = ov.players.raycast(p:eyes(), p:direction(), 50, p:dimension(), p)

ov.world

ov.world

{ … }

ov.world.state

(pos: Position, dimension: string?) -> string?

Un bloc avec ses propriétés : "frost:crusher[active=true]" (api 4).

ov.world.schedule

(pos: Position, ticks: number, dimension: string?) -> boolean

Un tick pour le bloc vivant du mod à cet endroit, dans tant de ticks (world.write, api 4).

ov.world.block

(at: Position, dimension: string?) -> string?

Le bloc à un endroit ("ov:stone", états compris), ou nil si le chunk n'est pas chargé.

ov.world.set_block

(at: Position, block: string, dimension: string?) -> boolean

Poser un bloc. Demande la permission world.write.

ov.world.set_block({ x = 0, y = 64, z = 0 }, "ov:gold_block")

ov.world.fill

(from: Position, to: Position, block: string, dimension: string?) -> (boolean, string)

Remplir une boîte d'un bloc. Demande world.write.

ov.world.place_structure

(id: string, at: Position, options: { rotation: number? }?, dimension: string?) -> (boolean, string)

Coller une structure du jeu ou du mod (content/structures). Demande world.write.

ov.world.place_structure("frost:tower", { x = 10, y = 64, z = 0 }, { rotation = 1 })

ov.world.sound

(id: string, at: Position, volume: number?, pitch: number?, dimension: string?) -> ()

Un son à un endroit, pour tous ceux qui l'entendent.

ov.world.raycast

(from: Position, direction: Position, reach: number?, dimension: string?) -> { x: number, y: number, z: number, block: string, distance: number }?

Le premier bloc qu'un rayon rencontre, ou nil (api 2).

ov.regions

ov.regions

{ … }

ov.regions.define

(id: string, from: Position, to: Position, dimension: string?) -> ()

Une boîte surveillée : y entrer et en sortir arrivent en region_enter et region_leave (api 2).

ov.regions.define("portail_rush", { x = 10, y = 64, z = 0 }, { x = 12, y = 68, z = 1 })

ov.regions.remove

(id: string) -> ()

Ne plus surveiller une boîte (api 2).

ov.regions.inside

(who: Player | string) -> { string }

Les boîtes où un joueur se tient (api 2).

ov.i18n

ov.i18n

{ … }

ov.i18n.define

(texts: { [string]: { fr: string?, en: string? } }) -> ()

Des textes en deux langues, { clé = { fr = …, en = … } } (api 2).

ov.i18n.define({ hello = { fr = "Salut %s", en = "Hi %s" } })

ov.i18n.t

(who: (Player | string)?, key: string, ...any) -> string

Le texte d'une clé dans la langue du joueur, formaté (api 2).

p:send(ov.i18n.t(p, "hello", p.name))

ov.server

ov.server

{ … }

ov.server.run

(command: string) -> (boolean, string)

Lancer une commande comme la console. Demande la permission server.command.

ov.server.broadcast

(text: Text) -> ()

Un message à tous les joueurs.

ov.server.tick

() -> number

Le tick du serveur (20 par seconde).

ov.timer

ov.timer

{ … }

ov.timer.after

(ticks: number, fn: () -> ()) -> number

Appeler fn dans n ticks. Rend un id pour cancel.

ov.timer.every

(ticks: number, fn: () -> ()) -> number

Appeler fn tous les n ticks.

ov.timer.cancel

(id: number) -> boolean

Arrêter un minuteur.

ov.after

ov.after

(ticks: number, fn: () -> ()) -> number

Appeler fn dans n ticks (comme ov.timer.after).

ov.after(20 * 5, function() ov.server.broadcast("5 secondes !") end)

ov.every

ov.every

(ticks: number, fn: () -> ()) -> number

Appeler fn tous les n ticks (comme ov.timer.every).

ov.cancel

ov.cancel

(id: number) -> boolean

Arrêter un minuteur.

ov.wait

ov.wait

(ticks: number?) -> ()

Attendre n ticks sans bloquer le jeu (1 par défaut). Pour étaler un gros travail.

for i = 1, 100 do ov.world.set_block({ x = i, y = 64, z = 0 }, "ov:stone") ov.wait() end

ov.spawn

ov.spawn

<A...>(fn: (A...) -> (), A...) -> ()

Lancer fn à part : elle peut attendre sans retenir celui qui l'a lancée.

ov.persist

ov.persist

<T>(name: string, default: T?) -> T

Une table qui survit aux rechargements et aux redémarrages, sauvegardée avec le monde.

local scores = ov.persist("scores", { best = 0 })

ov.storage

ov.storage

Store & { player: (who: string | Player) -> Store }

Un stockage clé-valeur du mod, et par joueur (ov.storage.player(p)).

ov.random

ov.random

{ … }

ov.random.int

(min: number, max: number) -> number

Un entier entre min et max compris. Le même tirage sur toutes les machines.

ov.random.float

() -> number

Un nombre entre 0 et 1.

ov.random.pick

<T>(list: { T }) -> T?

Un élément au hasard d'une liste.

ov.random.shuffle

<T>(list: { T }) -> { T }

La liste mélangée (une copie).

ov.realtime

ov.realtime

{ … }

ov.realtime.now

() -> { year: number, month: number, day: number, hour: number, minute: number, second: number, weekday: number }

La date et l'heure réelles du serveur, pour un événement du samedi soir.

ov.realtime.unix

() -> number

Les secondes depuis 1970.

ov.bus

ov.bus

{ … }

ov.bus.emit

(name: string, data: any?) -> ()

Prévenir les autres mods du serveur.

ov.bus.on

(name: string, handler: (data: any, from: string) -> ()) -> number

Écouter ce que les autres mods annoncent.

ov.mod

ov.mod

{ … }

ov.mod.id

string

L'identifiant du mod.

ov.mod.version

string

Sa version (mod.json).

ov.mod.on_reload

(fn: () -> ()) -> ()

Appelée après chaque rechargement réussi.

ov.scoreboard

ov.scoreboard

{ … }

ov.scoreboard.objective

(name: string, title: Text?) -> boolean

Créer un objectif de score, ou changer son titre.

ov.scoreboard.remove

(name: string) -> boolean

Supprimer un objectif.

ov.scoreboard.show

(slot: "sidebar" | "list" | "belowName", name: string?) -> boolean

Afficher un objectif : sur le côté, dans la liste des joueurs, sous les pseudos.

ov.scoreboard.set

(name: string, who: string | Player, value: number) -> boolean

Fixer un score.

ov.scoreboard.get

(name: string, who: string | Player) -> number?

Lire un score.

ov.scoreboard.add

(name: string, who: string | Player, amount: number?) -> number

Ajouter à un score (1 par défaut) et rendre le nouveau.

ov.scoreboard.reset

(name: string, who: string | Player) -> ()

Effacer un score.

ov.scoreboard.sidebar

(title: Text?, lines: { string }?) -> ()

La barre latérale d'un jeu en un appel : un titre, des lignes. Sans argument, elle disparaît.

ov.scoreboard.sidebar("<aqua>Sol fondant</aqua>", { "Joueurs : 4", "Manche 2" })

ov.teams

ov.teams

{ … }

ov.teams.create

(name: string, options: { color: string?, prefix: Text?, friendly_fire: boolean? }?) -> boolean

Créer une équipe : une couleur de pseudo, un préfixe, le tir ami.

ov.teams.remove

(name: string) -> boolean

Supprimer une équipe.

ov.teams.join

(name: string, who: string | Player) -> boolean

Mettre un joueur dans une équipe.

ov.teams.leave

(who: string | Player) -> boolean

Le sortir de son équipe.

ov.teams.of

(who: string | Player) -> string?

Son équipe, ou nil.

ov.entities

ov.entities

{ … }

ov.entities.spawn

(kind: string, at: Position, dimension: string?) -> number?

Faire apparaître une entité. Rend son id. Demande world.write.

ov.entities.hologram

(at: Position, text: Text, dimension: string?) -> number?

Un texte flottant dans le monde. Demande world.write.

ov.entities.hologram({ x = 0, y = 70, z = 0 }, "<gold>Meilleur score : 42</gold>")

ov.entities.set_text

(id: number, text: Text) -> boolean

Changer le texte d'un hologramme.

ov.entities.remove

(id: number) -> boolean

Retirer une entité.

ov.villagers

ov.villagers

{ … }

ov.villagers.villages

() -> { Village }

Tous les villages du monde : nom, palier, chef, quêtes ouvertes, voisins (api 3). Une copie, en lecture seule.

for _, v in ov.villagers.villages() do ov.log.info(v.name, v.people) end

ov.villagers.village_at

(at: Position) -> Village?

Le village à cet endroit du monde principal, ou nil (api 3).

ov.villagers.near

(at: Position, radius: number?, most: number?) -> { Villager }

Les villageois proches, le plus près d'abord : rayon 16 par défaut et au plus 64, 16 rendus par défaut et au plus 64 (api 3).

for _, v in ov.villagers.near(p:position(), 32) do p:send(v.name .. " : " .. v.profession) end

ov.villagers.think

(id: number, thought: string) -> boolean

Donner une pensée, du jeu ou d'un mod, à un villageois (son id d'entité) : elle colore son humeur pour ses heures. Demande world.write (api 3).

ov.villagers.think(v.id, "frost:first_snow")

ov.bossbar

ov.bossbar

{ … }

ov.bossbar.create

(id: string, text: Text?, options: { color: string?, style: string?, progress: number?, players: ({ Player } | "all")? }?) -> Bossbar

Une barre de boss en haut de l'écran.

local bar = ov.bossbar.create("timer", "Temps", { color = "red", progress = 1, players = "all" })

ov.particles

ov.particles

{ … }

ov.particles.spawn

(kind: string, at: Position, options: { count: number?, spread: number?, speed: number?, player: (Player | string)? }?, dimension: string?) -> ()

Des particules à un endroit, pour tous ou un seul joueur.

ov.worlds

ov.worlds

{ … }

ov.worlds.list

() -> { { name: string, phase: string } }

Les mondes du serveur et leur état.

ov.worlds.phase

(name: string) -> string?

L'état d'un monde : active, loading, unloaded…

ov.worlds.clone

(from: string, to: string) -> (boolean, string)

Copier un monde. Demande worlds.manage.

ov.worlds.create

(name: string, kind: ("normal" | "flat" | "void" | "emberdeep" | "starfall")?, options: { seed: number? }?) -> (boolean, string)

Créer un monde : normal, plat, vide, emberdeep ou starfall. Demande worlds.manage.

ov.worlds.create("arene_1", "void", { seed = 42 })

ov.worlds.load

(name: string) -> (boolean, string)

Charger un monde.

ov.worlds.remove

(name: string) -> (boolean, string)

Supprimer un monde. Demande worlds.manage.

ov.worlds.key

(name: string) -> string

L'identifiant d'un monde pour les autres fonctions ("ov:arene_1").

ov.worlds.set

(name: string, property: string, value: any) -> (boolean, string)

Changer une propriété d'un monde (pvp, combat legacy, gamemode…). Demande worlds.manage (api 2).

ov.worlds.set("arene_1", "combat", "legacy")

ov.worlds.gamerule

(name: string, rule: string, value: any) -> boolean

Changer une règle de jeu d'un monde. Demande worlds.manage (api 2).

ov.worlds.border

(name: string, size: number, options: { center: { x: number, z: number }?, seconds: number? }?) -> boolean

La bordure d'un monde : sa taille, son centre, en combien de secondes. Demande worlds.manage (api 2).

ov.net

ov.net

{ … }

ov.net.send

(player: Player | string, name: string, data: any?) -> ()

Envoyer un message à la moitié client du mod, chez un joueur.

ov.net.broadcast

(name: string, data: any?) -> ()

Le même message à tous les joueurs.

ov.net.on

(name: string, handler: (player: Player, data: any) -> ()) -> number

Écouter ce que la moitié client envoie.

ov.ui

ov.ui

{ … }

ov.ui.show

(player: Player | string, screen: string, tree: Widget) -> ()

Montrer un menu à un joueur, avec l'allure des menus du jeu.

ov.ui.show(p, "shop", ov.ui.panel("Boutique", { ov.ui.button("buy", "Acheter") }))

ov.ui.close

(player: Player | string, screen: string) -> ()

Fermer un menu.

ov.ui.hud

(player: Player | string, id: string, tree: Widget?) -> ()

Un morceau d'affichage permanent à droite de l'écran ; nil l'enlève.

ov.ui.on

(screen: string, handler: (player: Player, event: UiEvent) -> ()) -> number

Écouter les clics d'un menu.

ov.ui.panel

(title: string, children: { Widget }, options: { [string]: any }?) -> Widget

Un panneau avec un titre ; options : style = "medium" | "wide" (plus large), detail = un sous-titre.

ov.ui.panel("Jeux", { ov.ui.text("…") }, { style = "wide", detail = "12 jeux" })

ov.ui.column

(children: { Widget }, options: { [string]: any }?) -> Widget

Des éléments les uns sous les autres.

ov.ui.row

(children: { Widget }, options: { style: string? }?) -> Widget

Des éléments côte à côte : un objet, une icône, une pastille gardent leur taille, le reste se partage la largeur ; style = "end" ou "center" pour les aligner.

ov.ui.grid

(columns: number, children: { Widget }) -> Widget

Une grille de n colonnes.

ov.ui.text

(text: string, style: string?) -> Widget

Un texte ; style en mots : une taille (hero, h2, title, bold, body, small, muted, label, overline), une teinte (accent, gold, green, red, purple, aqua, #rrggbb), center.

ov.ui.text("Victoire", "h2 gold")

ov.ui.title

(text: string) -> Widget

Un titre.

ov.ui.button

(id: string, label: string, options: { style: string?, enabled: boolean? }?) -> Widget

Un bouton ; son clic arrive dans ov.ui.on avec son id.

ov.ui.toggle

(id: string, label: string, on: boolean?) -> Widget

Un interrupteur.

ov.ui.slider

(id: string, label: string, min: number, max: number, value: number?, step: number?) -> Widget

Un curseur entre min et max.

ov.ui.input

(id: string, placeholder: string?, value: string?) -> Widget

Un champ de texte.

ov.ui.progress

(value: number, label: string?) -> Widget

Une barre d'avancement (0 à 1).

ov.ui.item

(item: string, count: number?, size: number?) -> Widget

Un objet, dessiné comme dans l'inventaire, sa quantité et sa taille en dp (32 par défaut).

ov.ui.card

(id: string?, children: { Widget }, options: { style: string?, on: boolean?, detail: string? }?) -> Widget

Une tuile : ses enfants dedans, cliquable en entier si elle a un id ; options : style = une teinte, on = sélectionnée, detail = une infobulle.

ov.ui.card("play:rush", { ov.ui.text("Rush", "title") }, { style = "red" })

ov.ui.badge

(text: string, tone: string?) -> Widget

Un mot court dans une pastille colorée.

ov.ui.badge("3 en jeu", "green")

ov.ui.icon

(name: string, tone: string?, size: number?) -> Widget

Une icône du jeu par son nom (trophy, crown, sword, shield, users, play, sparkles…), une teinte, une taille.

ov.ui.spacer

(size: number?) -> Widget

Un espace vide.

ov.ui.divider

() -> Widget

Un trait de séparation.

ov.stats

ov.stats

{ … }

ov.stats.add

(who: string | Player, key: string, amount: number?) -> number

Ajouter à une statistique d'un joueur (1 par défaut) ; rend la nouvelle valeur. Sans « : », la clé est celle du mod (wins → sol_fondant:wins).

ov.stats.add(p, "wins")

ov.stats.set

(who: string | Player, key: string, value: number) -> ()

Fixer une statistique (un meilleur temps).

ov.stats.get

(who: string | Player, key: string) -> number

Lire une statistique, de ce mod ou d'un autre (« sol_fondant:wins »).

ov.stats.top

(key: string, count: number?, lowest_first: boolean?) -> { { uuid: string, name: string, value: number } }

Les meilleurs d'une statistique ; lowest_first pour un temps.

ov.economy

ov.economy

{ … }

ov.economy.currency

string

Le nom de la monnaie.

ov.economy.balance

(who: string | Player) -> number

Les pièces d'un joueur, les mêmes dans tous les jeux du serveur.

ov.economy.give

(who: string | Player, amount: number, reason: string?) -> number

Donner des pièces ; rend le nouveau solde.

ov.economy.take

(who: string | Player, amount: number, reason: string?) -> boolean

Prendre des pièces s'il en a assez ; rend true si c'est fait.

if ov.economy.take(p, 100, "chapeau") then p:send("Acheté !") end

ov.minigame

ov.minigame

{ … }

ov.minigame.define

(spec: MinigameSpec) -> Minigame

Définir un mini-jeu : ses règles en entrée, toute sa vie en sortie (file, compte à rebours, arène, victoire, stats, menu, commande).

ov.minigame.define({ id = "sol_fondant", name = "Sol fondant", map = { build = function(m) end }, void_y = 40 })

ov.lobby

ov.lobby

{ … }

ov.lobby.setup

(options: { spawn: Position?, dimension: string?, radius: number?, title: string? }?) -> ()

Faire d'un endroit le hub du serveur : arrivée, protection, /hub, /jouer, /groupe.

ov.lobby.setup({ spawn = { x = 0, y = 100, z = 0 }, title = "Mon réseau" })

ov.lobby.configure

(options: { spawn: Position?, dimension: string?, radius: number?, title: string? }?) -> ()

Déplacer ou renommer le hub, sans rien réinstaller.

ov.lobby.selector

(game: string, at: Position, dimension: string?) -> ()

Un personnage qui envoie vers un jeu d'un clic droit, avec sa file au-dessus.

ov.lobby.play

(player: Player, game: string) -> ()

Envoyer un joueur, et son groupe, dans la file d'un jeu.

ov.lobby.games

() -> { { id: string, name: string, description: string, queue: number, playing: number, min: number, max: number } }

Les jeux du serveur et leurs files.

ov.moderation

ov.moderation

{ … }

ov.moderation.setup

() -> ()

Les commandes de modération : /mute, /unmute, /avertir, /signaler, /moderation.

ov.moderation.is_muted

(player: Player) -> boolean

Ce joueur est-il muet en ce moment ?

ov.moderation.flag

(player: Player, reason: string) -> ()

Noter ce qu'un jeu a vu d'étrange (un déplacement trop rapide), et prévenir les modérateurs en ligne.

ov.moderation.flag(p, "va plus vite que le jeu ne le permet")

ov.moderation.entries

(name: string?, count: number?) -> { { kind: string, who: string, by: string, reason: string, at: number } }

Le journal, le plus récent d'abord ; pour un joueur si un nom est donné.

ov.blocks

ov.blocks

{ … }

ov.blocks.define

(name: string, spec: { data: boolean?, on_place: ((b: any, player: Player, item: string) -> boolean?)?, on_use: ((b: any, player: Player, item: string?) -> boolean?)?, on_break: ((b: any, player: Player) -> boolean?)?, on_random_tick: ((b: any) -> ())?, on_tick: ((b: any) -> ())?, on_neighbour: ((b: any) -> ())? }) -> ()

Ce que fait un bloc vivant du mod (content/blocks.json : random_ticks, neighbour_updates, data) : posé, utilisé, cassé, un tick aléatoire ou programmé, un voisin qui change. b a x, y, z, dimension, name, b:state(), b:get(prop), b:set({prop = valeur}), b:schedule(ticks) et b.data (api 4).

ov.blocks.define("crusher", { data = true, on_use = function(b, p) b:set({ active = "true" }); b:schedule(40) end, on_tick = function(b) b:set({ active = "false" }) end })

ov.items

ov.items

{ … }

ov.items.define

(name: string, spec: { on_use: ((player: Player, item: string, count: number) -> boolean?)?, on_hit: ((attacker: Player, victim: Player, info: DamageInfo) -> (boolean | number)?)?, on_mine: ((player: Player, at: Place, block: string) -> boolean?)? }) -> ()

Ce que fait un objet du mod (content/items.json) : utilisé en l'air, frappant un joueur, cassant un bloc. Rendre false annule ; on_hit peut rendre les nouveaux dégâts (api 4).

ov.items.define("frost_wand", { on_use = function(p) p:send("Brrr !") end })

ov.leaderboards

ov.leaderboards

{ … }

ov.leaderboards.show

(id: string, at: Position, stat: string, options: { title: string?, count: number?, lowest_first: boolean?, format: "time"?, dimension: string? }?) -> ()

Un classement flottant, mis à jour toutes les dix secondes.

ov.leaderboards.show("sol_fondant", { x = 0, y = 102, z = 5 }, "sol_fondant:wins", { title = "Sol fondant — victoires" })

ov.leaderboards.remove

(id: string) -> ()

Retirer un classement.

ov.arenas

ov.arenas

{ … }

ov.arenas.create

(template: string) -> string

Une copie jetable d'un monde modèle, pour une partie. Rend son nom.

local arena = ov.arenas.create("sol_fondant_map")

ov.arenas.ready

(name: string) -> boolean

L'arène est-elle prête ?

ov.arenas.await

(name: string, timeout: number?) -> boolean

Attendre qu'elle soit prête (dans un handler).

ov.arenas.destroy

(name: string) -> (boolean, string)

Détruire l'arène.

ov.arenas.copy

(folder: string) -> string

Une arène copiée d'un dossier modèle voisin du monde ("maps/ldc_foret") : les cartes n'occupent pas de place parmi les 32 mondes. Demande worlds.manage (api 2).