Tutorial 5 Memory coloré (1/2)

Pour ce nouveau tutorial nous allons être plus ambitieux. Je vous propose de réaliser une version colorée du célèbre memory. Vous savez ce jeu qui consiste à retourner les cartes par deux pour trouver les paires. Ici ce ne sont pas des cartes à retourner mais des plots à toucher qui se colorent. Le jeu consiste à retrouver les paires de couleurs. Comme vous pouvez le voir sur l'image j'ai réalisé une version très épurée composée de 16 plots (8 paires) placées sur un support. J'ai aussi prévu un bouton en bas pour la mise en marche. Sur l'illustration le jeu est en cours et quelques paires de couleurs ont déjà été trouvées. J'ai simplifié au maximum le fonctionnement pour ne pas trop charger le script. Un seul bouton pour démarrer ou redémarrer à n'importe quel moment. Au niveau de la construction j'ai commencé par créer les 16 plots en les alignant soigneusement, J'ai ensuite réalisé le support et le bouton. Pour les liaisons il faut respecter l'ordre suivant (pour que le script fonctionne !) : sélectionnez d'abord les plots, puis le bouton et en dernier le support. Ainsi ce dernier ce retrouve à la racine (root).

Voici le code à mettre dans le support. Ne vous laissez pas intimider par sa longueur, nous détaillerons tout ça...



//
// Memory Version 1.1
// par bestmomo
//

// Nombre de paires de couleurs
integer NombrePaires;
// Liste des etats des plots
list Visible = [];
// Liste melange des plots
list Melange;
// Liste des couleurs
list Couleurs = [];
// Premier plot touche
integer Premier;
// Second plot touche
integer Second;
// Constante de communication
integer GO = 10;
// Constante pour les plots
integer NON_TOUCHE = -1;

initialisations()
{

// Initialisation du nombre de paires
NombrePaires = 8;
// Initialisation des touches
Premier = NON_TOUCHE;
Second = NON_TOUCHE;
// Nombre total de plots
integer NombrePlots = NombrePaires * 2;
// Index du dbut des plots
integer Debut = llGetNumberOfPrims() - NombrePlots + 1;
// Creation et remplissage de la liste des plots
integer x;
list Plots = [];
for(x = Debut; x < NombrePlots + Debut; x++)
{
Plots += x;
// Plots noirs au depart
llSetLinkColor(x, <0,0,0>, ALL_SIDES);
}
// Creation d'une liste melange des plots
Melange = llListRandomize(Plots, 1);
// Creation de la liste des couleurs des plots par paires
for(x = 0; x < NombrePaires; x++)
{
vector col = ;
Couleurs += col;
Couleurs += col;
}
// Remplissage de 0 de la liste Visible
for(x = 0; x < NombrePlots; x++)
Visible += [0];
// Avis de depart
llSay(PUBLIC_CHANNEL, "Jeu en cours");
}

// Renvoie l'index du Plot
integer IndexPlot(list sender_number)
{
return llListFindList(Melange, sender_number);
}

// Renvoie la valeur de visibilite TRUE (1) ou FALSE (0)
integer TestVisible(list sender_number)
{
integer Index = IndexPlot(sender_number);
return llList2Integer(Visible, Index);
}

// Affecte la visibilite au Plot
SetVisible(integer plot)
{
integer Index = IndexPlot([plot]);
Visible = llListReplaceList(Visible, [1], Index, Index);
}

// Met en couleur le plot
ColorePlot(integer sender_number)
{
llSetLinkColor(sender_number, llList2Vector(Couleurs, IndexPlot([sender_number])), ALL_SIDES);
}

// Test de paire
integer TestePaire(integer a, integer b)
{
if(llList2Vector(Couleurs, IndexPlot([a])) == llList2Vector(Couleurs, IndexPlot([b])))
return TRUE;
return FALSE;
}

// Test de fin
integer TestFin()
{
if(llListFindList(Visible, [0]) == -1)
return TRUE;
return FALSE;
}

default
{
// Attente action du bouton
link_message(integer sender_number, integer number, string message, key id)
{
// Depart du jeu
if(number == GO)
{
initialisations();
state PremierPlot;
}
return;
}
}

state PremierPlot
{
// Reception d'un message des plots
link_message(integer sender_number, integer number, string message, key id)
{
// Nouveau depart du jeu ?
if(number == GO)
{
initialisations();
return;
}
// Plot deja visible ?
if(TestVisible([sender_number]))
return;
else
{
// Affectation premier plot
Premier = sender_number;
// Colorisation du plot
ColorePlot(sender_number);
// Passage au choix du second plot
state SecondPlot;
}
}
}

state SecondPlot
{
// Reception d'un message des plots
link_message(integer sender_number, integer number, string message, key id)
{
// Nouveau depart du jeu ?
if(number == GO)
{
initialisations();
state PremierPlot;
}
// Deja un second plot touche ?
if(Second != NON_TOUCHE)
return;
// Deuxieme plot choisi
Second = sender_number;
if(TestVisible([Second]) || Second == Premier)
return;
else
{
// Colorisation du plot
ColorePlot(Second);
// Test paire trouvee
if(TestePaire(Premier, Second))
{
// Affecte visible pour les deux plots
SetVisible(Premier);
SetVisible(Second);
// Reinitialisation
Premier = NON_TOUCHE;
Second = NON_TOUCHE;
// Test de fin du jeu
if(TestFin())
llResetScript();
// Retour au choix du premier plot
state PremierPlot;
}
else
// Timer 2 secondes
llSetTimerEvent(2);
}
}

// Temporisation
timer()
{
// Remise a noir de la couleur des deux plots
llSetLinkColor(Premier, <0,0,0>, ALL_SIDES);
llSetLinkColor(Second, <0,0,0>, ALL_SIDES);
// Reinitialisation des touches
Premier = NON_TOUCHE;
Second = NON_TOUCHE;
// Reset du timer
llSetTimerEvent(.0);
// Retour au choix du premier plot
state PremierPlot;
}
}

En ce qui concerne ce code je dois avouer que j'ai un peu galéré. Je suis habitué aux langages évolués et à la programmation objet. Les contraintes de LSL me renvoient bien des années en arrière. J'ai un peu pesté contre les limitations de ce langage. J'ai aussi utilisé à forte dose le programme LSLEditor et j'ai passé plusieurs heures à chercher un bug dans mon programme alors qu'il était dans l'éditeur ! Le côté positif c'est que j'ai participé au débogage de cet excellent éditeur (en fait le seul qui existe pour LSL !) et j'ai fait la connaissance de son auteur qui est fort sympathique. Je vous proposerai d'ailleurs un de ces jours une vidéo pour illustrer son fonctionnement en mode débogage.

Voici maintenant le code pour le bouton :



integer GO = 10;

default
{
touch_start(integer total_number)
{
llMessageLinked(LINK_ROOT, GO, "", NULL_KEY);
}
}




Et celui pour les plots (il faut mettre ce script dans chaque plot !) :



integer TOUCHE = 1;

default
{
touch_start(integer total_number)
{
llMessageLinked(LINK_ROOT, TOUCHE, "", NULL_KEY);
}
}




Commencez par essayer ce code. J'ai mis pas mal de commentaires, ce qui peut déjà vous expliquer un peu son fonctionnement.

Ce script va nous permettre de voir le dernier type de LSL qui est un type un peu particulier puisque c'est le seul qui peut contenir plusieurs valeurs, de type différents en plus. C'est le type list. Comme son nom l'indique c'est une liste de valeurs empilées. C'est bien pratique pour stocker et manipuler un ensemble de valeurs liées fonctionnellement. J'en fait une utilisation intensive dans ce script. Tout ce que vous voulez savoir sur les listes est situé ici :



http://www.lslwiki.net/lslwiki/wakka.php?wakka=list



On peut faire à peu près tout ce qu'on veut, même si ce n'est pas toujours d'une simplicité biblique. En particulier il manque une fonction du genre ListIndexOf qui renverrait l'index d'une valeur. Au lieu de cela il faut se contenter de llListFindList qui donne l'index d'une liste dans une autre liste. Évidemment il suffit de mettre une seule valeur dans la liste de recherche pour obtenir l'index d'une seule valeur mais bon... J'ai sans doute pris de mauvaises habitudes avec la pléthore de fonctions intégrées aux langages que j'utilise habituellement.

Dans le prochain tutorial je commencerai à commenter le code. En attendant vous pouvez déjà exercer votre mémoire en jouant avec ce memory !