Les relations ink – Partie 1 : les utiliser

mes-relations.ink

Voici les relations qu’on peut avoir dans ce jeu :

LIST Relations = Contient, EstEn, EstDeForme, Réclame, Possède, Connait

Et les choses auxquelles elles s’appliquent :

LIST Personnes = Hervé, Sandrine
LIST Objets = Transmuteur, BolGauche, BolCentral, BolDroit, Pièce, Dé, Bille
LIST Matières = Cuivre, Terre, Fer, Verre, Argile, Bois
LIST Formes = Cercle, Carré, Triangle

Il faut définir la fonction spéciale qui dit à ink quelles listes sont en relation. Ink l’appellera pour savoir quels sont les éléments possibles à gauche ou à droite d’une relation. Pour ça, il nous passe une relation et un booléen qui vaut true s’il veut savoir ce qu’il y a du côté gauche de la relation et false pour savoir ce qu’il y a du côté droit.

J’ai ajouté une fonction intermédiaire gauche_droite uniquement pour des raisons de formatage, je trouve pratique de voir toutes les relations d’un coup chacune sur sa ligne.

=== function relationDatabase(relation, gauche)
{ relation:
// Ex : La relation EstEn lie des Objets (à gauche) à des Matières (à droite)
- EstEn:      ~ return gauche_droite(gauche, Objets,    Matières)
- Contient:   ~ return gauche_droite(gauche, Objets,    Objets)
- Réclame:    ~ return gauche_droite(gauche, Objets,    Formes)
- EstDeForme: ~ return gauche_droite(gauche, Objets,    Formes)
- Possède:    ~ return gauche_droite(gauche, Personnes, Objets)
- Connait:    ~ return gauche_droite(gauche, Personnes, Objets)
}

=== function gauche_droite(gauche, listeGauche, listeDroite)
{ gauche:
~ return listeGauche
- else:
~ return listeDroite
}

histoire.ink

On inclut tous les fichiers mentionnés plus tôt.

INCLUDE relations-system.ink
INCLUDE mes-relations.ink
INCLUDE texte.ink
INCLUDE utils.ink

Définissons quelques relations initiales :

~ relate(Pièce, EstEn,      Cuivre)
~ relate(Pièce, EstDeForme, Triangle) // Et ouais
~ relate(Dé,    EstEn,      Bois)
~ relate(Dé,    EstDeForme, Carré)
~ relate(Bille, EstEn,      Verre)
~ relate(Bille, EstDeForme, Cercle)

// Oh, on peut gérer un inventaire avec les relations !
~ relate(Hervé, Possède, Dé)
~ relate(Hervé, Possède, Bille)
// La pièce est dans une salle, Hervé ne la possède pas

// On veut tirer des matières au hasard sans piocher 2 fois la même.
// On fait donc une copie de la liste dont on va à chaque fois enlever un élément aléatoirement (pop_random, une fonction disponible dans l'éditeur Inky).
~ temp m = LIST_ALL(Matières)
~ relate(BolGauche,  EstEn, pop_random(m))
~ relate(BolCentral, EstEn, pop_random(m))
~ relate(BolDroit,   EstEn, pop_random(m))

~ temp f = LIST_ALL(Formes)
~ relate(BolGauche,  Réclame, pop_random(f))
~ relate(BolCentral, Réclame, pop_random(f))
~ relate(BolDroit,   Réclame, pop_random(f))

Si c’était un vrai jeu et pas juste un exemple, on pourrait vouloir s’assurer qu’on n’est pas tombé aléatoirement sur un cas trop simple à résoudre (tous les objets déjà de la bonne matière).

Maintenant que l’initialisation est faite, on peut rentrer dans l’histoire. On va avoir une === intro, qui va nous mener à la === salle_des_bols. Une fois qu’on aura regardé les trois bols, on débloquera l’accès à la === salle_du_transmuteur ainsi qu’à l’=== inventaire.

-> intro

=== intro
[ Pavé de texte que vous pouvez retrouver dans la version complète. ]

+ [Continuer] -> salle_des_bols

=== salle_des_bols
{ TURNS_SINCE(-> salle_du_transmuteur) == 1:
    Vous reprenez le tunnel jusqu'aux bols.
- else:
    Trois bols sont alignés sur un piédestal en pierre.
}
// Ne montrer que les bols tant qu'on ne les a pas tous examinés
// On pourrait gérer ça avec un simple compteur de visite (vu_bol_xyz) sur chaque choix de bol, mais c'est un article sur les relations ;-)

~ temp tous_bols_vus = LIST_COUNT(whatIs(Hervé, Connait)) == 3

+ [Bol gauche  {info_bol(BolGauche)}]  -> menu_bol(BolGauche) ->
+ [Bol central {info_bol(BolCentral)}] -> menu_bol(BolCentral) ->
+ [Bol droit   {info_bol(BolDroit)}]   -> menu_bol(BolDroit) ->
+ {tous_bols_vus}
    [{salle_du_transmuteur:Aller au transmuteur|Explorer la grotte}]
        -> salle_du_transmuteur
+ {tous_bols_vus}
    [Inventaire]
        -> inventaire ->
-
->  redirect_0(-> salle_des_bols)

Ici, le seul morceau qui concerne les relations, c’est la ligne :
~ temp tous_bols_vus = LIST_COUNT(whatIs(Hervé, Connait)) == 3
Avec whatIs(Hervé, Connait), on récupère une liste des objets connus par Hervé. Puis on compte le nombre d’éléments et si c’est 3, c’est qu’Hervé a examiné les 3 bols. Si c’est le cas, on débloque les choix « Explorer la grotte » et « Inventaire ».

Le code utilise également info_bol et menu_bol. La première fonction permet de donner des détails sur un bol s’il est connu. On vérifie cela avec isRelated(Hervé, bol, Connait). Si c’est le cas, on récupère contenu et matière avec whatIs(bol, Contient) et whatIs(bol, EstEn).

=== function info_bol(bol)
// Afficher les infos uniquement si le bol est connu
~ temp connu = isRelated(Hervé, bol, Connait)
{ not connu:
    ~ return
}
~ temp contenu = whatIs(bol, Contient)
~ temp matière = whatIs(bol, EstEn)
~ temp texteContenu = "{contenu:contient {t("un", contenu)}|vide}"
~ return "({texteMatiere(matière)}, {texteContenu})"

Le nœud menu_bol emploie du code similaire pour récupérer contenu, matière et symbole.

C’est là qu’on déclare qu’Hervé connait le bol, et s’il prend quelque chose dans le bol, on modifie les relations avec relate et unrelate. Ça permet de « déplacer » un objet du bol vers l’inventaire.

=== menu_bol(bol)
~ relate(Hervé, Connait, bol)
~ temp contenu = whatIs(bol, Contient)
~ temp matière = whatIs(bol, EstEn)
~ temp symbole = whatIs(bol, Réclame)

Ce bol est {texteMatiere(matière)}.
<> {contenu:Il contient {t("un", contenu)}|Il est vide}.
<> {contenu:Sous {texteObjet("le", contenu)}|Au fond}, vous distinguez un symbole : {texteSymbole(symbole)}.

// S'il y a quelque chose dans le bol, on peut le reprendre, sinon on peut y déposer un objet
+ {contenu} [Reprendre {contenu}]
    ~ relate(Hervé, Possède, contenu)
    ~ unrelate(bol, Contient, contenu)
+ {not contenu} [Déposer] -> menu_deposer(bol) ->
    // Après un dépôt, on vérifie les bols
    { verifier_bols():
    - Victoire: -> victoire
    - Défaite: -> defaite
    }
+ [Retour]
-
->->

Je passe sur le nœud menu_deposer qui génère un choix pour chacun des objets de l’inventaire puis utilise également relate/unrelate.

La salle du transmuteur est similaire à la salle des bols, à part qu’on met les objets dans le transmuteur au lieu des bols. Et bien sûr, le transmuteur transmute…

Au début, la pièce (l’objet) est dans cette salle mais on ne s’est pas embêté à faire un système générique pour prendre et déposer des objets dans les lieux. On pourrait matérialiser ça avec une relation entre des Lieux et des Objets, mais puisque c’est le seul concerné, on peut faire autrement. La pièce peut être à 4 endroits : dans l’inventaire d’Hervé, dans un des bols, dans le transmuteur ou dans la salle. Si Hervé ne possède pas la pièce et qu’aucun objet (bols ou transmuteur) ne contient la pièce, alors il ne reste plus qu’une possibilité : la pièce est dans la salle. On vérifie cela en comptant le nombre d’items en relation avec la pièce via Contient et Possède.
~ temp piece_ici = LIST_COUNT(whatIs(Contient, Pièce) + whatIs(Possède, Pièce)) == 0

=== salle_du_transmuteur

{ TURNS_SINCE(-> salle_des_bols) == 1:
    {La grotte n'est constituée que de deux chambres connectées par un étroit tunnel. Vous vous retrouvez donc la salle du transmuteur que vous aviez découvert précédemment avec Sandrine.|Vous vous faufilez jusqu'au transmuteur}
}

~ temp piece_ici = LIST_COUNT(whatIs(Contient, Pièce) + whatIs(Possède, Pièce)) == 0
{piece_ici: Un objet triangulaire traine dans la poussière.}

~ temp contenu_transmuteur = whatIs(Transmuteur, Contient)

+ {piece_ici} [Ramasser l'objet triangulaire]
    Vous ramassez le triangle, qui semble {texteMatiere(whatIs(Pièce, EstEn))}. Vous reconnaissez le symbole qui est gravé sur une des faces : c'est une pièce de monnaie.
    ~ relate(Hervé, Possède, Pièce)
+ {contenu_transmuteur} [Récupérer {t("le", contenu_transmuteur)}]
    ~ relate(Hervé, Possède, contenu_transmuteur)
    ~ unrelate(Transmuteur, Contient, contenu_transmuteur)
+ {not contenu_transmuteur} [Déposer un objet dans le transmuteur]
    -> menu_deposer(Transmuteur) ->
    ~ contenu_transmuteur = whatIs(Transmuteur, Contient)
    { contenu_transmuteur:
        -> transmuter(contenu_transmuteur) ->
    }
+ [Retourner dans la chambre des bols]
    -> salle_des_bols
+ [Inventaire]
    -> inventaire ->
-
-> redirect_0(-> salle_du_transmuteur)

Pour terminer, on peut regarder la fonction verifier_bols() qui décide si on a gagné/perdu ou s’il faut continuer. Notamment, on vérifie avec plusieurs appels à isRelated() que le contenu du bol a la bonne forme et la bonne matière.

=== function verifier_bols()
LIST StatutBols = Incomplet, Victoire, Défaite
~ temp contenuGauche = whatIs(BolGauche, Contient)
~ temp contenuCentral = whatIs(BolCentral, Contient)
~ temp contenuDroit = whatIs(BolDroit, Contient)

// Si < 3 contenus, le puzzle est incomplet
{ LIST_COUNT(whatIs((BolGauche, BolCentral, BolDroit), Contient)) < 3:
    ~ return Incomplet
}
{ verifier_bol(BolGauche) and verifier_bol(BolCentral) and verifier_bol(BolDroit):
    ~ return Victoire
- else:
    ~ return Défaite
}

=== function verifier_bol(bol)
// On valide l'objet et sa matière
~ temp contenu = whatIs(bol, Contient)
~ temp matière_contenu = whatIs(contenu, EstEn)
~ temp forme_contenu = whatIs(contenu, EstDeForme)
~ temp bol_ok = isRelated(bol, forme_contenu, Réclame) and isRelated(bol, matière_contenu, EstEn😱
~ return bol_ok