Enigma (jeu vidéo, 2002)

Définition des dalles

On peut convenir de représenter par des espaces les dalles ayant les propriétés du béton, en écrivant[9]

ti[" "] = {"fl_concrete"}

(fl est une abréviation pour floor).

Puis de même, le sol de la chambre peut être représenté par des x (du gravier encadré):

ti["x"] = {"fl_gravel_framed"}

Le niveau sera muni de 4 portes numérotées de 1 à 4, qui s'appelleront door1, door2, door3 et door4; elles auront leur battants au nord et au sud, et seront initialement fermées et par-dessus le sol en béton (la concaténation est notée par deux points en lua[10]):

ti["1"] = ti[" "]..{"st_door_d","door1",faces="ns",state=CLOSED}
ti["2"] = ti[" "]..{"st_door_d","door2",faces="ns",state=CLOSED}
ti["3"] = ti[" "]..{"st_door_d","door3",faces="ns",state=CLOSED}
ti["4"] = ti[" "]..{"st_door_d","door4",faces="ns",state=CLOSED}

Pour les murs de la chambre et le couloir fermé par les portes, on utilise des pierres ayant elles aussi l'aspect du béton, afin de donner un look "urbain" à ce jeu (st veut dire stone).

ti["#"] = {"st_concrete"}

Pour que ce jeu soit jouable, il faut au moins deux pierres oxyd (celles que Blackball devra toucher pour gagner le jeu); elles seront représentées par le caractère o sur la carte:

ti["o"] = {"st_oxyd"}

Une seule dalle sera représentée par une arobase, l'acteur Blackball lui-même (précédé par un dièse pour le centrer sur la dalle):

ti["@"] = {"#ac_marble"}

Une dernière pierre est représentée par un i: C'est un interrupteur ("switch"), paramétré pour qu'à son contact, il lance ("callback") la fonction lua appelée "GimmeMoney()":

ti["i"] = {"st_switch",action="callback",target="GimmeMoney"}

Ce jeu utilise des pièces de monnaie de valeurs respectives 10, 5 et 2 cents. Elles seront représentées respectivement par les lettres l, m et s (comme large, medium et small):

ti["l"] = {"it_coin_l","large#"}
ti["m"] = {"it_coin_m","medium#"}
ti["s"] = {"it_coin_s","small#"}

Enfin, la règle du jeu est dans un document que Blackball peut ramasser en roulant dessus, puis lire en cliquant dessus; sur la carte, ce document est représenté par la lettre d:

ti["d"] = {"it_document",text="text1"}

Ainsi constitué, l'objet ti (comme tile) est un tableau associatif, dont les éléments sont des objets du jeu. Constituer le jeu, c'est puiser ces éléments et les placer dans une carte appelée wo (comme world) ci-dessous

Carte du niveau

La construction du jeu ressemble à un jeu de construction: On puise les éléments dans le tableau ti, avec une valeur par défaut pour le sol (le caractère espace) et en suivant les instructions qui figurent dans la carte (une chaîne de caractères elle aussi):

wo(ti, " ", {
    "####################",
    "#o          lllll#o#",
    "#           mmmmm#1#",
    "#           sssss#2#",
    "#        @       #3#",
    "#                #4#",
    "# #######          #",
    "# #.....#         d#",
    "#  .....#          #",
    "# #.....#          #",
    "# #######          #",
    "#                 i#",
    "####################"
})

Une fois rendue, cette carte ressemble à ceci dans le jeu Enigma:

Pour finir l'initialisation du jeu, on affecte deux variables wealth (le montant à déposer dans la chambre, initialement trop grand pour que ce soit possible avant d'actionner l'interrupteur) et ndoors qui représente le numéro de la prochaine porte à ouvrir (c'est-à-dire le nombre de portes fermées):

ndoors=4
wealth=150 -- cannot have that

Algorithmes

Le principe du jeu est le suivant : Chaque fois que Blackball actionne l'interrupteur, on lui apporte un ordre de mission, comportant un montant à déposer dans la chambre, et si le montant correspond à celui qui est demandé, la prochaine action de l'interrupteur ouvrira la porte portant le numéro ndoors. La variable ndoors est alors décrémentée jusqu'à ce que toutes les portes soient ouvertes ce qui permet de gagner le jeu. C'est le rôle de la fonction GimmeMoney() appelée à chaque action de l'interrupteur:

function GimmeMoney()
	if ndoors>0 then
        somme=0
        tens=no["large#*"]
        for n in tens do
            if n.x>2 and n.x<8 and n.y>6 and n.y<10 then somme=somme+10 end
        end
        fives=no["medium#*"]
        for n in fives do
            if n.x>2 and n.x<8 and n.y>6 and n.y<10 then somme=somme+5 end
        end
        twos=no["small#*"]
        for n in twos do
            if n.x>2 and n.x<8 and n.y>6 and n.y<10 then somme=somme+2 end
        end
        if somme==wealth then
		 st(no["door"..ndoors]):open()
            ndoors=ndoors-1
        end
        wealth=10*random(5)+5*random(5)+2*random(5)
        wo[po(18,9)]={"it_document",text=wealth.." cents"}
    end
end

Si ndoors est déjà égal à zéro, cette fonction ne fait rien puisque les portes étant ouvertes, la fonction GimmeMoney() est devenue inutile. Sinon on calcule le montant présent dans la chambre en initialisant une variable somme à zéro, puis en y additionnant 10 fois le nombre de pièces de 10, 5 fois le nombre de pièces de 5 et 2 fois le nombre de pièces de 2 présentes dans la pièce (c'est-à-dire, dont l'abscisse est comprise entre 2 et 8, et l'ordonnée entre 6 et 10 exclus). Par exemple, pour avoir le nombre de pièces de 10, on fait

        tens=no["large#*"]
        for n in tens do
            if n.x>2 and n.x<8 and n.y>6 and n.y<10 then somme=somme+10 end
        end

(On place dans l'objet tens les objets dont le nom commence par large, no étant une abréviation pour named objects; on peut alors boucler sur les éléments de tens); on fait pareil avec les pièces de 5 et de 2, puis si les deux montants coïncident, on adresse à la pierre dont le nom est doors concaténé avec le numéro ndoors, un message (représenté par un double-point) lui demandant de s'ouvrir:

        if somme==wealth then
		 st(no["door"..ndoors]):open()
            ndoors=ndoors-1
        end

Enfin, on calcule un nouveau montant aléatoire (à placer ensuite dans la chambre) et on l'écrit sur un document suivi du mots cents, avant de placer ce document sur la dalle de coordonnées (18;9):

        wealth=10*random(5)+5*random(5)+2*random(5)
        wo[po(18,9)]={"it_document",text=wealth.." cents"}

Théorie de ce jeu

En fait, malgré l'absence de pièces d'un cent, le jeu n'est pas très difficile puisqu'on peut toujours trouver une manière d'arranger des pièces de 10, 5 et 2 avec l'algorithme glouton.