Bonjour à tous ! À la suite d'un projet ISN consistant à réaliser un morpion en Python, j'ai dû imaginer plusieurs algorithmes qui pourraient vous être utiles pour créer n'importe quel jeu du type Puissance 4, 5 croix ou Morpion si vous en avez envie :) J'ai également fait ce programme en JavaScript (vous pouvez l'essayer ici : http://yann-p.fr/puissance4). Je partage donc les techniques que j'ai utilisées pour y arriver. Ce ne sont sûrement pas les meilleures, mais ça marche. Enjoy !

I - Bases

On tient l'état du jeu avec les variables suivantes :

var grille = [ // Générée avec une petite boucle
	[0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0]
]
var tour = 1 // 1 : au tour du joueur, 2: au tour de l'IA

II - Détecter si un coup clôture la partie avec un gagnant

Ce qu'on veut : connaitre l'alignement maximal qu'a réalisé un joueur, connaissant son dernier coup et l'état du jeu (grille). Je me base donc sur le dernier coup. Ensuite, connaissant ses coordonnées, on cherche dans toutes les directions d'autres pions du même joueur (ici, des croix.) Pour chaque direction, on initialise le compteur d'alignement à 1 (le coup sur lequel on se base pour la recherche). Puis on part dans les deux sens que représente cette direction, à partir du dernier coup. Prenons ici la diagonale verte. Pour les deux sens, on cumule le nombre de coups du joueur et on s'arrête lorsqu'on rencontre soit une case vide, soit un coup de l'adversaire, soit le bord de la grille. On recommence pour chaque direction à chercher dans les deux sens et finalement, on prend le compteur correspondant à la direction ayant effectué le plus haut score. Voici ce que ça donne niveau algorithmique :

var alignementMaximal = function(dernierX, dernierY, tour) {
	directions = [
        [[1, 0], [-1, 0]], // Ligne horizontale : [ vers la droite : [x+, y], vers la gauche : [x-, y]]
        [[0, 1], [0, -1]], // Ligne verticale : [ vers la bas : [x, y+], vers le haut : [x, y-]]
        [[-1, 1], [1, -1]],// Diagonale \
        [[-1, -1], [1, 1]] // Diagonale /
    ]

    for (i = 0; i < directions.length; i++) { // Pour toutes les directions
  		direction = directions[i];
  		compteur = 1;
  		for (j = 0; j < direction.length; j++) { // Pour les deux sens de cette direction
    		sens = direction[j];
    		x = dernierX + sens[0]; // On initialise les variables de la position du coup initial
    		y = dernierY + sens[1]; // sens[0] est le changement de x, sens[1] celui de y
    		while (!horsGrille(x, y) && !caseOccupeeParAdversaire(x, y) && !caseVide(x, y)) { // Tant que rien ne bloque la progression
      			compteur++;   // Le compteur augmente
      			x += sens[0]; // On avance
      			y += sens[1];
    	}
    }
}

Je m'arrête là pour aujourd'hui et dans mon prochain tuto, je vous explique comment fonctionne l'intelligence artificielle :) L'IA se servira de cette fonction car elle étudiera toutes les issues des coups réalisables sur la grille, et aura donc besoin de savoir si tel ou tel coup clôture une partie. Merci d'avoir lu et bonne journée ! :D