algorithme connecter quatre javascript

DOM Traversal n'est pas particulièrement efficace, alors que vous pouvez l'éviter, je le recommande de le faire. Cela vous permettrait de construire cela comme une matrice 2D pour stocker et mettre à jour l'état du jeu. La table ne serait qu'une représentation visuelle du tableau.

Je sais que, normalement, vous construirez la matrice avec des lignes comme la première dimension et les colonnes comme la deuxième dimension, mais que, aux fins de pouvoir ajouter des morceaux à "Stack" de chaque colonne, je ferais la première dimension des colonnes et la seconde dimension des rangées. P>

Pour faire le chèque, jetez un coup d'œil à ce violon que j'ai fait: p>

http://jsfiddle.net/koviko/4dtyw/ p>

Il y a 4 directions Pour vérifier: nord-sud, est-ouest, nord-est-sud-ouest et sud-est du nord-ouest. Cela peut être représenté comme des objets avec le delta défini pour x et y: p> xxx pré>

puis, boucle à travers cet objet et boucle à travers votre "table" à partir des limites les plus éloignées que cette pièce peut éventuellement contribuer à une victoire. Donc, comme vous avez besoin de 4 pièces d'affilée, la pièce actuellement placée peut contribuer dans une victoire pouvant aller jusqu'à 3 pièces dans n'importe quelle direction. P>

function isVictory(pieces, placedX, placedY) {
  var i, j, x, y, maxX, maxY, steps, count = 0,
    directions = [
      { x: 0, y: 1  }, // North-South
      { x: 1, y: 0  }, // East-West
      { x: 1, y: 1  }, // Northeast-Southwest
      { x: 1, y: -1 }  // Southeast-Northwest
    ];

  // Check all directions
  outerloop:
  for (i = 0; i < directions.length; i++, count = 0) {
    // Set up bounds to go 3 pieces forward and backward
    x =     Math.min(Math.max(placedX - (3 * directions[i].x), 0), pieces.length    - 1);
    y =     Math.min(Math.max(placedY - (3 * directions[i].y), 0), pieces[0].length - 1);
    maxX =  Math.max(Math.min(placedX + (3 * directions[i].x),     pieces.length    - 1), 0);
    maxY =  Math.max(Math.min(placedY + (3 * directions[i].y),     pieces[0].length - 1), 0);
    steps = Math.max(Math.abs(maxX - x), Math.abs(maxY - y));

    for (j = 0; j < steps; j++, x += directions[i].x, y += directions[i].y) {
      if (pieces[x][y] == pieces[placedX][placedY]) {
        // Increase count
        if (++count >= 4) {
          break outerloop;
        }
      } else {
        // Reset count
        count = 0;
      }
    }
  }

  return count >= 4;
}

En général, une matrice 2Dimensionnelle conviendrait mieux à la vérification d'une ligne de 4. Vous pouvez alors faire quelque chose comme ce qui suit: xxx

modifier: ajouté Vérifications pour les frontières du terrain de jeu

J'ai publié une version entièrement professionnelle du jeu sur github .

Il met en œuvre une variation optimisée sur l'algorythm SIRKO mentionné. < P> Pour éviter tout redunancement inutile, l'algorythm vérifie directement le DOM plutôt que sur une table JS. Comme cet algorythme nécessite une quantité minimale de chèques, la surcharge de performance pour accéder à la DOM est négligable.

Le joueur actuel et un drapeau permettant de suivre si le jeu est terminé les seules étatiques stockées dans le JS elle-même.

J'ai même utilisé le DOM pour stocker des chaînes. Il n'a pas de dépendances externes et est supporté par toutes les versions d'IE à partir de IE6 vers le haut ainsi que des navigateurs modernes.

code est optimisé pour la définition et la performance. La dernière version inclut également une animation, même si le code JS total du jeu n'est toujours que 1,216 octets après minéculation.