1. Introduction

Le démineur est un jeu de réflexion, qui a été grandement popularisé par Microsoft Windows. Les règles du jeu sont simple : {{localiser des mines cachées dans un champs virtuel avec pour seule indication le nombre de mines dans les zones adjacentes.} page Wikipédia du démineur.

Note importante: certaines parties de ce billet, notamment des morceaux de code contiennent des hyperliens alors qu'elles devraient contenir des crochets [ ]. Ceci est du à l'encodage wiki du billet, il ne faut pas en prendre compte.

1.1 But

Attention, grande révélation, le but de ce projet est de créer un démineur. Le langage utilisé sera le PHP / html et l’aspect visuel sera une grille en deux dimensions. La grille devra se générer automatiquement et aléatoirement et la taille devra être modifiable.

2. Matériel et méthodes

2.1 Matériel

Un ordinateur

2.2 Méthode

Le projet se déroulera en plusieurs parties.

2.2.1 Le tableau

Pour commencer, il va falloir générer un tableau de taille x, y rempli de zéros.

L’aspect dynamique, donc les données contenues dans les cases, seront en PHP tandis que l’aspect visuel sera fait en html. Commençons par le PHP : il faut en premier lieu définir les variables. Les première variables sont une variable x et une variable y, respectivement $x et $y. La valeur de x définit le nombre de colonnes et y le nombre de lignes, le but étant de pouvoir modifier facilement la taille de la grille, simplement en changeant la valeur de x ou y. La première subtilité se présente : pour la suite du code, deux lignes et colonnes supplémentaires vont être nécessaires, cependant, elles ne seront pas visibles dans la partie finale. On ne va donc non pas créer un tableau x*y mais x+2*y+2, c’est pour cela que les variable $axe_x et axe_y sont là, qui sont égales respectivement à $x+2 et $y+2. Une autre variable $total_case = $axe-x*$axe_y est là pour définir le nombre de cases totales. Il nous manque une dernière variable $compteur = 0. Pour générer le tableau, il va falloir une boucle. Pour cela j’utilise un while.

while ($compteur<total_case)

{
$tableau$compteur=0 ;
$compteur++ ;
}

La boucle va se répéter jusqu'à atteindre le nombre total de cases, en remplissant au passage chacune des cases avec un zéro. Voilà la base du tableau.

Maintenant pour la mise en forme, on crée une table en html qui contiendra deux boucles qui généreront les cases avec les informations que l’on aura définies en PHP.

<table>
< ?php
while ($boucle_y<$axe_y)
{
?><tr><?php
for ($boucle_x=0 ; $boucle_x < $axe_x ; $boucle_x++)
{
?><td>< ?php echo $tableau$compteur ?></td>< ?php
$compteur++ ;
}

$boucle_y++ ;
?>
</tr>
< ?php
}
?>
</table>

Pour cette manipulation, il va falloir définir une autre variable que j’ai nommée $boucle_y et qui est égale à zéro. La boucle for fait une ligne de cases de taille x, et la boucle while fait répéter le processus pour une nouvelle ligne, jusqu'à ce que le nombre de ligne soit égal à y.
Voilà, maintenant on a un tableau avec plein de zéros.

2.2.2 Placement des bombes

La prochaine partie consistera à placer des bombes aléatoirement dans le tableau à la place des zéros.

Les bombes seront définies comme des -1 (un peu d’imagination sil vous plait). Pour nous aider avec la prochaine partie, le but sera de ne pas avoir de bombes dans les lignes et colonnes à l’extérieur. L’idée pour le placement des bombes est de prendre chaque case, de lui appliquer un test, et de changer sa valeur en -1 ou 0 selon le résultat. Le test en question est de prendre une nouvelle variable, en l’occurrence appelée $place et de changer sa valeur avec la fonction mt_rand qui permet de choisir une valeur aléatoire parmi celles choisies. Dans ce cas, les valeur sont comprises entre -1 et 1 ; ainsi, si la valeur est -1, la valeur de $tableau$compteur deviendra -1 et dans tout les autres cas, elle restera 0. Avec cette méthode, il est possible de choisir proportionnellement le nombre de bombes qui seront placées.
Le code est le suivant

$compteur=$axe_x;

$ligne = 2;

while($ligne<$axe_y)
{
for ($A=0; $A<$x; $A++)
{
$compteur++;

$place = mt_rand(-1,1);
if ($place == -1)
{
$tableau$compteur = -1;
}
else
{
$tableau$compteur = 0;
}
}

$compteur = $compteur+2;
$ligne++;
}
compteur=0;

$facteur = 1;
$compteur=($axe_x);

for ($compteur=$axe_x*($axe_y-1); $compteur < $total_case ; $compteur++)
{
$tableau$[compteur]=0;
}

Le deuxième but est de ne pas placer de bombe dans les lignes et colonnes extérieures. Le changement de valeur doit se faire pour les cases du milieu seulement, c’est pour cela que l’on place le compteur directement à la deuxième case de la deuxième ligne, puis il faut continuer en évitant les cases dans le bord.

Pour une raison obscure, sans la ligne de code qui suit, la ligne du bas n’affiche rien ; le code sert alors à ajouter avec une boucle, des zéros à la dernière ligne.

compteur=0;

$facteur = 1;
$compteur=($axe_x);

for ($compteur=$axe_x*($axe_y-1); $compteur < $total_case ; $compteur++)
{
$tableau$compteur=0;
}

$compteur=0;

Le tableau affiche maintenant des zéros et des -1 à l’emplacement des bombes

2.2.3 Calculs

On utilise une boucle qui va prendre chaque case autour de la bombe et qui, si Maintenant vient la troisième partie ; le calcul des cases.

Dans le démineur, chaque case ne contenant pas de bombe indique le nombre de bombes se trouvant dans un rayon de 1 autour de la case. Il va alors falloir calculer la valeur de ces cases. Pour cela, la méthode utilisée sera la suivante : chaque bombe générée ajoutera +1 aux cases environnantes. C’est là que la subtilité intervient puisque l’on est fort embêté lorsqu’une bombe se trouve dans un bord, puisqu’elle va ajouter +1 à une case qui visuellement n’est pas à coter ; c’est à cela que les lignes, colonnes supplémentaires vont servir.
On utilise une boucle qui va prendre chaque case autour de la bombe et qui, si cette case n’est pas déjà une bombe, y ajoute 1 ; l’opération se répète alors 8 fois.

Voici le code

while($compteur<$total_case)
{
if ($tableau$compteur== -1)
{
if ($tableau$compteur-$axe_x-1 != -1)
{
$tableau$compteur-$axe_x-1++;
}
if ($tableau$compteur-$axe_x != -1)
{
$tableau$compteur-$axe_x++;
}
if ($tableau$compteur-$axe_x+1 != -1)
{
$tableau$compteur-$axe_x+1++;
}
if ($tableau$compteur-1 != -1)
{
$tableau$compteur-1++;
}
if ($tableau$compteur+1 != -1)
{
$tableau$compteur+1++;
}
if ($tableau$compteur+$axe_x-1 != -1)
{
$tableau$compteur+$axe_x-1++;
}
if ($tableau$compteur+$axe_x != -1)
{
$tableau$compteur+$axe_x++;
}
if ($tableau$compteur+$axe_x+1 != -1)
{

$tableau$compteur+$axe_x+1++;
}
}
$compteur++;
}
$compteur=0;

?>

Voilà pour les calculs. Notre grille est maintenant prête, il faudrait ensuite s’attaquer à l’aspect visuel et à l’interaction, mais je n’ai malheureusement pas eu le temps de le faire.

3. Résultats

Le résultat peut être observé à cette adresse : et le code se trouve sur le git.

Le code source est disponible ici

4. Discussion


Les premiers résultats correspondent aux premiers critères, malheureusement la suite n'a pas pu être réalisée. La méthode utilisée n'est pas forcément la plus optimal, mais elle fonctionne. Elle pourrait donc largement amélioré et simplifiée.

5. Conclusion

La première partie fonctionne, mais la suite n'est pas finie.