Fonctions intégrées

Loreline inclut une collection de fonctions natives que vous pouvez appeler depuis des expressions, de l'interpolation de texte ou comme instructions autonomes.

Nouveau sur Loreline ? Commencez par le Guide d'écriture pour apprendre les beats, les choix et la gestion de l'état. Revenez ici quand vous aurez besoin de détails sur une fonction spécifique.

Référence rapide

Catégorie	Fonctions
Math	`floor` `ceil` `round` `abs` `min` `max` `clamp` `pow`
Random	`random` `chance` `seed_random` `random_float`
Timing	`wait`
Conversion de type	`float` `string` `bool`
String	`string_upper` `string_lower` `string_contains` `string_replace` `string_split` `string_trim` `string_index` `string_sub` `string_starts` `string_ends` `string_repeat` `string_length`
Text	`plural` (+ syntaxe pipe)
Array	`array_add` `array_pop` `array_prepend` `array_shift` `array_remove` `array_index` `array_has` `array_sort` `array_reverse` `array_join` `array_pick` `array_shuffle` `array_copy` `array_length`
Map	`map_keys` `map_has` `map_get` `map_set` `map_remove` `map_copy` `map_length`
État du récit	`current_beat` `has_beat` `beat_visits`
Introspection des choix	`choices` `choices_all` `choices_disabled`

Math

Fonction	Description
`floor(n)`	Arrondit un nombre vers le bas à l'entier le plus proche. `floor(3.7)` renvoie `3`.
`ceil(n)`	Arrondit un nombre vers le haut à l'entier le plus proche. `ceil(3.2)` renvoie `4`.
`round(n)`	Arrondit un nombre à l'entier le plus proche. `round(3.5)` renvoie `4`.
`abs(n)`	Renvoie la valeur absolue d'un nombre. `abs(-5)` renvoie `5`.
`min(a, b)`	Renvoie la plus petite des deux valeurs. `min(3, 7)` renvoie `3`.
`max(a, b)`	Renvoie la plus grande des deux valeurs. `max(3, 7)` renvoie `7`.
`clamp(valeur, bas, haut)`	Contraint une valeur à rester dans un intervalle donné. `clamp(10, 0, 5)` renvoie `5`.
`pow(base, exp)`	Élève un nombre à une puissance. `pow(2, 3)` renvoie `8`.

sante = clamp(sante + soin, 0, santeMax)
degats = min(puissanceAttaque, santeEnnemi)

Random

Fonction	Description
`random(min, max)`	Renvoie un nombre entier aléatoire entre `min` et `max` (inclus).
`chance(n)`	Renvoie `true` avec une probabilité de 1 sur n. `chance(3)` a environ 33 % de chances d'être vrai.
`seed_random(graine)`	Définit la graine (seed) du générateur aléatoire pour des résultats reproductibles. Après cet appel, toutes les fonctions aléatoires produisent la même séquence à chaque fois.
`random_float(min, max)`	Renvoie un nombre décimal aléatoire de `min` jusqu'à (mais sans inclure) `max`.

lancerDe = random(1, 6)
Tu as obtenu un $lancerDe !

if chance(4)
  Tu trouves une gemme rare par terre !

Timing

Fonction	Description
`wait(secondes)`	Met le script en pause pendant le nombre de secondes indiqué avant de continuer.

Le sol commence à trembler...
wait(2)
Un énorme rocher fracasse le mur !

Conversion de type

Fonction	Description
`float(valeur)`	Convertit une valeur en nombre. Les chaînes comme `"3.14"` sont analysées. Renvoie `0` si la conversion échoue.
`string(valeur)`	Convertit n'importe quelle valeur en texte. `string(42)` renvoie `"42"`.
`bool(valeur)`	Convertit une valeur en `true` ou `false`. Zéro, les chaînes vides, les tableaux vides et `null` sont faux, tout le reste est vrai.

String

Fonction	Description
`string_upper(texte)`	Convertit toutes les lettres en majuscules. `string_upper("bonjour")` renvoie `"BONJOUR"`.
`string_lower(texte)`	Convertit toutes les lettres en minuscules. `string_lower("BONJOUR")` renvoie `"bonjour"`.
`string_contains(texte, recherche)`	Vérifie si une chaîne contient un morceau de texte. `string_contains("bonjour le monde", "monde")` renvoie `true`.
`string_replace(texte, ancien, nouveau)`	Remplace chaque occurrence d'un morceau de texte. `string_replace("bonjour le monde", "monde", "tous")` renvoie `"bonjour le tous"`.
`string_split(texte, separateur)`	Découpe une chaîne en tableau. `string_split("a,b,c", ",")` renvoie `"a", "b", "c"]`.
`string_trim(texte)`	Supprime les espaces au début et à la fin. `string_trim(" bonjour ")` renvoie `"bonjour"`.
`string_index(texte, recherche)`	Trouve la position de la première occurrence d'un texte (à partir de `0`), ou `-1` si non trouvé. `string_index("bonjour", "nj")` renvoie `2`.
`string_sub(texte, debut, longueur)`	Extrait une portion d'une chaîne. `string_sub("ABCDEF", 0, 3)` renvoie `"ABC"`.
`string_starts(texte, prefixe)`	Vérifie si une chaîne commence par le préfixe donné. `string_starts("bonjour le monde", "bonjour")` renvoie `true`.
`string_ends(texte, suffixe)`	Vérifie si une chaîne se termine par le suffixe donné. `string_ends("bonjour le monde", "monde")` renvoie `true`.
`string_repeat(texte, nombre)`	Répète le texte le nombre de fois indiqué. `string_repeat("ab", 3)` renvoie `"ababab"`.
`string_length(texte)`	Renvoie le nombre de caractères dans une chaîne. `string_length("bonjour")` renvoie `7`.

if string_contains(message, "aide")
  Quelqu'un a besoin d'aide !

mots = string_split(phrase, " ")
La phrase contient $array_length(mots) mots.

if string_starts(nom, "Sire")
  Tu t'inclines devant le chevalier.

Toutes les fonctions string_ supportent aussi la notation par point : supprimez le préfixe string_ et appelez la fonction directement sur la valeur. Par exemple, string_upper(nom) peut s'écrire nom.upper(), et string_contains(msg, "aide") s'écrire msg.contains("aide"). Cela fonctionne aussi sur les littéraux et peut être chaîné :

titre = "bonjour".upper()
salutation = "  bonjour le monde  ".trim().upper()

Text

Fonction	Description
`plural(nombre, singulier, pluriel)`	Renvoie `singulier` quand nombre vaut 1, `pluriel` sinon. Fonctionne pour les pluriels de noms et la conjugaison de verbes dans n'importe quelle langue.

objets = 3
Tu as trouvé $objets $plural(objets, "pièce", "pièces").
// "Tu as trouvé 3 pièces."

messages = 1
Tu as $plural(messages, "un nouveau", "des nouveaux") $plural(messages, "message", "messages").
// "Tu as un nouveau message."

Il existe aussi une syntaxe abrégée avec le pipe pour le cas courant. Après une $expression numérique, écrivez singulier|pluriel et la résolution se fait automatiquement :

objets = 3
Tu as trouvé $objets pièce|pièces.
// "Tu as trouvé 3 pièces."

boites = 1
$boites (boîte a été trouvée|boîtes ont été trouvées).
// "1 boîte a été trouvée."

Utilisez des parenthèses pour les alternatives à plusieurs mots. Échappez avec | si vous avez besoin d'un caractère pipe littéral. La syntaxe pipe ne s'active qu'après une expression numérique. Sinon | est conservé tel quel.

Array

Fonction	Description
`array_add(tableau, valeur)`	Ajoute un élément à la fin d'un tableau.
`array_pop(tableau)`	Retire et renvoie le dernier élément. Renvoie `null` si le tableau est vide.
`array_prepend(tableau, valeur)`	Ajoute un élément au début d'un tableau.
`array_shift(tableau)`	Retire et renvoie le premier élément. Renvoie `null` si le tableau est vide.
`array_remove(tableau, valeur)`	Trouve et retire la première occurrence d'une valeur. Renvoie `true` si trouvée.
`array_index(tableau, valeur)`	Trouve la position d'une valeur (à partir de `0`), ou `-1` si non trouvée.
`array_has(tableau, valeur)`	Vérifie si un tableau contient une valeur donnée.
`array_sort(tableau)`	Trie le tableau sur place et le renvoie.
`array_reverse(tableau)`	Inverse le tableau sur place et le renvoie.
`array_join(tableau, separateur)`	Combine tous les éléments en une chaîne. `array_join(["a", "b", "c"], ", ")` renvoie `"a, b, c"`.
`array_pick(tableau)`	Renvoie un élément au hasard. Affecté par `seed_random`.
`array_shuffle(tableau)`	Mélange le tableau sur place et le renvoie. Affecté par `seed_random`.
`array_copy(tableau)`	Renvoie une copie superficielle du tableau.
`array_length(tableau)`	Renvoie le nombre d'éléments dans un tableau.

objets = ["épée", "bouclier"]
array_add(objets, "potion")

if array_has(inventaire, "clé dorée")
  Tu ouvres la porte ancienne.

salutations = ["Bonjour !", "Salut !", "Bienvenue !"]
barista: $array_pick(salutations)

Toutes les fonctions array_ supportent aussi la notation par point. Par exemple, array_add(objets, "épée") peut s'écrire objets.add("épée"), et array_join(objets, ", ") s'écrire objets.join(", "). Cela fonctionne aussi sur les littéraux :

trie = [3, 1, 2].sort().join(", ")   // "1, 2, 3"

Map

Fonction	Description
`map_keys(dictionnaire)`	Renvoie un tableau de toutes les clés du dictionnaire.
`map_has(dictionnaire, cle)`	Vérifie si une clé existe dans le dictionnaire.
`map_get(dictionnaire, cle)`	Obtient la valeur associée à une clé. Renvoie `null` si la clé n'existe pas.
`map_set(dictionnaire, cle, valeur)`	Stocke une valeur sous une clé.
`map_remove(dictionnaire, cle)`	Supprime une clé et sa valeur. Renvoie `true` si la clé existait.
`map_copy(dictionnaire)`	Renvoie une copie superficielle du dictionnaire.
`map_length(dictionnaire)`	Renvoie le nombre de clés dans un dictionnaire.

map_set(comptesInventaire, "fleches", 20)
nombre = map_get(comptesInventaire, "fleches")
Il te reste $nombre flèches.

Toutes les fonctions map_ supportent aussi la notation par point. Par exemple, map_get(stats, "pv") peut s'écrire stats.get("pv") :

cles = { nom: "Alice", age: 30 }.keys()

État du récit

Fonction	Description
`current_beat()`	Renvoie une référence au beat en cours d'exécution. Utilisé dans du texte (`current_beat()`), il affiche le nom du beat. Peut être comparé à une chaîne : `current_beat() == "MonBeat"`.
`has_beat(nom)`	Vérifie si un beat portant le nom donné existe et est accessible depuis votre position actuelle. Accepte une chaîne (`has_beat("MonBeat")`) ou une référence de beat (`has_beat(MonBeat)`).
`beat_visits()`	Renvoie le nombre de fois que le beat courant a été visité.
`beat_visits(nom)`	Renvoie le nombre de fois que le beat nommé a été visité. Accepte une chaîne (`beat_visits("MonBeat")`) ou une référence de beat (`beat_visits(MonBeat)`).

if has_beat("FinSecrete")
  choice
    Tenter le chemin secret -> FinSecrete

Les noms de beats peuvent être utilisés directement comme références dans les expressions. Cela permet la notation par point pour les fonctions de beat. Par exemple, beat_visits(CoffeeShop) peut aussi s'écrire CoffeeShop.visits() :

beat CoffeeShop
  if beat_visits() == 1
    Bienvenue au coffee shop !
  else
    Bon retour ! Vous êtes venu $CoffeeShop.visits() fois.

Introspection des choix

Fonction	Description
`choices()`	Renvoie un tableau du texte de toutes les options de choix actuellement activées.
`choices_all()`	Renvoie un tableau du texte de toutes les options de choix, qu'elles soient activées ou désactivées.
`choices_disabled()`	Renvoie un tableau du texte de toutes les options de choix désactivées.

Ces fonctions sont utiles à l'intérieur du corps d'une option de choix pour inspecter quelles options étaient disponibles quand le joueur a fait son choix :

choice
  Café
    if choices().length() > 2
      barista: Tant de choix aujourd'hui, et tu as pris un café !
    else
      barista: Menu réduit aujourd'hui, bon choix.
  Thé
    barista: Un classique.
  Jus de fruit if aJusDeFruit
    barista: Pressé du jour !

On peut aussi utiliser choices() dans une condition d'option de choix. Ici, l'option de repli n'apparaît que quand toutes les options préfixées par - ont été choisies lors de visites précédentes :

choice
  - Café
    barista: Voici ton café !
  - Thé
    barista: Ça arrive !
  - Jus de fruit
    barista: Pressé du jour !
  Il te reste quelque chose ? if !choices()
    barista: Désolé, il n'y a plus rien. Reviens demain !

Voir aussi

Introduction →

Ce qu'est Loreline, ce qu'il fait, et un premier aperçu de sa syntaxe.

Guide d’écriture →

Apprenez le langage de script Loreline depuis zéro.

Scripter des fonctions →

Référence de la syntaxe de script utilisée dans les fonctions Loreline.

Localisation →

Comment traduire des scripts Loreline en plusieurs langues.