MRS-Algorithmus: Unterschied zwischen den Versionen

Aus MINT.lentner.net
Zur Navigation springen Zur Suche springen
 
(30 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 4: Zeile 4:
 
  /* frei nach Fridrich/SPIEGEL                                    */
 
  /* frei nach Fridrich/SPIEGEL                                    */
 
  /* ************************************************************* */
 
  /* ************************************************************* */
 +
 +
===Die globale Variable "orbit" enthält die [[Orbitkennung]], um inkorrekte Würfelzustände zu kennzeichnen===
 +
let orbit="";
 +
 +
===mrs_WeissOben()===
  
 
  /* Dreht den Wüfel mit der weißen Seite nach oben */
 
  /* Dreht den Wüfel mit der weißen Seite nach oben */
Zeile 19: Zeile 24:
 
  }
 
  }
 
  }
 
  }
 +
 +
===mrs_WeissObenGruenVorne()===
  
 
  /* Dreht die weiße Seite nach oben, die grüne nach vorne (=Standardansicht) */
 
  /* Dreht die weiße Seite nach oben, die grüne nach vorne (=Standardansicht) */
Zeile 33: Zeile 40:
 
  }
 
  }
 
  }   
 
  }   
−
+
 
 +
===mrs_GelbOben()===
 +
 
 
  /* Dreht den Wüfel mit der gelben Seite nach oben */
 
  /* Dreht den Wüfel mit der gelben Seite nach oben */
 
  async function mrs_GelbOben(){
 
  async function mrs_GelbOben(){
Zeile 48: Zeile 57:
 
  }
 
  }
 
  }
 
  }
−
+
 
 +
===mrs_Kante1()===
 +
 
 
  /* Richtet die Kante UF (lässt bereits korrekte Kanten der 1. Ebene unverändert) */
 
  /* Richtet die Kante UF (lässt bereits korrekte Kanten der 1. Ebene unverändert) */
 
  async function mrs_Kante1() {
 
  async function mrs_Kante1() {
−
UI.log("function mrs_Kante1();");
+
UI.log("function mrs_Kante1();");
−
let kanteUF=CUBELETS.findSolvedInPart(CubePart.UF);
+
let kanteUF=CUBELETS.findSolvedInPart(CubePart.UF);
−
let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
+
let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
−
switch(kanteUF.currentPart)
+
switch(kanteUF.currentPart)
−
{
+
{
−
case CubePart.UF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" F E' F E ");  
+
case CubePart.UF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" F E' F E ");  
−
  else await CUBE.move(" ");  
+
  else await CUBE.move(" ");  
−
  break;
+
  break;
−
case CubePart.UR: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" R' E' F E ");  
+
case CubePart.UR: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" R' E' F E ");  
−
  else await CUBE.move(" R' F' ");  
+
  else await CUBE.move(" R' F' ");  
−
  break;
+
  break;
−
case CubePart.BU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" B B D D F F ");  
+
case CubePart.BU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" B B D D F F ");  
−
  else await CUBE.move(" B' E' F' E ");  
+
  else await CUBE.move(" B' E' F' E ");  
−
  break;
+
  break;
−
case CubePart.LU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" L E F' E' ");  
+
case CubePart.LU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" L E F' E' ");  
−
  else await CUBE.move(" L F ");  
+
  else await CUBE.move(" L F ");  
−
  break;
+
  break;
−
case CubePart.LF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E F' E' ");  
+
case CubePart.LF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E F' E' ");  
−
  else await CUBE.move(" F ");  
+
  else await CUBE.move(" F ");  
−
  break;
+
  break;
−
case CubePart.FR: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E' F E ");  
+
case CubePart.FR: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E' F E ");  
−
  else await CUBE.move(" F' ");  
+
  else await CUBE.move(" F' ");  
−
  break;
+
  break;
−
case CubePart.RB: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E' F' E ");  
+
case CubePart.RB: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E' F' E ");  
−
  else await CUBE.move(" E E F E E");  
+
  else await CUBE.move(" E E F E E");  
−
  break;
+
  break;
−
case CubePart.BL: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E F E' ");  
+
case CubePart.BL: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E F E' ");  
−
  else await CUBE.move(" E E F' E E ");  
+
  else await CUBE.move(" E E F' E E ");  
−
  break;
+
  break;
−
case CubePart.FD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" F F ");  
+
case CubePart.FD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" F F ");  
−
  else await CUBE.move(" D' M D M' ");  
+
  else await CUBE.move(" D' M D M' ");  
−
  break;
+
  break;
−
case CubePart.RD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D' F F ");  
+
case CubePart.RD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D' F F ");  
−
  else await CUBE.move(" M D' M' ");  
+
  else await CUBE.move(" M D' M' ");  
−
  break;
+
  break;
−
case CubePart.DB: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D D F F ");  
+
case CubePart.DB: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D D F F ");  
−
  else await CUBE.move(" D M D M' ");  
+
  else await CUBE.move(" D M D M' ");  
−
  break;
+
  break;
−
case CubePart.DL: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D F F ");  
+
case CubePart.DL: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D F F ");  
−
  else await CUBE.move(" M D M' ");  
+
  else await CUBE.move(" M D M' ");  
−
  break;
+
  break;
−
}
+
}
−
}
+
}
 +
 
 +
===mrs_Kantenkreuz1()===
 +
 
 +
/* Richtet das komplette Kantenkreuz der 1. Ebene unabhängig von der Orientierung des Würfels */
 +
async function mrs_Kantenkreuz1() {
 +
UI.log("function mrs_Kantenkreuz1();");
 +
for(i=1; i<5; ++i) { await mrs_Kante1(); await CUBE.move(" y "); }
 +
}
 +
 
 +
===mrs_Ecke1()===
 +
 
 +
/* Richtet die obere, vordere, rechte Ecke UFR (lässt bereits korrekte Ecken der 1. Ebene unverändert) */
 +
async function mrs_Ecke1() {
 +
UI.log("function mrs_Ecke1();");
 +
let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
 +
let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
 +
switch(eckeUFR.currentPart)
 +
{
 +
case CubePart.UFR:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.UP): break;
 +
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F D F' D D R' D R "); break;
 +
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R' D' R D D F D' F' "); break;
 +
}
 +
break;
 +
case CubePart.URB:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B' D' B D' R' D R "); break;
 +
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B' D' B D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R D R' D R' D R "); break;
 +
}
 +
break;
 +
case CubePart.ULF:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" L D L' D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F' D' F D' F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L D L' D' R' D R "); break;
 +
}
 +
break;
 +
case CubePart.UBL:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B D B' D D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B D B' R' D R "); break;
 +
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L' D' L F D' F' "); break;
 +
}
 +
break;
 +
case CubePart.DRF:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D' R' D R "); break;
 +
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" R' D D R D D F D' F' "); break;
 +
}
 +
break;
 +
case CubePart.DBR:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D' R' D D R D D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D D R' D R "); break;
 +
}
 +
break;
 +
case CubePart.DLB:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D D R' D D R D D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" D R' D R "); break;
 +
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" D' F D' F' "); break;
 +
}
 +
break;
 +
case CubePart.DFL:
 +
switch(obenFarbe)
 +
{
 +
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D R' D' D' R D D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D D F D' F' "); break;
 +
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" R' D R "); break;
 +
}
 +
break;
 +
}
 +
}
 +
 
 +
===mrs_Eckenkranz1()===
 +
 
 +
/* Richtet den kompletten Eckenkranz der 1. Ebene unabhängig von der Orientierung des Würfels */
 +
async function mrs_Eckenkranz1() {
 +
UI.log("function mrs_Eckenkranz1();");
 +
for(i=1; i<5; ++i) {await mrs_Ecke1(); await CUBE.move(" y "); }
 +
}
 +
 
 +
===mrs_Ebene1()===
 +
 
 +
/* Richtet die komplette 1. Ebene unabhängig von der Orientierung des Würfels */
 +
async function mrs_Ebene1() {
 +
UI.log("function mrs_Ebene1();");
 +
await mrs_Kantenkreuz1();
 +
await mrs_Eckenkranz1();
 +
}
 +
 
 +
===mrs_Mango()===
 +
 
 +
/* MANGO: transportiert die Kante FD nach FR, lässt sonst die 2. Ebene unversehrt */
 +
/* Produkt der Kommutatoren D'R'DR und F'RFR' *********************************** */
 +
async function mrs_Mango() {
 +
UI.log("function mrs_Mango();");
 +
await CUBE.move(" D' R' D R F' R F R' ");
 +
}
 +
 
 +
===mrs_MangoMirror()===
  
−
/* Richtet das komplette Kantenkreuz der 1. Ebene unabhängig von der Orientierung des Würfels */
+
/* MANGOMIRROR: Spiegelverkehrter Mango, transportiert die Kante RD nach FR, lässt sonst die 2. Ebene unversehrt */
−
async function mrs_Kantenkreuz1() {  
+
async function mrs_MangoMirror() {  
−
UI.log("function mrs_Kantenkreuz1();");
+
UI.log("function mrs_MangoMirror();");
−
for(i=1; i<5; ++i) { await mrs_Kante1(); await CUBE.move(" y "); }
+
await CUBE.move(" D F D' F' R F' R' F ");  
−
}
+
}
  
−
/* Richtet die obere, vordere, rechte Ecke UFR (lässt bereits korrekte Ecken der 1. Ebene unverändert) */
+
===mrs_Kante2()===
−
async function mrs_Ecke1() {
 
−
UI.log("function mrs_Ecke1();");
 
−
let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
 
−
let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
 
−
switch(eckeUFR.currentPart)
 
−
{
 
−
case CubePart.UFR:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.UP): break;
 
−
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F D F' D D R' D R "); break;
 
−
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R' D' R D D F D' F' "); break;
 
−
}
 
−
break;
 
−
case CubePart.URB:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B' D' B D' R' D R "); break;
 
−
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B' D' B D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R D R' D R' D R "); break;
 
−
}
 
−
break;
 
−
case CubePart.ULF:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" L D L' D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F' D' F D' F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L D L' D' R' D R "); break;
 
−
}
 
−
break;
 
−
case CubePart.UBL:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B D B' D D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B D B' R' D R "); break;
 
−
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L' D' L F D' F' "); break;
 
−
}
 
−
break;
 
−
case CubePart.DRF:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D' R' D R "); break;
 
−
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" R' D D R D D F D' F' "); break;
 
−
}
 
−
break;
 
−
case CubePart.DBR:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D' R' D D R D D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D D R' D R "); break;
 
−
}
 
−
break;
 
−
case CubePart.DLB:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D D R' D D R D D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" D R' D R "); break;
 
−
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" D' F D' F' "); break;
 
−
}
 
−
break;
 
−
case CubePart.DFL:
 
−
switch(obenFarbe)
 
−
{
 
−
case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D R' D' D' R D D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D D F D' F' "); break;
 
−
case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" R' D R "); break;
 
−
}
 
−
break;
 
−
}
 
−
}
 
  
−
/* Richtet den kompletten Eckenkranz der 1. Ebene unabhängig von der Orientierung des Würfels */
+
/* Richtet die Kante FR mit Mango oder MangoMirror, bugsiert notfalls vorbereitend eine Kante der 2. in die 3. Ebene */  
−
async function mrs_Eckenkranz1() {  
+
async function mrs_Kante2() {
−
UI.log("function mrs_Eckenkranz1();");
+
UI.log("function mrs_Kante2();");
−
for(i=1; i<5; ++i) {await mrs_Ecke1(); await CUBE.move(" y "); }
+
let kanteFR=CUBELETS.findSolvedInPart(CubePart.FR);
−
}
+
let vorneFarbe=CUBELETS.findCurrentlyInPart(CubePart.F).getColorAt(CubeFace.FRONT);
 +
switch(kanteFR.currentPart)
 +
{
 +
case CubePart.LF: await CUBE.move(" y' ");
 +
  await mrs_Mango();
 +
  await CUBE.move(" y ");
 +
  await mrs_Kante2();
 +
  break;
 +
case CubePart.FR: if(vorneFarbe==CUBELETS.findCurrentlyInPart(CubePart.FR).getColorAt(CubeFace.FRONT)) break;
 +
  await mrs_Mango();
 +
  await mrs_Kante2();
 +
  break;
 +
case CubePart.RB: await CUBE.move(" y ");
 +
  await mrs_Mango();
 +
  await CUBE.move(" y' ");
 +
  await mrs_Kante2();
 +
  break;
 +
case CubePart.BL: await CUBE.move(" y y ");
 +
  await mrs_Mango();
 +
  await CUBE.move(" y y ");  
 +
  await mrs_Kante2();
 +
  break;
 +
case CubePart.FD: if(kanteFR.getColorAt(CubeFace.FRONT)==vorneFarbe) await mrs_Mango();
 +
  else { await CUBE.move(" D "); await mrs_MangoMirror(); }
 +
  break;
 +
case CubePart.RD: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) await mrs_MangoMirror();
 +
  else { await CUBE.move(" D' "); await mrs_Mango(); }
 +
  break;
 +
case CubePart.DB: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) { await CUBE.move(" D' "); await mrs_MangoMirror(); }
 +
  else { await CUBE.move(" D D "); await mrs_Mango(); } 
 +
  break;
 +
case CubePart.DL: if(kanteFR.getColorAt(CubeFace.LEFT)==vorneFarbe) { await CUBE.move(" D "); await mrs_Mango(); }
 +
  else { await CUBE.move(" D D "); await mrs_MangoMirror(); } 
 +
  break;
 +
}
 +
}
  
−
/* Richtet die komplette 1. Ebene unabhängig von der Orientierung des Würfels */
+
===mrs_Ebene2()===
−
async function mrs_Ebene1() {
 
−
UI.log("function mrs_Ebene1();");
 
−
await mrs_Kantenkreuz1();
 
−
await mrs_Eckenkranz1();
 
−
}
 
  
−
/* Bringt den Würfel in Standardlage (WEIß oben, GRÜN vorne) und richtet die 1. Ebene */
+
/* Richtet die komplette 2. Ebene unabhängig von der Orientierung des Würfels (die 1. Ebene muss korrekt sein) */
−
async function mrs_WeisseEbene1() {  
+
async function mrs_Ebene2() {  
−
UI.log("function mrs_WeisseEbene1();");
+
UI.log("function mrs_Ebene2();");
−
await mrs_WeissObenGruenVorne();  
+
for(i=1; i<5; ++i) { await mrs_Kante2(); await CUBE.move(" y "); }
−
await mrs_Ebene1();  
+
}
−
}
 
  
−
/* MANGO: transportiert die Kante FD nach FR, lässt sonst die 2. Ebene unversehrt */
+
===mrs_Bingo()===
−
/* Produkt der Kommutatoren D'R'DR und F'RFR' *********************************** */
 
−
async function mrs_Mango() {
 
−
UI.log("function mrs_Mango();");
 
−
await CUBE.move(" D' R' D R F' R F R' ");
 
−
}
 
  
−
/* MANGOMIRROR: Spiegelverkehrter Mango, transportiert die Kante RD nach FR, lässt sonst die 2. Ebene unversehrt */
+
/* BINGO: Rotiert drei Kantenwürfel in der 1. Ebene, lässt Ebene 2 und 3 unversehrt */
−
async function mrs_MangoMirror() {  
+
/* Produkt der Kommutatoren RUR'U' und R'FRF' ************************************* */
−
UI.log("function mrs_MangoMirror();");
+
async function mrs_Bingo() {
−
await CUBE.move(" D F D' F' R F' R' F ");  
+
UI.log("function mrs_Bingo();");
−
}
+
await CUBE.move(" R U R' U' R' F R F' ");
 +
}
  
−
/* Richtet die Kante FR mit Mango oder MangoMirror, bugsiert notfalls vorbereitend eine Kante der 2. in die 3. Ebene */
+
===mrs_Kanten3Positionieren()===
−
async function mrs_Kante2() {
 
−
UI.log("function mrs_Kante2();");
 
−
let kanteFR=CUBELETS.findSolvedInPart(CubePart.FR);
 
−
let vorneFarbe=CUBELETS.findCurrentlyInPart(CubePart.F).getColorAt(CubeFace.FRONT);
 
−
switch(kanteFR.currentPart)
 
−
{
 
−
case CubePart.LF: await CUBE.move(" y' ");
 
−
  await mrs_Mango();
 
−
  await CUBE.move(" y ");
 
−
  await mrs_Kante2();
 
−
  break;
 
−
case CubePart.FR: if(vorneFarbe==CUBELETS.findCurrentlyInPart(CubePart.FR).getColorAt(CubeFace.FRONT)) break;
 
−
  await mrs_Mango();
 
−
  await mrs_Kante2();
 
−
  break;
 
−
case CubePart.RB: await CUBE.move(" y ");
 
−
  await mrs_Mango();
 
−
  await CUBE.move(" y' ");
 
−
  await mrs_Kante2();
 
−
  break;
 
−
case CubePart.BL: await CUBE.move(" y y ");
 
−
  await mrs_Mango();
 
−
  await CUBE.move(" y y ");
 
−
  await mrs_Kante2();
 
−
  break;
 
−
case CubePart.FD: if(kanteFR.getColorAt(CubeFace.FRONT)==vorneFarbe) await mrs_Mango();
 
−
  else { await CUBE.move(" D "); await mrs_MangoMirror(); }
 
−
  break;
 
−
case CubePart.RD: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) await mrs_MangoMirror();
 
−
  else { await CUBE.move(" D' "); await mrs_Mango(); }
 
−
  break;
 
−
case CubePart.DB: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) { await CUBE.move(" D' "); await mrs_MangoMirror(); }
 
−
  else { await CUBE.move(" D D "); await mrs_Mango(); } 
 
−
  break;
 
−
case CubePart.DL: if(kanteFR.getColorAt(CubeFace.LEFT)==vorneFarbe) { await CUBE.move(" D "); await mrs_Mango(); }
 
−
  else { await CUBE.move(" D D "); await mrs_MangoMirror(); } 
 
−
  break;
 
−
}
 
−
}
 
  
−
/* Richtet die komplette 2. Ebene unabhängig von der Orientierung des Würfels (die 1. Ebene muss korrekt sein) */
+
/* Positioniert alle Kantenwürfel der 1. Ebene durch BINGO */
−
async function mrs_Ebene2() {  
+
async function mrs_Kanten3Positionieren() {
−
UI.log("function mrs_Ebene2();");
+
UI.log("function mrs_Kanten3Positionieren();");
−
for(i=1; i<5; ++i) { await mrs_Kante2(); await CUBE.move(" y "); }  
+
//Kante LU Positionieren
−
}
+
let kanteLU=CUBELETS.findSolvedInPart(CubePart.LU);
 +
switch(kanteLU.currentPart){
 +
case CubePart.LU: break;
 +
case CubePart.BU: await CUBE.move(" U' ");
 +
  break;
 +
case CubePart.UR: await CUBE.move(" U U ");
 +
  break;
 +
case CubePart.UF: await CUBE.move(" U ");
 +
  break;
 +
}
 +
//Kante BU Positionieren
 +
let kanteBU=CUBELETS.findSolvedInPart(CubePart.BU);
 +
switch(kanteBU.currentPart){
 +
case CubePart.BU: break;
 +
case CubePart.UR: await mrs_Bingo();
 +
  break;
 +
case CubePart.UF: await mrs_Bingo();
 +
  await mrs_Bingo();
 +
  break;
 +
}
 +
//Kante UR Positionieren
 +
let kanteUR=CUBELETS.findSolvedInPart(CubePart.UR);
 +
switch(kanteUR.currentPart){
 +
case CubePart.UR: break;
 +
case CubePart.UF: await CUBE.move(" U ");
 +
  await mrs_Bingo();  
 +
  await mrs_Bingo();
 +
  await CUBE.move(" U U ");
 +
  break;
 +
}
 +
}
  
−
/* Richtet 1. und 2. Ebene in Standardlage */
+
===mrs_Menno()===
−
async function mrs_WeisseEbene2() {
 
−
UI.log("function mrs_WeisseEbene2();");
 
−
await mrs_WeisseEbene1();
 
−
await mrs_Ebene2();
 
−
}
 
  
−
/* BINGO: Rotiert drei Kantenwürfel in der 1. Ebene, lässt Ebene 2 und 3 unversehrt */
+
/* MENNO: Kippt die Kante UR, lässt alle anderen Würfel der 1. Ebene unverändert ** */  
−
/* Produkt der Kommutatoren RUR'U' und R'FRF' ************************************* */
+
/* Lässt bei zweimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert */
−
async function mrs_Bingo() {
+
/* MENNO ist die 4. Potenz von ER. ER hat die Ordung 8 **************************** */
−
UI.log("function mrs_Bingo();");
+
async function mrs_Menno() {
−
await CUBE.move(" R U R' U' R' F R F' ");
+
UI.log("function mrs_Menno();");
−
}
+
await CUBE.move(" E R E R E R E R ");
 +
}
  
−
/* Positioniert alle Kantenwürfel der 1. Ebene durch BINGO */
+
===mrs_Kanten3Drehen()===
−
async function mrs_Kanten3Positionieren() {
 
−
UI.log("function mrs_Kanten3Positionieren();");
 
−
//Kante LU Positionieren
 
−
let kanteLU=CUBELETS.findSolvedInPart(CubePart.LU);
 
−
switch(kanteLU.currentPart){
 
−
case CubePart.LU: break;
 
−
case CubePart.BU: await CUBE.move(" U' ");
 
−
  break;
 
−
case CubePart.UR: await CUBE.move(" U U ");
 
−
  break;
 
−
case CubePart.UF: await CUBE.move(" U ");
 
−
  break;
 
−
}
 
−
//Kante BU Positionieren
 
−
let kanteBU=CUBELETS.findSolvedInPart(CubePart.BU);
 
−
switch(kanteBU.currentPart){
 
−
case CubePart.BU: break;
 
−
case CubePart.UR: await mrs_Bingo();
 
−
  break;
 
−
case CubePart.UF: await mrs_Bingo();
 
−
  await mrs_Bingo();
 
−
  break;
 
−
}
 
−
//Kante UR Positionieren
 
−
let kanteUR=CUBELETS.findSolvedInPart(CubePart.UR);
 
−
switch(kanteUR.currentPart){
 
−
case CubePart.UR: break;
 
−
case CubePart.UF: await CUBE.move(" U ");
 
−
  await mrs_Bingo();
 
−
  await mrs_Bingo();
 
−
  await CUBE.move(" U U ");
 
−
  break;
 
−
}
 
−
}
 
  
−
/* MENNO: Kippt die Kante UR, lässt alle anderen Würfel der 1. Ebene unverändert ** */
+
async function mrs_Kanten3Drehen() {
−
/* Lässt bei zweimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert */
+
UI.log("function mrs_Kanten3Drehen();");
−
/* MENNO ist die 4. Potenz von ER. ER hat die Ordung 8 **************************** */
+
let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
−
async function mrs_Menno() {
+
let anzahl_kipp=0;
−
UI.log("function mrs_Menno();");
+
//Kante UR evtl. Drehen
−
await CUBE.move(" E R E R E R E R ");
+
for(i=1; i<5; ++i) {
−
}
+
let obenKantenfarbe=CUBELETS.findCurrentlyInPart(CubePart.UR).getColorAt(CubeFace.UP);
 +
if(obenWandfarbe!=obenKantenfarbe) { await mrs_Menno(); ++anzahl_kipp; }
 +
await CUBE.move(" U ");
 +
}
 +
//Falls ungerade viele Mennos, ist der Würfel inkorrekt.
 +
//Dann wird UR gekippt, damit 2. und 3. Ebene unversehrt bleibt.
 +
if(anzahl_kipp % 2 == 1) { await mrs_Menno(); orbit = "1" + orbit; } else orbit = "0" + orbit;
 +
}
  
−
/* Richtet die Orientierung aller Kantenwürfel der 1. Ebene durch MENNO */
+
===mrs_Claudia()===
−
async function mrs_Kanten3Drehen() {
 
−
UI.log("function mrs_Kanten3Drehen();");
 
−
let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
 
−
//Kante UR evtl. Drehen
 
−
for(i=1; i<5; ++i) {
 
−
let obenKantenfarbe=CUBELETS.findCurrentlyInPart(CubePart.UR).getColorAt(CubeFace.UP);
 
−
if(obenWandfarbe!=obenKantenfarbe) await mrs_Menno();
 
−
await CUBE.move(" U ");
 
−
}
 
−
}
 
  
−
/* CLAUDIA: Rotiert 3 Eckenwürfel der 1. Ebene, lässt den Rest von Ebene 1 sowie die 2. und 3. Ebene unversehrt */
+
/* CLAUDIA: Rotiert 3 Eckenwürfel der 1. Ebene, lässt den Rest von Ebene 1 sowie die 2. und 3. Ebene unversehrt */
−
async function mrs_Claudia() {
+
async function mrs_Claudia() {
−
UI.log("function mrs_Claudia();");
+
UI.log("function mrs_Claudia();");
−
await CUBE.move(" L' U R U' L U R' U' ");
+
await CUBE.move(" L' U R U' L U R' U' ");
−
}
+
}
  
−
/* Positioniert alle Eckenwürfel der 1. Ebene durch CLAUDIA */
+
===mrs_Ecken3Positionieren()===
−
async function mrs_Ecken3Positionieren() {
 
−
UI.log("function mrs_Ecken3Positionieren();");
 
−
let found=false;
 
−
for(i=1; i<5; ++i){
 
−
let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
 
−
if(eckeUFR.currentPart==CubePart.UFR) {
 
−
found=true;
 
−
while(CUBELETS.findSolvedInPart(CubePart.ULF).currentPart!=CubePart.ULF) await mrs_Claudia();
 
−
}
 
−
if(found) break;
 
−
await CUBE.move(" y ");
 
−
}
 
−
if(!found) {
 
−
await mrs_Claudia();
 
−
while(CUBELETS.findSolvedInPart(CubePart.UFR).currentPart!=CubePart.UFR) await CUBE.move(" y ");
 
−
while(CUBELETS.findSolvedInPart(CubePart.ULF).currentPart!=CubePart.ULF) await mrs_Claudia();
 
−
}
 
−
}
 
  
−
/* BENNO: Kippt das Eck UFR um den Betrag 1, lässt alle anderen Würfel der 1. Ebene unverändert */
+
async function mrs_Ecken3Positionieren() {
−
/* Lässt bei dreimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert *********** */
+
UI.log("function mrs_Ecken3Positionieren();");
−
/* BENNO ist die 2. Potenz des Kommutators RF'R'F. Der Kommutator RF'R'F hat die Ordung 6 ***** */
+
//Richtet UFR
−
async function mrs_Benno() {
+
let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
−
UI.log("function mrs_Benno();");
+
switch(eckeUFR.currentPart)
−
await CUBE.move(" R F' R' F R F' R' F ");
+
{
−
}
+
case CubePart.UFR: break;
 +
case CubePart.URB: await CUBE.move(" U' ");
 +
  await mrs_Claudia();
 +
  await CUBE.move(" U ");
 +
  break;
 +
case CubePart.UBL: await CUBE.move(" U' ");
 +
  await mrs_Claudia();
 +
  await mrs_Claudia();
 +
  await CUBE.move(" U ");
 +
  break;
 +
case CubePart.ULF: await CUBE.move(" U U ");
 +
  await mrs_Claudia();  
 +
  await mrs_Claudia();
 +
  await CUBE.move(" U U ");
 +
  break;
 +
}
 +
//Richtet ULF
 +
let eckeULF=CUBELETS.findSolvedInPart(CubePart.ULF);
 +
switch(eckeULF.currentPart)
 +
{
 +
                case CubePart.URB: await mrs_Claudia(); break;
 +
                case CubePart.UBL: await mrs_Claudia(); await mrs_Claudia(); break;
 +
                case CubePart.ULF: break;
 +
}
 +
//UBL und URB werden nicht gerichtet. Sind korrekt oder auch nicht.
 +
if(CUBELETS.findSolvedInPart(CubePart.UBL).currentPart==CubePart.UBL) orbit = "0" + orbit; else orbit = "1" + orbit;
 +
}
  
−
/* Kippt alle Ecken der 1. Ebene durch BENNO */
+
===mrs_Benno()===
−
async function mrs_Ecken3Drehen() {
+
 
−
UI.log("function mrs_Ecken3Drehen();");
+
/* BENNO: Kippt das Eck UFR um den Betrag 1, lässt alle anderen Würfel der 1. Ebene unverändert */
−
let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
+
/* Lässt bei dreimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert *********** */
−
for(i=1; i<5; ++i){
+
/* BENNO ist die 2. Potenz des Kommutators RF'R'F. Der Kommutator RF'R'F hat die Ordung 6 ***** */
−
let eckeUFR=CUBELETS.findCurrentlyInPart(CubePart.UFR);
+
async function mrs_Benno() {
−
while(eckeUFR.getColorAt(CubeFace.UP)!=obenWandfarbe) await mrs_Benno();
+
UI.log("function mrs_Benno();");
−
await CUBE.move(" U ");
+
await CUBE.move(" R F' R' F R F' R' F ");
−
}
+
  }
−
}
+
 
 +
===mrs_Ecken3Drehen()===
 +
 
 +
async function mrs_Ecken3Drehen() {
 +
UI.log("function mrs_Ecken3Drehen();");
 +
let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
 +
let anzahl_kipp=0;
 +
for(i=1; i<5; ++i){
 +
let eckeUFR=CUBELETS.findCurrentlyInPart(CubePart.UFR);
 +
while(eckeUFR.getColorAt(CubeFace.UP)!=obenWandfarbe) {
 +
await mrs_Benno();
 +
++anzahl_kipp;
 +
}
 +
await CUBE.move(" U ");
 +
}
 +
//Wurde Benno nicht =0 MOD 3 oft angewandt, ist der Würfel nicht korrekt.
 +
//UFR wird dann noch entsprechend oft weitergekippt, damit 2. und 3. Ebene unversehrt bleibt.
 +
let j=0; for(i=anzahl_kipp; i%3!=0; ++i) { await mrs_Benno(); ++j; } orbit=orbit + j.toString();
 +
}
 +
 
 +
===mrs_Ebene3()===
 +
 
 +
/* Richtet die komplette 3. Ebene unabhängig von der Orientierung des Würfels (1. und 2. Ebene müssen korrekt sein) */
 +
async function mrs_Ebene3() {
 +
UI.log("function mrs_Ebene3();");
 +
await mrs_Kanten3Positionieren();
 +
await mrs_Kanten3Drehen();
 +
await mrs_Ecken3Positionieren();
 +
await mrs_Ecken3Drehen();
 +
}
  
−
/* Richtet die komplette 3. Ebene unabhängig von der Orientierung des Würfels (1. und 2. Ebene müssen korrekt sein) */
+
===Mögliche Hauptprogrammaufrufe===
−
async function mrs_Ebene3() {
 
−
UI.log("function mrs_Ebene3();");
 
−
await mrs_Kanten3Positionieren();
 
−
await mrs_Kanten3Drehen();
 
−
await mrs_Ecken3Positionieren();
 
−
await mrs_Ecken3Drehen();
 
−
}
 
  
−
/* Richtet den kompletten Würfel in Standardlage */
+
//Main: Beliebiger Würfel
−
async function mrs_WeisseEbene3() {
+
//await mrs_Ebene1();  
−
UI.log("function mrs_WeisseEbene3();");
+
//await mrs_Ebene2();
−
await mrs_WeisseEbene2();  
+
//await CUBE.move(" x x ");
−
await mrs_GelbOben();  
+
//await mrs_Ebene3();
−
await mrs_Ebene3();  
 
−
await mrs_WeissObenGruenVorne();
 
−
}
 
  
−
//Main
+
//Main: Würfel in Standardlage und Ausgabe der Orbitkennung
−
await mrs_WeisseEbene3();
+
await mrs_WeissObenGruenVorne();
 +
await mrs_Ebene1();
 +
await mrs_Ebene2();
 +
await CUBE.move(" x x y y ");
 +
await mrs_Ebene3();
 +
UI.log("Orbitkennung:" + orbit);

Aktuelle Version vom 8. April 2021, 22:31 Uhr

/* ************************************************************* */
/* MRS ALGORITMUS                                                */
/* Wolfgang Lentner, Städtische Realschule für Mädchen Rosenheim */
/* frei nach Fridrich/SPIEGEL                                    */
/* ************************************************************* */

Die globale Variable "orbit" enthält die Orbitkennung, um inkorrekte Würfelzustände zu kennzeichnen

let orbit="";

mrs_WeissOben()

/* Dreht den Wüfel mit der weißen Seite nach oben */
async function mrs_WeissOben() {
	UI.log("function mrs_WeissOben();");
	let weisseMitte=CUBELETS.findInitiallyInPart(CubePart.U);
	switch(weisseMitte.currentPart)
	{
		case CubePart.U: break;
		case CubePart.F: await CUBE.move(" x "); break;
		case CubePart.D: await CUBE.move(" x x "); break;
		case CubePart.B: await CUBE.move(" x' "); break;
		case CubePart.R: await CUBE.move(" z' "); break;
		case CubePart.L: await CUBE.move(" z "); break;
	}
}

mrs_WeissObenGruenVorne()

/* Dreht die weiße Seite nach oben, die grüne nach vorne (=Standardansicht) */
async function mrs_WeissObenGruenVorne() {
	UI.log("function mrs_WeissObenGruenVorne();");
	await mrs_WeissOben();
	let grueneMitte=CUBELETS.findInitiallyInPart(CubePart.F);
	switch(grueneMitte.currentPart)
	{
		case CubePart.F: break;
		case CubePart.R: await CUBE.move(" y "); break;
		case CubePart.B: await CUBE.move(" y y "); break;
		case CubePart.L: await CUBE.move(" y' "); break;
	}
}

mrs_GelbOben()

/* Dreht den Wüfel mit der gelben Seite nach oben */
async function mrs_GelbOben(){
	UI.log("function mrs_GelbOben();");
	let gelbeMitte=CUBELETS.findInitiallyInPart(CubePart.D);
	switch(gelbeMitte.currentPart)
	{
		case CubePart.U: break;
		case CubePart.F: await CUBE.move(" x "); break;
		case CubePart.D: await CUBE.move(" x x "); break;
		case CubePart.B: await CUBE.move(" x' "); break;
		case CubePart.R: await CUBE.move(" z' "); break;
		case CubePart.L: await CUBE.move(" z "); break;
	}
}

mrs_Kante1()

/* Richtet die Kante UF (lässt bereits korrekte Kanten der 1. Ebene unverändert) */
async function mrs_Kante1() {
	UI.log("function mrs_Kante1();");
	let kanteUF=CUBELETS.findSolvedInPart(CubePart.UF);
	let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
	switch(kanteUF.currentPart)
	{
		case CubePart.UF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" F E' F E "); 
				  else await CUBE.move(" "); 
				  break;
		case CubePart.UR: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" R' E' F E "); 
				  else await CUBE.move(" R' F' "); 
				  break;
		case CubePart.BU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" B B D D F F "); 
				  else await CUBE.move(" B' E' F' E "); 
				  break;
		case CubePart.LU: if(kanteUF.getColorAt(CubeFace.UP)==obenFarbe) await CUBE.move(" L E F' E' "); 
				  else await CUBE.move(" L F "); 
				  break;
		case CubePart.LF: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E F' E' "); 
				  else await CUBE.move(" F "); 
				  break;
		case CubePart.FR: if(kanteUF.getColorAt(CubeFace.FRONT)==obenFarbe) await CUBE.move(" E' F E "); 
				  else await CUBE.move(" F' "); 
				  break;
		case CubePart.RB: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E' F' E "); 
				  else await CUBE.move(" E E F E E"); 
				  break;
		case CubePart.BL: if(kanteUF.getColorAt(CubeFace.BACK)==obenFarbe) await CUBE.move(" E F E' "); 
				  else await CUBE.move(" E E F' E E "); 
				  break;
		case CubePart.FD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" F F "); 
				  else await CUBE.move(" D' M D M' "); 
				  break;
		case CubePart.RD: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D' F F "); 
				  else await CUBE.move(" M D' M' "); 
				  break;
		case CubePart.DB: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D D F F "); 
				  else await CUBE.move(" D M D M' "); 
				  break;
		case CubePart.DL: if(kanteUF.getColorAt(CubeFace.DOWN)==obenFarbe) await CUBE.move(" D F F "); 
				  else await CUBE.move(" M D M' "); 
				  break;
	}
}

mrs_Kantenkreuz1()

/* Richtet das komplette Kantenkreuz der 1. Ebene unabhängig von der Orientierung des Würfels */
async function mrs_Kantenkreuz1() { 
	UI.log("function mrs_Kantenkreuz1();");
	for(i=1; i<5; ++i) { await mrs_Kante1(); await CUBE.move(" y "); }
}

mrs_Ecke1()

/* Richtet die obere, vordere, rechte Ecke UFR (lässt bereits korrekte Ecken der 1. Ebene unverändert) */
async function mrs_Ecke1() {
	UI.log("function mrs_Ecke1();");
	let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
	let obenFarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
	switch(eckeUFR.currentPart)
	{
		case CubePart.UFR: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.UP): break;
				case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F D F' D D R' D R "); break;
				case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R' D' R D D F D' F' "); break;
			}
			break;
		case CubePart.URB: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B' D' B D' R' D R "); break;
				case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B' D' B D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" R D R' D R' D R "); break;
			}
			break;
		case CubePart.ULF: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" L D L' D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" F' D' F D' F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L D L' D' R' D R "); break;
			}
			break;
		case CubePart.UBL: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.UP): await CUBE.move(" B D B' D D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" B D B' R' D R "); break;
				case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" L' D' L F D' F' "); break;
			}
			break;
		case CubePart.DRF: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D' R' D R "); break;
				case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" R' D D R D D F D' F' "); break;
			}
			break;
		case CubePart.DBR: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D' R' D D R D D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.RIGHT): await CUBE.move(" D D R' D R "); break;
			}
			break;
		case CubePart.DLB: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D D R' D D R D D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.BACK): await CUBE.move(" D R' D R "); break;
				case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" D' F D' F' "); break;
			}
			break;
		case CubePart.DFL: 
			switch(obenFarbe)
			{
				case eckeUFR.getColorAt(CubeFace.DOWN): await CUBE.move(" D R' D' D' R D D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.FRONT): await CUBE.move(" D D F D' F' "); break;
				case eckeUFR.getColorAt(CubeFace.LEFT): await CUBE.move(" R' D R "); break;
			}
			break;
	}
}

mrs_Eckenkranz1()

/* Richtet den kompletten Eckenkranz der 1. Ebene unabhängig von der Orientierung des Würfels */
async function mrs_Eckenkranz1() { 
	UI.log("function mrs_Eckenkranz1();");
	for(i=1; i<5; ++i) {await mrs_Ecke1(); await CUBE.move(" y "); }
}

mrs_Ebene1()

/* Richtet die komplette 1. Ebene unabhängig von der Orientierung des Würfels */
async function mrs_Ebene1() { 
	UI.log("function mrs_Ebene1();");
	await mrs_Kantenkreuz1();
	await mrs_Eckenkranz1();
}

mrs_Mango()

/* MANGO: transportiert die Kante FD nach FR, lässt sonst die 2. Ebene unversehrt */
/* Produkt der Kommutatoren D'R'DR und F'RFR' *********************************** */
async function mrs_Mango() { 
	UI.log("function mrs_Mango();");
	await CUBE.move(" D' R' D R F' R F R' "); 
}

mrs_MangoMirror()

/* MANGOMIRROR: Spiegelverkehrter Mango, transportiert die Kante RD nach FR, lässt sonst die 2. Ebene unversehrt */
async function mrs_MangoMirror() { 
	UI.log("function mrs_MangoMirror();");
	await CUBE.move(" D F D' F' R F' R' F "); 
}

mrs_Kante2()

/* Richtet die Kante FR mit Mango oder MangoMirror, bugsiert notfalls vorbereitend eine Kante der 2. in die 3. Ebene */ 
async function mrs_Kante2() {
	UI.log("function mrs_Kante2();");
	let kanteFR=CUBELETS.findSolvedInPart(CubePart.FR);
	let vorneFarbe=CUBELETS.findCurrentlyInPart(CubePart.F).getColorAt(CubeFace.FRONT);
	switch(kanteFR.currentPart)
	{
		case CubePart.LF: await CUBE.move(" y' "); 
						  await mrs_Mango(); 
						  await CUBE.move(" y "); 
						  await mrs_Kante2(); 
						  break;
		case CubePart.FR: if(vorneFarbe==CUBELETS.findCurrentlyInPart(CubePart.FR).getColorAt(CubeFace.FRONT)) break;
						  await mrs_Mango(); 
						  await mrs_Kante2(); 
						  break;
		case CubePart.RB: await CUBE.move(" y "); 
						  await mrs_Mango(); 
						  await CUBE.move(" y' "); 
						  await mrs_Kante2(); 
						  break;
		case CubePart.BL: await CUBE.move(" y y "); 
						  await mrs_Mango(); 
						  await CUBE.move(" y y "); 
						  await mrs_Kante2(); 
						  break;
		case CubePart.FD: if(kanteFR.getColorAt(CubeFace.FRONT)==vorneFarbe) await mrs_Mango(); 
						  else { await CUBE.move(" D "); await mrs_MangoMirror(); } 
						  break;
		case CubePart.RD: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) await mrs_MangoMirror(); 
						  else { await CUBE.move(" D' "); await mrs_Mango(); } 
						  break;
		case CubePart.DB: if(kanteFR.getColorAt(CubeFace.DOWN)==vorneFarbe) { await CUBE.move(" D' "); await mrs_MangoMirror(); } 
						  else { await CUBE.move(" D D "); await mrs_Mango(); }  
						  break;	
		case CubePart.DL: if(kanteFR.getColorAt(CubeFace.LEFT)==vorneFarbe) { await CUBE.move(" D "); await mrs_Mango(); } 
						  else { await CUBE.move(" D D "); await mrs_MangoMirror(); }  
						  break;
	}
}

mrs_Ebene2()

/* Richtet die komplette 2. Ebene unabhängig von der Orientierung des Würfels (die 1. Ebene muss korrekt sein) */
async function mrs_Ebene2() { 
	UI.log("function mrs_Ebene2();");
	for(i=1; i<5; ++i) { await mrs_Kante2(); await CUBE.move(" y "); } 
}

mrs_Bingo()

/* BINGO: Rotiert drei Kantenwürfel in der 1. Ebene, lässt Ebene 2 und 3 unversehrt */
/* Produkt der Kommutatoren RUR'U' und R'FRF' ************************************* */
async function mrs_Bingo() {
	UI.log("function mrs_Bingo();");
	await CUBE.move(" R U R' U' R' F R F' ");
}

mrs_Kanten3Positionieren()

/* Positioniert alle Kantenwürfel der 1. Ebene durch BINGO */
async function mrs_Kanten3Positionieren() {
	UI.log("function mrs_Kanten3Positionieren();");
	//Kante LU Positionieren
	let kanteLU=CUBELETS.findSolvedInPart(CubePart.LU);
	switch(kanteLU.currentPart){
		case CubePart.LU: break;	
		case CubePart.BU: await CUBE.move(" U' "); 
				  break;
		case CubePart.UR: await CUBE.move(" U U "); 
				  break;
		case CubePart.UF: await CUBE.move(" U "); 
				  break;
	}
	//Kante BU Positionieren
	let kanteBU=CUBELETS.findSolvedInPart(CubePart.BU);
	switch(kanteBU.currentPart){
		case CubePart.BU: break;	
		case CubePart.UR: await mrs_Bingo(); 
				  break;
		case CubePart.UF: await mrs_Bingo(); 
				  await mrs_Bingo(); 
				  break;
	}
	//Kante UR Positionieren
	let kanteUR=CUBELETS.findSolvedInPart(CubePart.UR);
	switch(kanteUR.currentPart){
		case CubePart.UR: break;
		case CubePart.UF: await CUBE.move(" U "); 
				  await mrs_Bingo(); 
				  await mrs_Bingo(); 
				  await CUBE.move(" U U ");
				  break;
	}
}

mrs_Menno()

/* MENNO: Kippt die Kante UR, lässt alle anderen Würfel der 1. Ebene unverändert ** */ 
/* Lässt bei zweimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert */
/* MENNO ist die 4. Potenz von ER. ER hat die Ordung 8 **************************** */
async function mrs_Menno() {
	UI.log("function mrs_Menno();");
	await CUBE.move(" E R E R E R E R ");
}

mrs_Kanten3Drehen()

async function mrs_Kanten3Drehen() {
	UI.log("function mrs_Kanten3Drehen();");
	let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
	let anzahl_kipp=0;
	//Kante UR evtl. Drehen
	for(i=1; i<5; ++i) {
		let obenKantenfarbe=CUBELETS.findCurrentlyInPart(CubePart.UR).getColorAt(CubeFace.UP);
		if(obenWandfarbe!=obenKantenfarbe) { await mrs_Menno(); ++anzahl_kipp; }
		await CUBE.move(" U ");
	}
	//Falls ungerade viele Mennos, ist der Würfel inkorrekt. 
	//Dann wird UR gekippt, damit 2. und 3. Ebene unversehrt bleibt.
	if(anzahl_kipp % 2 == 1) { await mrs_Menno(); orbit = "1" + orbit; } else orbit = "0" + orbit;
}

mrs_Claudia()

/* CLAUDIA: Rotiert 3 Eckenwürfel der 1. Ebene, lässt den Rest von Ebene 1 sowie die 2. und 3. Ebene unversehrt */
async function mrs_Claudia() {
	UI.log("function mrs_Claudia();");
	await CUBE.move(" L' U R U' L U R' U' ");
}

mrs_Ecken3Positionieren()

async function mrs_Ecken3Positionieren() {
	UI.log("function mrs_Ecken3Positionieren();");
	//Richtet UFR
	let eckeUFR=CUBELETS.findSolvedInPart(CubePart.UFR);
	switch(eckeUFR.currentPart)
	{
		case CubePart.UFR: break;
		case CubePart.URB: await CUBE.move(" U' ");
						   await mrs_Claudia();
						   await CUBE.move(" U ");
						   break;
		case CubePart.UBL: await CUBE.move(" U' ");
						   await mrs_Claudia(); 
						   await mrs_Claudia();
						   await CUBE.move(" U ");
						   break;
		case CubePart.ULF: await CUBE.move(" U U ");
						   await mrs_Claudia(); 
						   await mrs_Claudia();
						   await CUBE.move(" U U ");
						   break;
	}
	//Richtet ULF
	let eckeULF=CUBELETS.findSolvedInPart(CubePart.ULF);
	switch(eckeULF.currentPart)
	{
                case CubePart.URB: await mrs_Claudia(); break;
                case CubePart.UBL: await mrs_Claudia(); await mrs_Claudia(); break;
                case CubePart.ULF: break;
	}
	//UBL und URB werden nicht gerichtet. Sind korrekt oder auch nicht.
	if(CUBELETS.findSolvedInPart(CubePart.UBL).currentPart==CubePart.UBL) orbit = "0" + orbit; else orbit = "1" + orbit;
}

mrs_Benno()

/* BENNO: Kippt das Eck UFR um den Betrag 1, lässt alle anderen Würfel der 1. Ebene unverändert */ 
/* Lässt bei dreimaliger Anwendung auch alle Würfel der 2. und 3. Ebene unverändert *********** */
/* BENNO ist die 2. Potenz des Kommutators RF'R'F. Der Kommutator RF'R'F hat die Ordung 6 ***** */
async function mrs_Benno() {
	UI.log("function mrs_Benno();");
	await CUBE.move(" R F' R' F R F' R' F ");
 }

mrs_Ecken3Drehen()

async function mrs_Ecken3Drehen() {
	UI.log("function mrs_Ecken3Drehen();");
	let obenWandfarbe=CUBELETS.findCurrentlyInPart(CubePart.U).getColorAt(CubeFace.UP);
	let anzahl_kipp=0;
	for(i=1; i<5; ++i){
		let eckeUFR=CUBELETS.findCurrentlyInPart(CubePart.UFR);
		while(eckeUFR.getColorAt(CubeFace.UP)!=obenWandfarbe) {
			await mrs_Benno();
			++anzahl_kipp;
		}
		await CUBE.move(" U ");
	}
	//Wurde Benno nicht =0 MOD 3 oft angewandt, ist der Würfel nicht korrekt.
	//UFR wird dann noch entsprechend oft weitergekippt, damit 2. und 3. Ebene unversehrt bleibt.
	let j=0; for(i=anzahl_kipp; i%3!=0; ++i) { await mrs_Benno(); ++j; } orbit=orbit + j.toString();
}

mrs_Ebene3()

/* Richtet die komplette 3. Ebene unabhängig von der Orientierung des Würfels (1. und 2. Ebene müssen korrekt sein) */
async function mrs_Ebene3() { 
	UI.log("function mrs_Ebene3();");
	await mrs_Kanten3Positionieren();
	await mrs_Kanten3Drehen();
	await mrs_Ecken3Positionieren();
	await mrs_Ecken3Drehen();
}

Mögliche Hauptprogrammaufrufe

//Main: Beliebiger Würfel
//await mrs_Ebene1(); 
//await mrs_Ebene2();
//await CUBE.move(" x x ");
//await mrs_Ebene3();

//Main: Würfel in Standardlage und Ausgabe der Orbitkennung
await mrs_WeissObenGruenVorne();
await mrs_Ebene1(); 
await mrs_Ebene2();
await CUBE.move(" x x y y ");
await mrs_Ebene3();
UI.log("Orbitkennung:" + orbit);
Abgerufen von „http://mint.lentner.net/index.php?title=MRS-Algorithmus&oldid=1461“