Ho realizzato una sorta di puzzle game in cui l'obiettivo è quello di eliminare tutte le tessere bianche. Puoi provarlo alla fine della domanda.

Ogni volta, la scheda viene generata casualmente con tessere bianche in punti casuali su una griglia 5 * 5. Puoi fare clic su qualsiasi tessera su quella griglia e cambierà il colore di essa e tutte le tessere toccandole sui lati. Il mio dilemma è il fatto che non so se genererà una scheda impossibile. Qual è il modo migliore per controllare cose come questa?

function newgame() {
 moves = 0;
    document.getElementById("moves").innerHTML = "Moves: "+moves;

  for (var i = 0; i < 25; i++) {
   if (Math.random() >= 0.5) {
$(document.getElementsByClassName('block')[i]).toggleClass("b1 b2")
   }
}
}
newgame();
function toggle(a,b) {  
  moves += 1;
  document.getElementById("moves").innerHTML = "Moves: "+moves;
$(document.getElementsByClassName('block')[a+(b*5)]).toggleClass("b1 b2");

if (a<4) {$(document.getElementsByClassName('block')[(a+1)+(b*5)]).toggleClass("b1 b2")}
  
  
if (a>0) {$(document.getElementsByClassName('block')[(a-1)+(b*5)]).toggleClass("b1 b2")}
  
  
if (b<4) {$(document.getElementsByClassName('block')[a+((b+1)*5)]).toggleClass("b1 b2")}
  
if (b>0) {$(document.getElementsByClassName('block')[a+((b-1)*5)]).toggleClass("b1 b2")}
}

body {
  background-color: #000000;
}

.game {
  float: left;
  background-color: #000000;
  width: 300px;
  height: 300px;
  overflow: hidden;
  overflow-x: hidden;
  user-select: none;
  display: inline-block;
}

.container {
  border-color: #ffffff;
  border-width: 5px;
  border-style: solid;
  border-radius: 5px;
  width: 600px;
  height: 300px;
  text-align: center;
}

.side {
  float: left;
  background-color: #000000;
  width: 300px;
  height: 300px;
  overflow: hidden;
  overflow-x: hidden;
  user-select: none;
  display: inline-block;
}

.block {
  transition: background-color 0.2s;
  float: left;
}

.b1:hover {
  background-color: #444444;
  cursor: pointer;
}

.b2:hover {
  background-color: #bbbbbb;
  cursor: pointer;
}

.row {
  width: 300px;
  overflow: auto;
  overflow-x: hidden;
}

.b1 {
  display: inline-block;
  height: 50px;
  width: 50px;
  background-color: #000000;
  border-color: #000000;
  border-width: 5px;
  border-style: solid;
}




.b2 {
  display: inline-block;
  height: 50px;
  width: 50px;
  background-color: #ffffff;
  border-color: #000000;
  border-width: 5px;
  border-style: solid;
}



.title {
  width: 200px;
  height: 50px;
  color: #ffffff;
  font-size: 55px;
  font-weight: bold;
  font-family: Arial;
  display: table-cell;
  vertical-align: middle;
}

.button {
  cursor: pointer;
  width: 200px;
  height: 50px;
  background-color: #000000;
  border-color: #ffffff;
  border-style: solid;
  border-width: 5px;
  color: #ffffff;
  font-size: 25px;
  font-weight: bold;
  font-family: Arial;
  display: table-cell;
  vertical-align: middle;
  border-radius: 5px;
  transition: background-color 0.3s, color 0.3s;
}

.button:hover {
  background-color: #ffffff;
  color: #000000;
}

.sidetable {
  padding: 30px 0px;
  height: 200px;
}


#moves {
  width: 200px;
  height: 50px;
  color: #aaaaaa;
  font-size: 30px;
  font-weight: bold;
  font-family: Arial;
  display: table-cell;
  vertical-align: middle;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<center>
  <div class="container">
  
  
  <div class="game"><div class="row"><div onclick="toggle(0,0);" class="block b1"></div><div onclick="toggle(1,0);" class="block b1"></div><div onclick="toggle(2,0);" class="block b1"></div><div onclick="toggle(3,0);" class="block b1"></div><div onclick="toggle(4,0);" class="block b1"></div></div><div class="row"><div onclick="toggle(0,1);" class="block b1"></div><div onclick="toggle(1,1);" class="block b1"></div><div onclick="toggle(2,1);" class="block b1"></div><div onclick="toggle(3,1);" class="block b1"></div><div onclick="toggle(4,1);" class="block b1"></div></div><div class="row"><div onclick="toggle(0,2);" class="block b1"></div><div onclick="toggle(1,2);" class="block b1"></div><div onclick="toggle(2,2);" class="block b1"></div><div onclick="toggle(3,2);" class="block b1"></div><div onclick="toggle(4,2);" class="block b1"></div></div><div class="row"><div onclick="toggle(0,3);" class="block b1"></div><div onclick="toggle(1,3);" class="block b1"></div><div onclick="toggle(2,3);" class="block b1"></div><div onclick="toggle(3,3);" class="block b1"></div><div onclick="toggle(4,3);" class="block b1"></div></div><div class="row"><div onclick="toggle(0,4);" class="block b1"></div><div onclick="toggle(1,4);" class="block b1"></div><div onclick="toggle(2,4);" class="block b1"></div><div onclick="toggle(3,4);" class="block b1"></div><div onclick="toggle(4,4);" class="block b1"></div></div></div>
    
    <div class="side">
      <center class="sidetable">
        <div class="title">Tiles</div>
        <br>
        <div class="button" onclick="newgame()">New Game</div>
        <br><br>
        <div id="moves">Moves: 0</div>
      </center>
    </div>
    
  </div>
    </center>

Questo è il tipo di gioco in cui la stessa mossa eseguita due volte riporta la tavola al suo stato precedente. Quindi, per garantire che una tavola sia risolvibile, generala giocando al contrario. Inizia con una scheda (vuota) risolta, quindi inizia programmaticamente "facendo clic" in modo casuale un determinato numero di volte o fino a quando la scheda non ha il numero desiderato di quadrati bianchi. Una soluzione è quindi semplicemente eseguire le stesse mosse nell'ordine inverso. Potrebbero esistere altre soluzioni più brevi, ma sei sicuro di averne almeno una.

Un'altra soluzione molto più complessa è quella di definire un algoritmo di risoluzione che attraversi tutti i possibili stati di gioco dalla posizione iniziale per cercare di trovare la soluzione. Ciò richiederebbe molto più tempo per essere implementato ed eseguito, ma permetterebbe alle schede di essere veramente generate casualmente. Non entrerò nei dettagli di questa soluzione, perché non è un'idea altrettanto buona.

Mentre le risposte di cui sopra sono intelligenti (e probabilmente come lo farei comunque), questo particolare gioco è molto noto. Si chiama Lights Out ed è stato risolto matematicamente. C'è una soluzione se e solo se due somme di vari elementi (fornite nella pagina di Wikipedia) si sommano a zero mod 2 (cioè un numero pari). In generale, una piccola algebra lineare dovrebbe fornire condizioni di soluzione simili per i giochi su qualsiasi tavola.

Fai il contrario quando generi il tuo puzzle.

Invece di selezionare casualmente le tessere e trasformarle da bianche a nere, inizia da un'ardesia vuota, quindi seleziona le tessere ma invece di trasformare quella tessera in nero, rendila come se l'utente l'avesse selezionata, con il risultato di capovolgere tutte le altre tessere intorno ad esso.

In questo modo avrai la garanzia di avere almeno una soluzione: l'utente dovrà annullare ciò che il tuo giocatore "AI" ha fatto per creare il livello.

Ed e Alexandre ne hanno il diritto.

Ma se non volete sapere se ogni soluzione è possibile, ci sono modi.

Esistono un numero finito di possibili puzzle

Fare clic due volte sullo stesso quadrato produce lo stesso risultato del non fare clic su di esso, indipendentemente dal numero di clic effettuati tra di essi. Ciò significa che ogni soluzione può essere descritta assegnando a ciascun quadrato un valore binario di "cliccato" o "non cliccato". Allo stesso modo, ogni enigma può essere descritto dando ad ogni quadrato un valore binario di 'toggled' o 'not toggled'. Ciò significa che ci sono 2 ^ 25 possibili puzzle e 2 ^ 25 possibili soluzioni. Se puoi provare che ogni soluzione risolve un puzzle unico, allora deve esserci una soluzione per ogni puzzle. Allo stesso modo, se trovi due soluzioni che risolvono lo stesso puzzle, allora non può esserci una soluzione per ogni puzzle.

Inoltre, 2 ^ 25 è 33.554.432. È abbastanza, ma non è un numero ingestibile. Un buon algoritmo e un computer decente potrebbero probabilmente creare una forza bruta in un paio d'ore, specialmente se si considera che metà dei puzzle sono inversioni dell'altra metà.

Risposta generalizzata:

1. Crea una matrice di dimensioni (# mosse) x (# luci).
2. Inserisci un 1 in una cella se lo spostamento corrispondente a quella riga attiva o disattiva quella luce corrispondente a quella colonna, 0 altrimenti.
3. Eseguire l'eliminazione di Gauss-Jordan (modulo 2) sulla matrice.
4. Se la matrice risultante ha un solo 1 in ogni colonna e ogni riga ha al massimo un singolo 1, allora ogni griglia è risolvibile.

Altri hanno già menzionato i modi per scoprire se il tuo puzzle generato casualmente è risolvibile. la domanda che dovresti anche porre, tuttavia, è se desideri effettivamente puzzle generati casualmente.

I puzzle generati casualmente hanno tutti lo stesso difetto di base: la loro difficoltà è praticamente imprevedibile. I possibili puzzle che potresti ottenere possono variare da già risolti, a banali (la soluzione è ovvia) a difficili (la soluzione non è ovvia) a impossibili (il puzzle non è affatto risolvibile). Poiché la difficoltà è imprevedibile, rende l'esperienza insoddisfacente per il giocatore, soprattutto se fanno più puzzle di fila. È altamente improbabile che ottengano una curva di difficoltà regolare, che può renderli annoiati o frustrati a seconda dei puzzle che ottengono.

Un altro problema della generazione casuale è che il tempo necessario per l'inizializzazione del puzzle è imprevedibile. In generale, otterrai un puzzle risolvibile (quasi) immediatamente, ma con un po 'di sfortuna, i tuoi puzzle generati casualmente potrebbero finire su una serie di puzzle irrisolvibili.

Un modo per risolverli entrambi è avere vettori predefiniti di ogni puzzle risolvibile disponibile, disposti in gruppi di difficoltà, quindi selezionando un puzzle casuale tra i puzzle risolvibili in base alla difficoltà. In questo modo, sarai sicuro che ogni enigma è risolvibile, che la difficoltà è prevedibile e che la generazione sarà fatta in tempo costante.