Detaillierte Erklärung des digitalen Puzzles CocosCreator Huarongdao

//Durchlaufe die Lösung, während (true) {
    let Schritte: Array<beliebig> = [];
    let lastGrad: Array<beliebig> = this.mMapData[this.mMapData.length - 1];
    console.log(letzterGrad.Länge);
    //Alle Ergebnisse im letzten Gradienten durchlaufen und den nächsten Schritt lösen for (let i = 0; i < lastGrad.length; i++) {
        lass matrix = letzterGrad[i]["matrix"];
        lass Antwort = letzterGrad[i]["Antwort"];
        let-Ergebnis: Array<any> = this.move(Matrix, Antwort, Schritte);
        wenn (Ergebnis) {
            console.log("Ergebnis:", Ergebnis);
            Lösung (Ergebnis);
            zurückkehren;
        }
    }

    wenn(Schritte.Länge<=0){
        console.log("Abfrageergebnis fehlgeschlagen, ");
        auflösen (null);
        zurückkehren;
    }
    this.mMapData.push(Schritte);
}

privater Zug(Matrix: Array<Zahl>, Antwort: Array<beliebig>, Schritte: Array<beliebig>): Array<beliebig> {
    für (lass i = 0; i < Matrix.Länge; i++) {
        if (matrix[i] != -1) { //Kein leerer Bereich. Überprüfe, ob er verschoben werden kann, und erhalte das Ergebnis der Verschiebung. //Überprüfe, ob er nach oben, unten, links und rechts verschoben werden kann.
            let result0: Array<any> = this.moveUp(i, matrix, antwort, schritte);
            let result1: Array<any> = this.moveDown(i, matrix, antwort, schritte);
            let result2: Array<any> = this.moveLeft(i, matrix, antwort, schritte);
            let result3: Array<any> = this.moveRight(i, matrix, answer, steps);

            wenn (Ergebnis1) {
                Ergebnis1 zurückgeben;
            }
            wenn (Ergebnis2) {
                gib Ergebnis2 zurück;
            }
            wenn (Ergebnis0) {
                gib Ergebnis0 zurück;
            }
            wenn (Ergebnis3) {
                Ergebnis3 zurückgeben;
            }
        }
    }
    gibt null zurück;
}

private moveRight(i: Zahl, Matrix: Array<Zahl>, Antwort: Array<beliebig>, Schritte: Array<beliebig>): Array<beliebig> {
    let Zeile: Zahl = i % this.mLine;
    lass Zeile: Zahl = Math.floor(i / this.mLine);
    if (line + 1 >= this.mLine) return null; //Außerhalb der Grenzen let targetIndex: number = row * this.mLine + (line + 1);
    if ( matrix[targetIndex] != -1) return null; //Nicht verschiebbar //Verschieben //Verschieben //Das neue Array zur Änderung kopieren let newMatrix: Array<number> = JSON.parse(JSON.stringify(matrix));
    let newAnswer: Array<beliebig> = JSON.parse(JSON.stringify(answer));
    //Positionen austauschen let temp: number = newMatrix[i];
    neueMatrix[i] = neueMatrix[ZielIndex];
    neueMatrix[ZielIndex] = temp;
    neueAntwort.push({ "index": i, "dic": 3 });

    wenn (this.checkIsExist(newMatrix)) {
        gibt null zurück;
    }

    wenn (dieser.checkPass(neueMatrix)) {
        gib eine neue Antwort zurück;
    }
    lass Schritt: beliebig = {};
    Schritt["Matrix"] = neueMatrix;
    Schritt["Antwort"] = neue Antwort;
    Schritte.drücken(Schritt);
}
/**
 *Überprüfen Sie, ob es gelöscht ist*/
private checkPass(Matrix: Array<Zahl>): boolean {
    wenn (Matrix[diese.mRow * diese.mLine - 1] != -1) false zurückgibt;
    für (lass i = 0; i < diese.mRow * diese.mLine - 1; i++) {
        wenn (Matrix[i] != i + 1) {
            gibt false zurück;
        }
    }
    Konsole.log(Matrix)
    gibt true zurück;
}
/**
 *Überprüfen Sie, ob es wiederholt wird */
private checkIsExist(Matrix): boolean {
    wenn (diese.mMapMatrixS[JSON.stringify(matrix)]) {
        gibt true zurück;
    }
    dies.mMapMatrixS[JSON.stringify(matrix)] = "1";
    gibt false zurück;
}