My Rubik's Cube Simulator made on Processing for my final ISN exam

RubiksCubeSimulator

/*
Projet final d'ISN 2013-2014
 auteur: Berkmann Maximilian
 */
 //import java.processing.opengl;
float M[][] = new float[4][4];
//descritif des styles de cubes
color cubeFaceColors[] = {//défaut
  //D, B, R, F, L, U
  color(255, 255, 0), color(255, 127, 0), color(0, 0, 255), color(255, 0, 0), color(0, 255, 0), color(255)
}
, vCubeFC[] = {//VCube
  color(127), color(255, 127, 0), color(0, 0, 255), color(255, 0, 0), color(0, 255, 0), color(0)
}
, girlCFC[] = {//fille
  color(255, 255, 0), color(255, 127, 0), color(255, 0, 255), color(255, 16, 120), color(0, 255, 0), color(255)
}
, cF2C[] = {//blanc et noir
  color(255), color(255), color(0), color(0), color(255), color(0)
}
, cF3C[] = {//rouge, vert et bleu
  color(0, 255, 0), color(255, 0, 0), color(0, 0, 127), color(127, 0, 0), color(0, 0, 255), color(0, 127, 0)
}
, MirrorFC[] = {//couleur argent du cube Mirror
  color(210), color(210), color(210), color(210), color(210), color(210)
}
, MinxFC[] = {//cyan, magenta et orange
  color(0, 255, 0), color(255, 0, 0), color(0, 255, 255), color(255, 255, 0), color(0, 0, 255), color(255, 0, 255)
}
, OldStyle[] = {//noir, gris et blanc
  color(255), color(127), color(0), color(255), color(127), color(0)
}
, WCAClrSch[] = {//Schéma de couleur de la WCA
  color(255, 255, 0), color(0, 0, 255), color(255, 0, 0), color(0, 255, 0), color(255, 128, 0), color(255)
}
, TwoFC[] = {//seulement 2 faces
  color(255, 255, 0), color(128, 64), color(128, 64), color(128, 64), color(128, 64), color(255)
}
, Visual[] = {//Schéma de couleur de Visual Cube
  color(255, 255, 0, 127), color(0, 0, 255, 127), color(255, 0, 0, 127), color(0, 255, 0, 127), color(255, 128, 0, 127), color(255, 127)
};
//axe (0-3), tranche (0-3), direction (1: sens des aiguilles d'une montre; -1: sens inverse des aiguilles d'une montre)
int axis=0, slice=2, direction=1, speed=10, nbOfMoves = 0;//vitesse: défaut=3; max=16;
float theta = 0.0;//angle theta

boolean orient=false;//cube orienté
boolean firstRun = true;//début de l'animation
float xRot=-35.264, yRot=45, zRot=0;//rotation en x, en y et en z

PVector frontBound[], topBound[], rightBound[], downBound[], backBound[], leftBound[];//attachement des faces avec le centres du cube
float backViewDisp;//position de la vue arrière

stack stackOfMoves = new stack();//stack de mouvement
rubikCube rc;//Rubik's cube

String moveStr, algorithm = "", solverStat = "";//chaine de mouvement, algorithme affiché, état du solveur, algorithme pour undo algorithm
boolean moveStrValid = false;//validité du mouvement pour éviter la répétition involontaire de mouvements
int strMoveCount=0;//nombre de mouvements

boolean inMove = false;//indication du cube si c'est en mouvement ou non
int thetaCount = 0, cubeStyleSelected = 0;//comptage de l'angle, style du cube sélectionner

String[] solvingMethod = {
  "undo", "Beginner\'s", "Fridrich", "Petrus", "Roux", "EdgeFirst", "CornerFirst", "ZZ", "VH", "M2 3OP"
}
, //méthode de résolution
cubeStyles = {
  "classic", //bordure noir, couleur de base (normale)
  "VCube", //bordure blanche, noir au lieu de blanc et gris au lieu de jaune
  "girlish", //bordure jaune, magenta au lieu de bleu et rose au lieu de rouge
  "whiteAndBlack", //cube blanc et noir
  "rgb", //rouge, vert et bleu
  "mirror", //même couleur que le Mirror Cube (BLD cube)
  "minx", //Couleur du Megaminx en plus des couleurs classiques
  "OldStyle", //sans couleur
  "Heise\'s", //cube de Ryan Heise
  "WCA", //cube de la WCA
  "2F", //Couleur de 2 faces
  "Visual" //transparent
};
char[] undoStr;
color cubiesBorder = color(255);//couleur de la bordure du cube

void setup() {
  chCubeStyle(0);//change le style du cube
  size(1210, 600, OPENGL);//Taille et moteur de rendu
  ortho();//orthogonalité des formes
  strokeJoin(ROUND);//jointure ronde
  //frame.setTitle("Rubik's Cube Simulator");//titre
  rc = new rubikCube(height/8);//création du cube
  if (cubeStyleSelected==8) rc.setSize(5); //100 par défaut (séparation des cubies)

  rc.cubePosition = new PVector(width/3, height/2.0, 0.0);//position du cube
  backViewDisp = width/3;//vue arrière au tier de la fenêtre en longueur
  for (int i=0;i<8;i++) {//dessin des faces
    rot(rc.frontY, 1, rc.boundary.points[i]);//face avant en Y
    rot(rc.frontX, 0, rc.boundary.points[i]);//face avant en X
    trans(rc.cubePosition.x, rc.cubePosition.y, rc.cubePosition.z, rc.boundary.points[i]);//coin avant
    rot(rc.backY, 1, rc.boundary2.points[i]);//face arrière en Y
    rot(rc.backX, 0, rc.boundary2.points[i]);//face arrière en X
    trans(rc.cubePosition.x + backViewDisp, rc.cubePosition.y, rc.cubePosition.z, rc.boundary2.points[i]);//coin arrière
  }
  computeBoundaries();//attachement et frottement des cubies entre eux et entre le centre
  //scramble();
}

void draw() {
  //if(cubeStyleSelected<cubeStyles.length) cubeStyleSelected++;
  //else cubeStyleSelected=0;
  background(200);//effacement du fond
  if (!inMove && moveStrValid) strOfMoves();//autorisation de l'exécution des mouvements
  move(false);//reste sur le premier mouvement
  strokeWeight(5.0);//épaisseur des bordures
  //rc.drawBound(); bordure fixe
  pushMatrix();//matrice géométrique lancer
  translate(rc.cubePosition.x, rc.cubePosition.y, rc.cubePosition.z);
  pushMatrix();//sous matrice géométrique (cube avant)
  rotateX(radians(rc.frontX));//rotation du cube en X
  rotateY(radians(rc.frontY));//... en Y

    rc.drawRubikCube(theta);//dessine le cube avant (le 1er à gauche)
  popMatrix();//fermeture de la sous matrice
  translate(backViewDisp, 0, 0);//cube arrière
  rotateX(radians(rc.backX));
  rotateY(radians(rc.backY));
  rc.drawRubikCube(0.0); //dessine le cube arrière (le deuxième à droite)
  popMatrix();//ferme la matrice
  textSize(20);
  text(nbOfMoves+" moves", width/2, height-40);//affiche le nombre de mouvement sur le sketch
  text("scramble: "+algorithm, 20, 40);//affiche le mélange
  textSize(15);
  text(rc.codeString(), width/2-80, height-20);
  fill(255, 0, 0);
  textSize(24);
  if (rc.isSolved()) text("Solved", 60, height/2);//si le cube est résolu alors ça l'indique
  fill(0);
  textSize(30);
  text(min+":"+s+"."+ms, 50, height-50);//affiche le temps
  textSize(24);
  text("cube style: "+cubeStyles[cubeStyleSelected], width-250, height-45);//indique le style choisi
  //slowMove();
}
class cube {//cubie
  PVector pos;//position
  int id, size;//numéro d'identification, taille
  PVector points[];//points de construction
  float angX, angY, angZ;//angles
  String code;//code

    cube(int id, int size) {//constructeur de cube
    this.id = id;//assignation du paramètre à l'attribut
    pos = new PVector(0, 0, 0);//initialisation vectoriel
    points = new PVector[8];//création du tableau vectoriel
    for (int i=0;i<8;i++) points[i] = new PVector();//remplissage du tableau cellule par cellule
    this.size = size;
    for (int i=0;i<8;i++) {//position des points celon les signes de chaque coordonnées
      int xSign = (i%2==0)?1:-1;
      int ySign = (i/4 == 0)?1:-1;
      int zSign = ((i/2)%2 == 0)?1:-1;
      points[i].x = xSign*size/2.0;
      points[i].y = ySign*size/2.0;
      points[i].z = zSign*size/2.0;
    }
    angX = angY = angZ = 0.0;//remise à zero des angles (angZ=0;angY=angZ;angX=angY;) 
    code = new String("");//code vide
  }

  void setPos(PVector p) {//assigne la position
    for (int i=0;i<8;i++) trans(p.x, p.y, p.z, points[i]);
  }

  void findCenter() {//trouve les centres pour les correspondances cubies-centres
    PVector temp;//vecteur temporaire
    temp = PVector.add(points[0], points[7]);//ajout des points d'extremité du vecteur
    temp.div(2.0);//division en 2
  }

  void drawCube(PVector t) {//dessine le cubie
    int idx[] = {//tableau à numéro d'identification de cubie
      0, 1, 3, 2, 3, 7, 6, 2, 0, 2, 6, 4, 0, 4, 5, 1, 1, 5, 7, 3, 4, 6, 7, 5
    };
    for (int i=0;i<8;i++) rot(angY, 1, points[i]);//rotation en Y
    for (int i=0;i<8;i++) rot(angX, 0, points[i]);//rotation en X
    for (int i=0;i<8;i++) rot(angZ, 2, points[i]);//rotation en Z
    angX = angY = angZ = 0.0;
    for (int i=0;i<6;i++) {
      if ((this.id & (1<<i)) != 0) fill(cubeFaceColors[i]);
      else fill(0);
      stroke(cubiesBorder);//bordure du cubie
      beginShape(QUADS);//déclaration d'une forme de type quadrilatère
      for (int j=0;j<4;j++) {
        int pt = idx[i*4+j];//chaque point recoive un id
        vertex(this.points[pt].x, this.points[pt].y, this.points[pt].z);//créer un vertex à chaque endroits spécifié dans le tableau de points
      }
      endShape();//fermeture de la déclaration
    }
    findCenter();//recherche de centre pour assurer une cohérence des faces
  }

  PVector getCenter() {//retourne le centre
    return this.pos;//la position du cubie
  }
}
class stack {//stack de donné
  char data[];//tableau de donné
  int top;//seuil

  stack() {//constructeur de stack
    //initialisation des attributs
    top = -1;
    data = new char[999];
    for (int i=0; i<data.length; i++) {
      data[i] = ' ';
    }
  }

  void push(char v) {//ajout d'un caractère
    println("push");
    top++;
    if (top < 999) data[top] = v;//si le seuil n'est pas au maximum
  }
  char pop() {//enl����ve un caractère
    println("pop top="+top);
    char tmp = ' ';
    if (top>=0) {
      tmp = data[top];
      top--;
    }
    println("pop après top="+top);
    return tmp;
  }
  boolean isEmpty() {//indique si le stack est vide
    return (top<0);//si top<0: top=-1; ce qui signifie que top n'a pas était modifier donc pas d'ajout ou de suppression de donné
  }
  void reset() {//réinitialise le stack
    top = -1;
    for (int i=0; i<data.length; i++) {
      data[i] = ' ';
    }
  }
}
class rubikCube {//Rubik's cube
  cube grid[][][];//grille à cubie
  cube boundary, boundary2;//frontière avant et arrière
  PVector cubePosition;//vecteur de position du cube
  char UP, FRONT, RIGHT, BACK, LEFT, DOWN;//face
  int GREEN, BLUE, WHITE, YELLOW, ORANGE, RED, size;//id des couleur, taille
  float frontX, frontY, backX, backY;//angle de vue avant/arrière en X/Y

    rubikCube(int sz) {//constructeur de Rubik's cube (sz: écartement de cubie)
    //attribution des id au couleur
    WHITE = 32;
    RED = 8;
    BLUE = 4;
    ORANGE = 2;
    GREEN = 16;
    YELLOW = 1;

    grid = new cube[3][][];//établissement de la grille en X
    for (int i=0;i<3;i++) {//.. en Y
      grid[i] = new cube[3][];
      for (int j=0;j<3;j++) {//.. en Z
        grid[i][j] = new cube[3];
      }
    }

    int code=0;//code de correspondance avec les couleurs
    //coloration des cubies
    for (int x=0;x<3;x++) {
      for (int y=0;y<3;y++) {
        for (int z=0;z<3;z++) {
          if (x==0) code |= GREEN;//si c'est la face gauche (L)
          else if (x==2) code |= BLUE;//sinon si c'est la face droite (R)
          if (y==0) code |= YELLOW;//si c'est la face du bas (D)
          else if (y==2) code |= WHITE;//sinon si c'est la face du haut (U)
          if (z==2) code |= RED;//si c'est la face avant (F)
          else if (z==0) code |= ORANGE;//sinon si c'est la face arrière (B)

          grid[x][y][z] = new cube(code, sz);//remplissage de la grille par des cubies
          code = 0;//remise à zero du code
        }
      }
    }
    //association face-mouvement
    UP = 'U';
    DOWN = 'D';
    FRONT = 'F';
    BACK = 'B';
    RIGHT = 'R';
    LEFT = 'L';
    //mise des valeurs des angles de vue
    frontY = -45.0;
    frontX = -23.26;
    backX = -frontX;
    backY = frontY+180;

    setSize(sz);//met l'écartement à sz
    assignCode();//assignation de code propre à chaque cubie
    //création des frontières
    boundary = new cube(0, 3*size);
    boundary2 = new cube(0, 3*size);
  }

  void assignCode() {//assignation de code à chaque cubie de la grille
    //arrêtes (2 lettres==2 stickers)
    grid[1][2][2].code = new String("UF");
    grid[2][2][1].code = new String("UR");
    grid[1][2][0].code = new String("UB");
    grid[0][2][1].code = new String("UL");
    grid[1][0][2].code = new String("DF");
    grid[2][0][1].code = new String("DR");
    grid[1][0][0].code = new String("DB");
    grid[0][0][1].code = new String("DL");
    grid[2][1][2].code = new String("FR");
    grid[0][1][2].code = new String("FL");
    grid[2][1][0].code = new String("BR");
    grid[0][1][0].code = new String("BL");
    //coins
    grid[2][2][2].code = new String("UFR");
    grid[2][2][0].code = new String("URB");
    grid[0][2][0].code = new String("UBL");
    grid[0][2][2].code = new String("ULF");
    grid[2][0][2].code = new String("DRF");
    grid[0][0][2].code = new String("DFL");
    grid[0][0][0].code = new String("DLB");
    grid[2][0][0].code = new String("DBR");
  }

  void lTurn() {//rotation en L
    grid[0][2][2].code = rotateStr(grid[0][2][2].code, 1);//ULF
    grid[0][2][0].code = rotateStr(grid[0][2][0].code, 2);//UBL
    grid[0][0][0].code = rotateStr(grid[0][0][0].code, 1);//DLB
    grid[0][0][2].code = rotateStr(grid[0][0][2].code, 2);//DFL
  }
  void rTurn() {//rotation en R
    grid[2][2][2].code = rotateStr(grid[2][2][2].code, 2);//UFR
    grid[2][2][0].code = rotateStr(grid[2][2][0].code, 1);//URB
    grid[2][0][0].code = rotateStr(grid[2][0][0].code, 2);//DBR
    grid[2][0][2].code = rotateStr(grid[2][0][2].code, 1);//DRF
  }
  void fTurn() {//rotation en F
    grid[1][2][2].code = flipEdge(grid[1][2][2].code);//UF
    grid[1][0][2].code = flipEdge(grid[1][0][2].code);//DF
    grid[2][1][2].code = flipEdge(grid[2][1][2].code);//FR
    grid[0][1][2].code = flipEdge(grid[0][1][2].code);//FL

    grid[2][2][2].code = rotateStr(grid[2][2][2].code, 1);//UFR
    grid[0][0][2].code = rotateStr(grid[0][0][2].code, 1);//DFL
    grid[2][0][2].code = rotateStr(grid[2][0][2].code, 2);//DRF
    grid[0][2][2].code = rotateStr(grid[0][2][2].code, 2);//ULF
  }
  void bTurn() {//.. en B
    grid[1][2][0].code = flipEdge(grid[1][2][0].code);//UB
    grid[1][0][0].code = flipEdge(grid[1][0][0].code);//DB
    grid[2][1][0].code = flipEdge(grid[2][1][0].code);//BR
    grid[0][1][0].code = flipEdge(grid[0][1][0].code);//BL

    grid[2][2][0].code = rotateStr(grid[2][2][0].code, 2);//URB
    grid[0][2][0].code = rotateStr(grid[0][2][0].code, 1);//UBL
    grid[0][0][0].code = rotateStr(grid[0][0][0].code, 2);//DLB
    grid[2][0][0].code = rotateStr(grid[2][0][0].code, 1);//DBR
  }

  String codeString() {//affiche la chaine de code au format singmaster (utiliser dans les fichier .sgm)
    return new String(grid[1][2][2].code + " " + grid[2][2][1].code + " " + grid[1][2][0].code + " " + grid[0][2][1].code + " " + grid[1][0][2].code + " " + grid[2][0][1].code
      + " " + grid[1][0][0].code + " " + grid[0][0][1].code + " " + grid[2][1][2].code + " " + grid[0][1][2].code + " " + grid[2][1][0].code + " " + grid[0][1][0].code
      + " " + grid[2][2][2].code + " " + grid[2][2][0].code + " " + grid[0][2][0].code + " " + grid[0][2][2].code + " " + grid[2][0][2].code + " " + grid[0][0][2].code
      + " " + grid[0][0][0].code + " " + grid[2][0][0].code);
  }
  boolean isSolved() {//si le cube est résolu ça retourne vrai sinon faux
    //c'est-à-dire si chaque code des cubies corresponde avec celui à l'état résolu
    return grid[1][2][2].code.equals("UF") && grid[2][2][1].code.equals("UR") && grid[1][2][0].code.equals("UB") && grid[0][2][1].code.equals("UL") 
      && grid[1][0][2].code.equals("DF") && grid[2][0][1].code.equals("DR") && grid[1][0][0].code.equals("DB") && grid[0][0][1].code.equals("DL")
        && grid[2][1][2].code.equals("FR") && grid[0][1][2].code.equals("FL") && grid[2][1][0].code.equals("BR") && grid[0][1][0].code.equals("BL")
          && grid[2][2][2].code.equals("UFR") && grid[2][2][0].code.equals("URB") && grid[0][2][0].code.equals("UBL") && grid[0][2][2].code.equals("ULF")
            && grid[2][0][2].code.equals("DRF") && grid[0][0][2].code.equals("DFL") && grid[0][0][0].code.equals("DLB") && grid[2][0][0].code.equals("DBR");
  }
  void setSize(int size) {//écartement cubie-cubie
    PVector p;
    //décalage en coordonné
    int xOff, yOff, zOff;
    xOff = -size;
    for (int x=0;x<3;x++) {
      yOff = size;
      for (int y=0;y<3;y++) {
        zOff = -size;
        for (int z=0;z<3;z++) {
          p = new PVector();
          p.x = xOff;
          p.y = yOff;
          p.z = zOff;
          grid[x][y][z].setPos(p);//position individuelle
          zOff += size;
        }
        yOff -= size;
      }
      xOff += size;
    }
    this.size = size;
  }

  void drawRubikCube(float th) {//dessine le cube en fonction de la valeur de l'angle theta
    for (int x=0;x<3;x++)
      for (int y=0;y<3;y++)
        for (int z=0;z<3;z++) {
          if (axis==0 && x==slice) grid[x][y][z].angX = th;
          else if (axis==1 && y==slice) grid[x][y][z].angY = -th;
          else if (axis==2 && z==slice) grid[x][y][z].angZ = th;
          grid[x][y][z].drawCube(cubePosition);//dessine chaque cubie selon la position du cube
        }
  }

  void updateRotate(int a, int s, int d) {//met à jour les rotations (a: axis (axe); s: slice (tranche), d: direction)
    cube temp;//cubie temporaire
    //PVector tpos;
    if (d == 1) {//sens des aiguilles d'une montre
      if (a == 0) {//première axe
        //affection en queue (grid[s][0][0]->grid[s][2][0]->grid[s][2][2]->grid[s][0][2]->temp)
        temp = grid[s][0][0];//dernier valeur à affecter donc mise dans une variable temporaire pour ne pas la perdre
        grid[s][0][0] = grid[s][2][0];
        grid[s][2][0] = grid[s][2][2];
        grid[s][2][2] = grid[s][0][2];
        grid[s][0][2] = temp;
        temp = grid[s][1][0];
        grid[s][1][0] = grid[s][2][1];
        grid[s][2][1] = grid[s][1][2];
        grid[s][1][2] = grid[s][0][1];
        grid[s][0][1] = temp;
      }
      else if (a == 1) {//axe centrale
        temp = grid[0][s][2];
        grid[0][s][2] = grid[2][s][2];
        grid[2][s][2] = grid[2][s][0];
        grid[2][s][0] = grid[0][s][0];
        grid[0][s][0] = temp;
        temp = grid[0][s][1];
        grid[0][s][1] = grid[1][s][2];
        grid[1][s][2] = grid[2][s][1];
        grid[2][s][1] = grid[1][s][0];
        grid[1][s][0] = temp;
      }
      else {//dernier axe
        temp = grid[0][0][s];
        grid[0][0][s] = grid[2][0][s];
        grid[2][0][s] = grid[2][2][s];
        grid[2][2][s] = grid[0][2][s];
        grid[0][2][s] = temp;
        temp = grid[1][0][s];
        grid[1][0][s] = grid[2][1][s];
        grid[2][1][s] = grid[1][2][s];
        grid[1][2][s] = grid[0][1][s];
        grid[0][1][s] = temp;
      }
    }
    else {
      if (a == 0) {
        temp = grid[s][0][2];
        grid[s][0][2] = grid[s][2][2];
        grid[s][2][2] = grid[s][2][0];
        grid[s][2][0] = grid[s][0][0];
        grid[s][0][0] = temp;
        temp = grid[s][0][1];
        grid[s][0][1] = grid[s][1][2];
        grid[s][1][2] = grid[s][2][1];
        grid[s][2][1] = grid[s][1][0];
        grid[s][1][0] = temp;
      }
      else if (a == 1) {
        temp = grid[0][s][0];
        grid[0][s][0] = grid[2][s][0];
        grid[2][s][0] = grid[2][s][2];
        grid[2][s][2] = grid[0][s][2];
        grid[0][s][2] = temp;
        temp = grid[1][s][0];
        grid[1][s][0] = grid[2][s][1];
        grid[2][s][1] = grid[1][s][2];
        grid[1][s][2] = grid[0][s][1];
        grid[0][s][1] = temp;
      }
      else {
        temp = grid[0][2][s];
        grid[0][2][s] = grid[2][2][s];
        grid[2][2][s] = grid[2][0][s];
        grid[2][0][s] = grid[0][0][s];
        grid[0][0][s] = temp;
        temp = grid[0][1][s];
        grid[0][1][s] = grid[1][2][s];
        grid[1][2][s] = grid[2][1][s];
        grid[2][1][s] = grid[1][0][s];
        grid[1][0][s] = temp;
      }
    }
    //mise à jour des faces concerné pour éviter de le faire à tout le cube pouvant causé une invalidité du cube
    if (a == 2 && s == 2) fTurn();
    else if (a == 2 && s == 0) bTurn();
    else if (a == 0 && s == 2) rTurn();
    else if (a == 0 && s == 0) lTurn();
  }

  void drawBound() {//dessine les frontières
    noFill();//pas de remplissage
    stroke(0);//bordure noir
    beginShape();//début de forme
    for (int i=0;i<4;i++) vertex(leftBound[i].x, leftBound[i].y, leftBound[i].z);//vertex que comporte un carré
    endShape(CLOSE);//fermeture
  }

  void rotateOnU() {//y
    char temp = FRONT;//on sauvegarde la face F
    FRONT = RIGHT;//on la remplace avec la face R
    RIGHT = BACK;//on remplace la face R avec la face B
    BACK = LEFT;//on remplace la face B avec la face L
    LEFT = temp;//on remplace la face L avec la sauvegarde (de la face F)
    frontY -= 90;//on décale l'avant en Y
    backY = frontY + 180;//et l'arrière
  }
  void rotU() {//identique à la fonction précédente mais sans décaler les zones d'actions des mouvements
    moveStr = "Ued";//U E' D' sur un vrai
    moveStrValid = true;
  }
  void rotateOnD() {//y'
    char temp = FRONT;
    FRONT = LEFT;
    LEFT = BACK;
    BACK = RIGHT;
    RIGHT = temp;
    frontY += 90;
    backY = frontY + 180;
  }
  void rotD() {
    moveStr = "uED";
    moveStrValid = true;
  }
  void rotateOnR() {//x
    char temp = FRONT;
    FRONT = DOWN;
    DOWN = BACK;
    BACK = UP;
    UP = temp;
    frontY -= 90;
    backY = frontY + 180;
  }
  void rotR() {
    moveStr = "Rml";
    moveStrValid = true;
  }
  void rotateOnL() {//x'
    char temp = FRONT;
    FRONT = UP;
    UP = BACK;
    BACK = DOWN;
    DOWN = temp;
    frontY -= 90;
    backY = frontY + 180;
  }
  void rotL() {
    moveStr = "rML";
    moveStrValid = true;
  }
  void rotateDown() {//Tourne dans l'axe des ordonnées (en Y) de FR quand 2*rotateDown() = z x' z
    char temp = FRONT;
    FRONT = UP;
    UP = BACK;
    BACK = DOWN;
    DOWN = temp;
    frontX -= 90;
    backX = -frontX;
  }   
  void rotateUp() {//idem que rotateDown() mais dans le sens inverse soit 2*rotateUp() = z' x z'
    char temp = FRONT;
    FRONT = DOWN;
    DOWN = BACK;
    BACK = UP;
    UP = temp;
    frontX += 90;
    backX = -frontX;
  }
  void rotateOnF() {//z
    char temp = LEFT;
    LEFT = DOWN;
    DOWN = RIGHT;
    RIGHT = UP;
    UP = temp;
    frontX += 180;
    backY = frontY + 180;
  }
  void rotF() {
    moveStr = "FSb";
    moveStrValid = true;
  }
  void rotB() {
    moveStr = "fsB";
    moveStrValid = true;
  }
  String flipEdge(String c) {//retourne une arrête (ex: flipEdge("FU")="UF")
    char temp[] = {//sauvegarde les tout les caractère
      c.charAt(1), c.charAt(0)//le deuxi��me, le premier
      };
      return new String(temp);//retourne le résultat de l'inversion
  }
  String rotateStr(String c, int b) {//retourne une chaine de caractère (décale les caractère de b rang (cf. principe de cryptographie Vegenère))
    char temp[] = {
      't', 't', 't'//remplissage pour éviter l'erreur: création d'un tableau vide qu'on essais de remplir tout en une fois (sans passer par le remplissage cellule par cellule)
    };
    for (int i=0;i<3;i++) {//interchange les cellules celon la valeur de décalage b
      temp[(i+b)%3] = c.charAt(i);//tout en ayant bien les caractères de c et non pas 't' de temp[]
    }
    return new String(temp);
  }
}
void rot(float th, int ax, PVector v) {//th: angle theta, ax: axe; v: vecteur;
  for (int i=0;i<4;i++) {
    for (int j=0;j<4;j++) {
      if (i==j) M[i][j] = 1.0;
      else M[i][j] = 0.0;
    }
  }
  float cosTh = cos(radians(th));//cosinus(theta)
  float sinTh = sin(radians(th));//sinus(theta)
  if (ax==0) {
    M[1][1] = M[2][2] = cosTh;
    M[1][2] = -sinTh;
    M[2][1] = sinTh;
  }
  else if (ax==1) {
    M[0][0] = M[2][2] = cosTh;
    M[0][2] = sinTh;
    M[2][0] = -sinTh;
  }
  else if (ax==2) {
    M[1][1] = M[0][0] = cosTh;
    M[0][1] = -sinTh;
    M[1][0] = sinTh;
  }

  float tp[] = {//coordonné du vecteur
    v.x, v.y, v.z, 1.0
  };
  float res[] = {//tableau de résultat
    0, 0, 0, 0
  };

  for (int i=0;i<4;i++) {
    for (int k=0;k<4;k++) {
      res[i] += M[i][k] * tp[k];
    }
  }
  //mise à jour sur les coordonné du vecteur v
  v.x = res[0];
  v.y = res[1];
  v.z = res[2];
}

void trans(float dx, float dy, float dz, PVector v) {//équivaut à translate()
  v.x += dx;//direction en abscisse
  v.y += dy;//direction en ordonné
  v.z += dz;//direction en profondeur/côte
}

void scal(float sx, float sy, float sz, PVector v) {//redimension équivaut à scale()
  v.x *= sx;
  v.y *= sy;
  v.z *= sz;
}

void move(boolean newCall) {//en mouvement ou pas
  if (newCall) {//si vraie
    if (inMove || thetaCount != 0) return;//si en mouvement et que l'angle n'est pas nulle, ça retourne rien vue que cette fonction est du type void
    if (!inMove && newCall) {//si ce n'est pas en mouvement et qu'il ya eu une nouvelle appel
      inMove = true;//on change son statut en "en mouvement"
      thetaCount = 0;//l'angle theta revien à zero
    }
  }

  if (inMove) {//si en mouvement
    if (thetaCount > 90/speed) {//si le compte d'angle dépasse l'angle droit divisé par la vitesse
      rc.updateRotate(axis, slice, direction);//mise à jour des rotations
      inMove = false;
      theta = 0;
      thetaCount = 0;
      return;
    }
    theta = direction*speed;//pour suivre les mouvements dans l'espace
    thetaCount++;//en conséquence le comptage de theta aussi
  }
} 

void fastMove() {//mouvement rapide
  if (!inMove) {//mise à jour à l'état de repos
    rc.drawRubikCube(90.0*direction);//dessine le cube 
    rc.updateRotate(axis, slice, direction);//met à jour les rotations
  }
}
void slowMove() {//mouvement lent
  if (!inMove) {
    rc.drawRubikCube(direction);
    rc.updateRotate(axis, slice, direction);
  }
}
void scramble() {//mélangeur
  String j[] = {//tableau à mélanges spécifique et aléatoire
    new String("FBUDlrfbudLR"), new String("LRFBUDlr"), new String("FBUDlr"), new String("FFBBRRLLudlrbf"), new String(randAlgo(8, 50)), new String(randAlgo2(4, 25)), new String(randomAlgo(50)), new String(randomAlgo2(25)), 
    new String(extremAlgo()), new String(extremAlgo2()), new String("FFyFyFyF"), new String("URRFBRBBRUULBBRudRRFrLBBUUFF"), //superflip
    new String("FRUFRUFRU"), new String("MMEESS")/*damier*/, new String("drDRdrDRdrDR"), new String("FRUruRUruRUruf"), new String("FSRUruRUruRUrufs"), new String("MUMUMUMUMUMUMU"), new String("FrFrFrFrFrFrFrFrFr"), new String("MESMESMESMES")
    };
    moveStr = j[int(random(100.0))%j.length];//sélection aléatoire
  //moveStr = j[11];//sélection du 11e mélange
  algorithm = moveStr;//le mélange est affecter à l'algorithme affich����
  moveStrValid = true;//validité
  if (rc.isSolved()) text("Solved", 60, height/2);//au cas où ça ne s'affiche pas lors que le cube est résolu
}
String randAlgo(int min, int max) {//extension de randomAlgo() avec la possibilité de générer un algorithme aléatoire avec un nombre aléatoire
  int r=(int) random(min, max);//r est un nombre aléatoire compris entre min et max
  return randomAlgo(r);//génere l'algorithme aléatoire à r mouvement
}
void WCAScramble() {//mélange valide de la WCA
  String randomState="";//état aléatoire (algorithme du mélange)
  String[] allmoves = {
    "F", "f", "FF", "L", "l", "LL", "R", "r", "RR", "U", "u", "UU", "D", "d", "DD", "B", "b", "BB"
  }; //liste des mouvement autorisés (18 mouvements)
  for (int i=0; i<20; i++) {//génération d'un algorithme à 20 mouvements mais cela varie car les mouvements à 180° (2x la même lettre) sont comptées comme 2
    randomState += allmoves[int(random(allmoves.length))]+" ";//ajoute un mouvement de liste aléatoirement seulon le numéro de la cellule compris entre 0 et allmoves.length (longueur du tableau allmoves = 18)
  }
  moveStr = join(split(randomState, " "), "");//affiche le mélange sans espace pour éviter les ambiguïté de l'IA (exemple: prendre les espaces pour des répétition de mouvements, de pause, d'arrêt, ...)
  moveStrValid = true;
  if (rc.isSolved()) text("Solved", 60, height/2);
}
String randomAlgo(int moves) {//fonction qui retourne un algorithme avec moves mouvements (mouvement simple: pas de mouvements à 180°, pas de double mouvement)
  //regroupement de tout movement lorsque le rubik's cube est fixe et notamment les mouvements
  String[] allmoves = {
    "F", "f", "L", "l", "R", "r", "U", "u", "D", "d", "B", "b", "S", "s", "M", "m", "E", "e", "X", "x", "Y", "y", "Z", "z"
  }; //24 mouvements (mouvements simples/de tranches et rotations)
  String algo = "";//création de la variable algo contenant l'algorithme
  for (int i=0; i<moves; i++) algo += allmoves[int(random(allmoves.length))];//ajout de mouvements choisi aléatoirement en fonction du nombres de mouvements
  return algo;//retourne l'algorithme
}
String randAlgo2(int min, int max) {
  int r=(int) random(min, max);
  return randomAlgo2(r);
}
String randomAlgo2(int moves) {//identique à randomAlgo() mais avec tout les mouvements à une couche (donc pas des mouvements du genre: Rm)
  String[] allmoves = {
    "F", "f", "FF", "L", "l", "LL", "R", "r", "RR", "U", "u", "UU", "D", "d", "DD", "B", "b", "BB", "S", "s", "SS", "M", "m", "MM", "E", "e", "EE", "X", "x", "XX", "Y", "y", "YY", "Z", "z", "ZZ"
  }; //27
  String algo = "";//création de la variable algo contenant l'algorithme
  for (int i=0; i<moves; i++) {//ajout de mouvements choisi aléatoirement en fonction du nombres de mouvements
    algo += allmoves[int(random(allmoves.length))]+" ";
  }
  return algo;//retourne l'algorithme
}
String extremAlgo() {//génération à l'extreme
  return randomAlgo(100);
}
String extremAlgo2() {//moins extrême que la précédente car il y plus de mouvements possible
  return randomAlgo2(80);
}
void solve(String method) {//méthode à utiliser pour résoudre le cube
  solverStat = "inspection ...";
  println(solverStat);
  if (!rc.isSolved()) {//si le cube n'est pas résolu
    println("code: "+rc.codeString());//affiche le code du cube
    if (method.toLowerCase().equals("undo") || method.toLowerCase().equals(solvingMethod[0])) {//méthode du robot
      println("lancement de la méthode undo, top="+stackOfMoves.top);
      while (stackOfMoves.top>=0) {//tant que le cube n'est pas résolue l'IA undo les mouvements
        undo();
      }
    }
    else if (method.toLowerCase().equals("beginner") || method.toLowerCase().equals("lbl") || method.toLowerCase().equals(solvingMethod[1])) {//méthode des débutant
      //Scanne du cube pour trouver les cubies
      solverStat = "scan pour trouver UF, UR, UB et UL";
      int[] UFpos = getCubie("UF"), URpos = getCubie("UR"), UBpos = getCubie("UB"), ULpos = getCubie("UL");//positions des 4 premières arrêtes ciblé par la 1er étape de cette méthode
      if (UFpos[0]>=3 || UFpos[0]<0) UFpos = getCubie("FU");//si le cubie n'est pas dans/sur le cube
      if (URpos[0]>=3 || URpos[0]<0) URpos = getCubie("RU");
      if (UBpos[0]>=3 || UBpos[0]<0) UBpos = getCubie("BU");
      if (ULpos[0]>=3 || ULpos[0]<0) ULpos = getCubie("LU");
      //indique les positions des cubies désirer
      solverStat = "recherche d'un solution ...\nUF("+UFpos[0]+", "+UFpos[1]+", "+UFpos[2]+"), UR("+URpos[0]+", "+URpos[1]+", "+URpos[2]+"), UB("+UBpos[0]+", "+UBpos[1]+", "+UBpos[2]+"), UL("+ULpos[0]+", "+ULpos[1]+", "+ULpos[2]+")";
      //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
      println(solverStat);//affiche l'état du solveur
      solverStat = "1ère étape: la croix";
      //UF
      //whoIs("UF");//à quel place se trouve le cubie UF
      if (!cubieInPlace2(UFpos, "UF") || !cubieInPlace("UF")) {//si le cubie n'est pas à sa place
        solverStat = "place UF";
        //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
        println(solverStat);
        if (cubieIsOriented("UF")) {//bonne arrête
          //recherche de l'emplacement du cubie (cf. fiche)
          solverStat = "UF est orienter";
          //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
          println(solverStat);
          if (UFpos[0]==1 && UFpos[1]==0 && UFpos[2]==2) moveStr = "FF";//MDDm si les coins (UFR et ULF) sont résolu
          else if (UFpos[0]==0 && UFpos[1]==1 && UFpos[2]==2) moveStr = "Ulu";
          else if (UFpos[0]==2 && UFpos[1]==1 && UFpos[2]==2) moveStr = "uRU";
          else if (UFpos[0]==0 && UFpos[1]==0 && UFpos[2]==1) moveStr = "DFF";
          else if (UFpos[0]==2 && UFpos[1]==0 && UFpos[2]==1) moveStr = "dFF";
          else if (UFpos[0]==1 && UFpos[1]==0 && UFpos[2]==0) moveStr = "DDFF";
          else if (UFpos[0]==0 && UFpos[1]==2 && UFpos[2]==1) moveStr = "u";
          else solverStat = "je peux pas trouver UF";
          //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
          println(solverStat);
          algorithm=moveStr;
          moveStrValid=true;
        }
        else {//mauvaise arrête (mal orienté)
          if (cubieInPlace2(UFpos, "FU") || cubieInPlace("FU")) solverStat = "UF in place but misoriented";
          else solverStat = "UF have a problem";
          solverStat = "UF isn't oriented";
          //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
          println(solverStat);
          if (UFpos[0]==1 && UFpos[1]==0 && UFpos[2]==2) moveStr = "DMdm";//dMDm (mirroir)
          else if (UFpos[0]==0 && UFpos[1]==1 && UFpos[2]==2) moveStr = "F";
          else if (UFpos[0]==2 && UFpos[1]==1 && UFpos[2]==2) moveStr = "f";
          else if (UFpos[0]==0 && UFpos[1]==0 && UFpos[2]==1) moveStr = "lFl";
          else if (UFpos[0]==2 && UFpos[1]==0 && UFpos[2]==1) moveStr = "Rfr";
          else if (UFpos[0]==1 && UFpos[1]==2 && UFpos[2]==2) moveStr = "FuRU";//fUlu (mirroir) ou FFDMdm ou ffdMDm
          else if (UFpos[0]==0 && UFpos[1]==2 && UFpos[2]==1) moveStr = "u";
          else solverStat = "I can't find FU";
          //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
          println(solverStat);
          algorithm=moveStr;
          moveStrValid=true;
        }
      }//else rc.rotU();//Y pour passer au cubie suivant
      algorithm = moveStr;
      //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
      println(solverStat);
      /*//UR
       if(!cubieInPlace("UR")){
       solverStat = "placing UR";
       if(cubieIsOriented("UR")){//bonne arrêtes
       if(URpos[0]==1 && URpos[1]==0 && URpos[2]==2) moveStr = "FF";
       else if(URpos[0]==0 && URpos[1]==1 && URpos[2]==2) moveStr = "F";
       else if(URpos[0]==2 && URpos[1]==1 && URpos[2]==2) moveStr = "f";
       else if(URpos[0]==0 && URpos[1]==0 && URpos[2]==1) moveStr = "DFF";
       else if(URpos[0]==2 && URpos[1]==0 && URpos[2]==1) moveStr = "dFF";
       else solverStat = "I can't find UR";
       moveStrValid=true;
       }else{//mauvaise arrête
       if(URpos[0]==1 && URpos[1]==0 && URpos[2]==2) moveStr = "DMdm";
       else if(URpos[0]==0 && URpos[1]==1 && URpos[2]==2) moveStr = "Ulu";
       else if(URpos[0]==2 && URpos[1]==1 && URpos[2]==2) moveStr = "uRU";
       else if(URpos[0]==0 && URpos[1]==0 && URpos[2]==1) moveStr = "lFl";
       else if(URpos[0]==2 && URpos[1]==0 && URpos[2]==1) moveStr = "Rfr";
       else if(URpos[0]==1 && URpos[1]==2 && URpos[2]==2) moveStr = "FuRU";
       else solverStat = "I can't find RU";
       moveStrValid=true;
       }
       }else rc.rotU();
       algorithm = moveStr;moveStrValid = true;
       if(!cubieInPlace("UB")){
       solverStat = "placing UB";
       if(cubieIsOriented("UB")){
       if(UBpos[0]==1 && UBpos[1]==0 && UBpos[2]==2) moveStr = "FF";
       else if(UBpos[0]==0 && UBpos[1]==1 && UBpos[2]==2) moveStr = "F";
       else if(UBpos[0]==2 && UBpos[1]==1 && UBpos[2]==2) moveStr = "f";
       else if(UBpos[0]==0 && UBpos[1]==0 && UBpos[2]==1) moveStr = "DFF";
       else if(UBpos[0]==2 && UBpos[1]==0 && UBpos[2]==1) moveStr = "dFF";
       else solverStat = "I can't find UB";
       moveStrValid=true;
       }else{
       if(UBpos[0]==1 && UBpos[1]==0 && UBpos[2]==2) moveStr = "DMdm";
       else if(UBpos[0]==0 && UBpos[1]==1 && UBpos[2]==2) moveStr = "Ulu";
       else if(UBpos[0]==2 && UBpos[1]==1 && UBpos[2]==2) moveStr = "UBU";
       else if(UBpos[0]==0 && UBpos[1]==0 && UBpos[2]==1) moveStr = "lFl";
       else if(UBpos[0]==2 && UBpos[1]==0 && UBpos[2]==1) moveStr = "Rfr";
       else if(UBpos[0]==1 && UBpos[1]==2 && UBpos[2]==2) moveStr = "FUBU";
       else solverStat = "I can't find BU";
       moveStrValid=true;
       }
       }else rc.rotU();
       algorithm = moveStr;moveStrValid = true;
       if(!cubieInPlace("UL")){
       solverStat = "placing UL";
       if(cubieIsOriented("UL")){
       if(ULpos[0]==1 && ULpos[1]==0 && ULpos[2]==2) moveStr = "FF";
       else if(ULpos[0]==0 && ULpos[1]==1 && ULpos[2]==2) moveStr = "F";
       else if(ULpos[0]==2 && ULpos[1]==1 && ULpos[2]==2) moveStr = "f";
       else if(ULpos[0]==0 && ULpos[1]==0 && ULpos[2]==1) moveStr = "DFF";
       else if(ULpos[0]==2 && ULpos[1]==0 && ULpos[2]==1) moveStr = "dFF";
       else solverStat = "I can't find UL";
       moveStrValid=true;
       }else{
       if(ULpos[0]==1 && ULpos[1]==0 && ULpos[2]==2) moveStr = "DMdm";
       else if(ULpos[0]==0 && ULpos[1]==1 && ULpos[2]==2) moveStr = "Ulu";
       else if(ULpos[0]==2 && ULpos[1]==1 && ULpos[2]==2) moveStr = "ULU";
       else if(ULpos[0]==0 && ULpos[1]==0 && ULpos[2]==1) moveStr = "lFl";
       else if(ULpos[0]==2 && ULpos[1]==0 && ULpos[2]==1) moveStr = "Rfr";
       else if(ULpos[0]==1 && ULpos[1]==2 && ULpos[2]==2) moveStr = "FULU";
       else solverStat = "I can't find LU";
       moveStrValid=true;
       }
       }else rc.rotU();
       solverStat = "Cross finished";
       solverStat = "scanning to find UFR, URB, UBL and ULF";
       int[] UFRpos = getCubie("UFR"), URBpos = getCubie("URB"), UBLpos = getCubie("UBL"), ULFpos = getCubie("ULF");//positions des 4 premières coins ciblé par la 2������������������me étape de cette méthode*/
    }
    else if (method.toLowerCase().equals("fridrich") || method.toLowerCase().equals("cfop") || method.toLowerCase().equals(solvingMethod[2])) {//méthode utiliser par des speedcubers
    }
    else if (method.toLowerCase().equals("petrus") || method.toLowerCase().equals(solvingMethod[3])) {//méthode utiliser par des speedcubers
    }
    else if (method.toLowerCase().equals("roux") || method.toLowerCase().equals(solvingMethod[4])) {//...
    }
    else if (method.toLowerCase().equals("edgefirst") || method.toLowerCase().equals(solvingMethod[5])) {
    }
    else if (method.toLowerCase().equals("cornerfirst") || method.toLowerCase().equals(solvingMethod[6])) {
    }
    else if (method.toLowerCase().equals("zz") || method.toLowerCase().equals(solvingMethod[7])) {
    }
    else if (method.toLowerCase().equals("vh") || method.toLowerCase().equals(solvingMethod[8])) {
    }
    else if (method.toLowerCase().equals("m2 3op") || method.toLowerCase().equals(solvingMethod[9])) {//méthode utiliser par des speedcubers à l'aveugle
    }
    else {
      println("La méthode choisie pour résoudre le cube n'est pas disponible pour l'instant.\nLes méthodes disponible sont: "+solvingMethod);//indique que la méthode choisi n'est pas disponible et celles disponibles
    }
  }
  else {//si le cube est déjà résolu, ça l'annonce si ce n'était pas le cas et de modifie pas le cube
    solverStat = "cube solved";
    fill(255, 0, 0);
    textSize(24);
    text("Solved", 60, height/2);
    save("data/cubeStyle-"+cubeStyleSelected+".png");//pour garder un aperçu du style en cours
  }
  println(solverStat);//affiche l'état du solveur
  //frame.setTitle("Rubik's Cube Simulator - Solveur: "+solverStat);
}/*
String[][][] getCubiePos(int[] fpos, String code){
 String[][][] gpos = {{{code}}};
 gpos[fpos[0]][fpos[1]][fpos[2]] = code;
 return gpos;
 }*/
void whoIs(String ccode) {//qui est le cubie
  int[] gC = getCubie(ccode);
  if (cubieInPlace(ccode)) println(ccode+" is in is place");//si le cubie est lui-même (s'il est à sa place)
  else println(ccode+" is in the place of "+rc.grid[gC[0]][gC[1]][gC[2]].code);//sinon on indique quelle cubie appartient à la place où se trouve ce cubie
}/*
String[][][] findCubie(String ccode){
 int[] pos = {0};
 String[][][] cpos;
 for(int x=0; x<3; x++){
 for(int y=0; y<3; y++){
 for(int z=0; z<3; z++){
 //int[][][] pos = {x{y{z}}};
 if(rc.grid[x][y][z].code.equals(ccode)){pos[0] = x; pos[1] = y; pos[2] = z;}
 }
 }
 }
 cpos = getCubiePos(pos, ccode);
 return cpos;
 }*/
int[] getCubie(String code) {//scanne pour trouver le cubie ayant le code
  println("getting cubie "+code+" ...");//debug+indication de l'action effectué par l'IA
  //recherche individuelle des coordonnées du cubie pour éviter de passer par 3 fonctions (celle-ci y compris, dont les deux autre servent à retourner 3 résultat ce qui est complexe à faire) pour savoir où se trouve le cubie (défaut des autres fonctions en commentaire)
  int x=findCubieX(code), y=findCubieY(code), z=findCubieZ(code);
  if (x>=3||x<0||y>=3||y<0||z>=3||z<0) {//si le cubie est inexistant ou hors du cube
    println("Ho the cubie has a problem !");//indique qu'il y a problème que l'IA vient de rencontrer
    if (code.length()==2) code=rc.flipEdge(code);//si le cubie en question est une arrête
    else code=rc.rotateStr(code, 1);//sinon ce cubie est un coin
    println("new code: "+code);//indique le nouveau code pour assurer un bon déroulement de cette arrangement au yeux de l'IA
    x=findCubieX(code);
    y=findCubieY(code);
    z=findCubieZ(code);//on recherche les coordonné qui étaient jugées mauvaises
    if (code.length()==3) getCubie(code);//vérification au cas où le code du coin est toujour pas trouvable (mauvais) car un coin à 3 code possible (celon son orientation) exemple: UFR/FRU/RUF;
  }
  int[] p= {
    x, y, z
  };//on case toute les coordonnés (donné tri-dimentionnel du cubie) dans une variable pour faciliter le retour et l'exploitation du résultat
  println("cubie "+code+" finded");//indique que la recherche du cubie en question à bien été fait
  return p;
}
boolean cubieInPlace(String ccode) {//Si le cubie à besoin d'être permuter ou non (si c'est en place)
  int[] p=getCubie(ccode);//on récupère les coordonné du cubie
  if (rc.grid[p[0]][p[1]][p[2]].code.equals(ccode)) return true;//s'il est à sa place alors ça retourne vrai
  else if (ccode.length()==2 && rc.flipEdge(rc.grid[p[0]][p[1]][p[2]].code).equals(ccode)) return true;
  else if (ccode.length()==3 && rc.rotateStr(rc.grid[p[0]][p[1]][p[2]].code, 1).equals(ccode)) return true;
  else if (ccode.length()==3 && rc.rotateStr(rc.grid[p[0]][p[1]][p[2]].code, 2).equals(ccode)) return true;
  else return false;//sinon faux
}
boolean cubieInPlace2(int[] p, String c) {//Si le cubie à besoin d'être permuter ou non (si c'est en place)
  if (rc.grid[p[0]][p[1]][p[2]].code.equals(c)) return true;//s'il est à sa place alors ��a retourne vrai
  else if (c.length()==2 && rc.flipEdge(rc.grid[p[0]][p[1]][p[2]].code).equals(c)) return true;
  else if (c.length()==3 && rc.rotateStr(rc.grid[p[0]][p[1]][p[2]].code, 1).equals(c)) return true;
  else if (c.length()==3 && rc.rotateStr(rc.grid[p[0]][p[1]][p[2]].code, 2).equals(c)) return true;
  else return false;//sinon faux
}
boolean cubieIsOriented(String ccode) {//Si le cubie à besoin d'être orienter ou non (si les stickers sont bien placés)
  int[] p=getCubie(ccode);
  if (rc.grid[p[0]][p[1]][p[2]].code.equals(ccode)) return true;
  else {
    if (ccode.length()==2) ccode=rc.flipEdge(ccode);
    else ccode=rc.rotateStr(ccode, 1);
    if (rc.grid[p[0]][p[1]][p[2]].code.equals(ccode)) return false;
    else if (ccode.length()==3) {//au cas où ce n'est toujours pas bon
      ccode=rc.rotateStr(ccode, 1);
      if (rc.grid[p[0]][p[1]][p[2]].code.equals(ccode)) return false;
    }
    return false;
  }
}
int findCubieX(String code) {//cherche la coordonné X du cubie voulu
  int x=0;
  //navigue à traver le cube au niveau des 3 dimensions pour une suretté maximale
  for (x=0; x<3; x++) {
    for (int y=0; y<3; y++) {
      for (int z=0; z<3; z++) {
        if (rc.grid[x][y][z].code.equals(code)) return x;
      }
    }
  }
  return x;
}
int findCubieY(String code) {//cherche la coordonné Y du cubie voulu
  int y=0;
  for (int x=0; x<3; x++) {
    for (y=0; y<3; y++) {
      for (int z=0; z<3; z++) {
        if (rc.grid[x][y][z].code.equals(code)) return y;
      }
    }
  }
  return y;
}
int findCubieZ(String code) {//cherche la coordonné Z du cubie voulu
  int z=0;
  for (int x=0; x<3; x++) {
    for (int y=0; y<3; y++) {
      for (z=0; z<3; z++) {
        if (rc.grid[x][y][z].code.equals(code)) return z;
      }
    }
  }
  return z;
}
void reset() {//réinitialise le cube
  algorithm = "";
  background(200);//efface le sketch (la fenêtre du programme)
  rc = new rubikCube(height/8);//construit à nouveau le cube
  //et tout ce qu'il en suit
  rc.cubePosition = new PVector(width/3, height/2.0, 0.0);
  backViewDisp = width/3;
  for (int i=0;i<8;i++) {
    rot(rc.frontY, 1, rc.boundary.points[i]);
    rot(rc.frontX, 0, rc.boundary.points[i]);
    trans(rc.cubePosition.x, rc.cubePosition.y, rc.cubePosition.z, rc.boundary.points[i]);
    rot(rc.backY, 1, rc.boundary2.points[i]);
    rot(rc.backX, 0, rc.boundary2.points[i]);
    trans(rc.cubePosition.x + backViewDisp, rc.cubePosition.y, rc.cubePosition.z, rc.boundary2.points[i]);
  }
  nbOfMoves = 0;//pas de triche (passive ou par undo /!\ pas la méthode) et nécessaire pour les résolutions en FM (Fewest Moves: le moins de mouvements possible) c'est-à-dire pour ne pas pénaliser l'utilisateur/l'IA avec en ayant mis plus de mouvements qu'il n'en a fallut
}
void keyPressed() {//au moment où une touche est appuyée
  println(key+":"+keyCode);//affiche la touche et son code pour les débuggage et pour vérifier l'identité d'une touche
  if (keyCode == 70 || keyCode == 86 || keyCode == 82 || keyCode == 84 || keyCode == 85 || keyCode == 73//touche "mouvement" car si la validité se fait pour toute touches,
  || keyCode == 66 || keyCode == 78 || keyCode == 76 || keyCode == 77 || keyCode == 68 || keyCode == 67//s'il n'y a pas d'exécution d'un quelquonque mouvement le mouvement précedemment exécuter est répéter
  || keyCode == 65 || keyCode == 49 || keyCode == 81 || keyCode == 50 || keyCode == 69 || keyCode == 51
    || keyCode == 79 || keyCode == 80 || keyCode == 72 || keyCode == 74 || keyCode == 75 || keyCode == 44 || keyCode == 53 || keyCode == 54) {
    if (!rc.isSolved() && min==0 && s==0 && ms==0) startTimer();//si le cube est mélanger et que le temps n'est pas en cours (d'évolution) le chrono s'active
    //liste de mouvement aisni que les touches dédié à un mouvement spécifique
    if (key == 'F' || keyCode == 70) moveStr = "F";//F
    else if (key == 'V' || keyCode == 86) moveStr = "f";//F'
    else if (key == 'R' || keyCode == 82) moveStr = "R";//R
    else if (key == 'T' || keyCode == 84) moveStr = "r";//R'
    else if (key == 'U' || keyCode == 85) moveStr = "U";//U
    else if (key == 'I' || keyCode == 73) moveStr = "u";//U'
    else if (key == 'B' || keyCode == 66) moveStr = "B";//B
    else if (key == 'N' || keyCode == 78) moveStr = "b";//B'
    else if (key == 'L' || keyCode == 76) moveStr = "L";//L
    else if (key == 'M' || keyCode == 77) moveStr = "l";//L'
    else if (key == 'D' || keyCode == 68) moveStr = "D";//D
    else if (key == 'C' || keyCode == 67) moveStr = "d";//D'
    else if (key == 'A' || keyCode == 65) moveStr = "M";//M
    else if (key == '1' || keyCode == 49 || keyCode == '&') moveStr = "m";//M'
    else if (key == 'Q' || keyCode == 81) moveStr = "S";//S
    else if (key == '2' || keyCode == 50) moveStr = "s";//S'
    else if (key == 'E' || keyCode == 69) moveStr = "E";//E
    else if (key == '3' || keyCode == 51) moveStr = "e";//E'
    else if (key == 'O' || keyCode == 79) moveStr = "LM";//l
    else if (key == 'P' || keyCode == 80) moveStr = "lm";//l'
    else if (key == 'H' || keyCode == 72) moveStr = "Rm";//r
    else if (key == 'J' || keyCode == 74) moveStr = "rM";//r'
    else if (key == 'K' || keyCode == 75) moveStr = "Ue";//u
    else if (/*key == '?' || key == ',' || */keyCode == 44) moveStr = "uE";//u'
    else if ( key == '5' /*|| key == '(' */|| keyCode == 53) moveStr = "FS";//f
    else if ( key == '6' /*|| key == '-' */|| keyCode == 54) moveStr = "fs";//f'
    /*
  if (nbOfMoves>0 && algorithm != "" && inMove) println("moves: "+nbOfMoves);//dans la console
  if (inMove) println("scramble: "+algorithm);//affiche le mélange dans la console*/
    moveStrValid = true;
    algorithm += moveStr;//bien sur en conserve une trace écrite des mouvements fait
    println("moveStr="+moveStr);
    stackOfMoves.push(moveStr.charAt(0));
    println("moveStr="+moveStr+" après");
    println("pile="+stackOfMoves.data[0]+stackOfMoves.data[1]+" top="+stackOfMoves.top);
  }
  if (key==ENTER || keyCode == 10) solve("beginner");//activation manuelle du solveur
  else if (key=='S' || keyCode == 83) {
    if (cubeStyleSelected==9 || cubeStyleSelected==11) WCAScramble();
    else scramble();
  }//lancement du mélangeur et si le cube est le n°10 ou 12 alors le mélange est de catégorie WCA
  else if (/*key == CONTROL || */keyCode == 17) reset();//retour à l'état résolu
  else if (key == 'X' || keyCode == 88) rc.rotR();//x
  else if (key == 'W' || keyCode == 87) rc.rotL();//x'
  else if (key == 'Y' || keyCode == 89) rc.rotU();//y
  else if (key == 'G' || keyCode == 71) rc.rotD();//y'
  else if (key == 'Z' || keyCode == 90) rc.rotateUp();//z
  else if (key == '4' || keyCode == 52) rc.rotateDown();//z'
  else if (key == '0' || keyCode == 48) println("Code du cube: "+rc.codeString());//indique le code du cube au format Singmaster
  else if (key == BACKSPACE || keyCode == BACKSPACE || keyCode == 8) undo();//undo 1 seul mouvement
  else if (key == UP || keyCode == 38 && keyCode != 49) chCubeStyle(1);//va plus haut dans la table à style
  else if (key == DOWN || keyCode == 40 && keyCode != 53) chCubeStyle(-1);//va plus bas ...
}
void chCubeStyle(int n) {//change le style du cube par n rang
  println("changement de style par "+n);
  //réinitialisation au cas où une ou plusieurs face(s) d'un style remplace celle(s) des autres styles pouvant ainsi gaché les autres en question
  vCubeFC[0] = color(127);//D
  vCubeFC[1] = color(255, 127, 0);//B
  vCubeFC[2] = color(0, 0, 255);//R
  vCubeFC[3] = color(255, 0, 0);//F
  vCubeFC[4] = color(0, 255, 0);//L
  vCubeFC[5] = color(0);//U
  girlCFC[0] = color(255, 255, 0);
  girlCFC[1] = color(255, 127, 0);
  girlCFC[2] = color(255, 0, 255);
  girlCFC[3] = color(255, 16, 120);
  girlCFC[4] = color(0, 255, 0);
  girlCFC[5] = color(255);
  cF2C[0] = color(255);
  cF2C[1] = color(255);
  cF2C[2] = color(0);
  cF2C[3] = color(0);
  cF2C[4] = color(255);
  cF2C[5] = color(0);
  cF3C[0] = color(0, 255, 0);
  cF3C[1] = color(255, 0, 0);
  cF3C[2] = color(0, 0, 127);
  cF3C[3] = color(127, 0, 0);
  cF3C[4] = color(0, 0, 255);
  cF3C[5] = color(0, 127, 0);
  MirrorFC[0] = color(210);
  MirrorFC[1] = color(210);
  MirrorFC[2] = color(210);
  MirrorFC[3] = color(210);
  MirrorFC[4] = color(210);
  MirrorFC[5] = color(210);
  MinxFC[0] = color(0, 255, 0);
  MinxFC[1] = color(255, 0, 0);
  MinxFC[2] = color(0, 255, 255);
  MinxFC[3] = color(255, 255, 0);
  MinxFC[4] = color(0, 0, 255);
  MinxFC[5] = color(255, 0, 255);
  OldStyle[0] = color(255);
  OldStyle[1] = color(127);
  OldStyle[2] = color(0);
  OldStyle[3] = color(255);
  OldStyle[4] = color(127);
  OldStyle[5] = color(0);
  WCAClrSch[0] = color(255, 255, 0);
  WCAClrSch[1] = color(0, 0, 255);
  WCAClrSch[2] = color(255, 0, 0);
  WCAClrSch[3] = color(0, 255, 0);
  WCAClrSch[4] = color(255, 128, 0);
  WCAClrSch[5] = color(255);
  TwoFC[0] = color(255, 255, 0);
  TwoFC[1] = color(128, 64);
  TwoFC[2] = color(128, 64);
  TwoFC[3] = color(128, 64);
  TwoFC[4] = color(128, 64);
  TwoFC[5] = color(255);
  Visual[0] = color(255, 255, 0, 127);
  Visual[1] = color(0, 0, 255, 127);
  Visual[2] = color(255, 0, 0, 127);
  Visual[3] = color(0, 255, 0, 127);
  Visual[4] = color(255, 128, 0, 127);
  Visual[5] = color(255, 127);
  cubiesBorder = color(255);//couleur de la bordure du cube
  if (cubeStyleSelected<cubeStyles.length && n==1) cubeStyleSelected++;//si le style n'est pas le dernier de la liste et que le rang de changement est de 1
  else if (cubeStyleSelected>0 && n==-1) cubeStyleSelected--;//si le style n'est pas le premier de la liste et que le rang de changement est de -1
  if (cubeStyleSelected==0) {//si le style sélectionné est le premier
    cubeFaceColors[0] = color(255, 255, 0);
    cubeFaceColors[1] = color(255, 127, 0);
    cubeFaceColors[2] = color(0, 0, 255);
    cubeFaceColors[3] = color(255, 0, 0);
    cubeFaceColors[4] = color(0, 255, 0);
    cubeFaceColors[5] = color(255);
    cubiesBorder = color(0);//bordure du cube de couleur noir
  }
  else if (cubeStyleSelected==1) {//si le style sélectionné est le deuxième
    cubiesBorder = color(255);//bordure du cube de couleur blanche
    cubeFaceColors = vCubeFC;//le schéma de couleur est celui de vCubeFC
  }
  else if (cubeStyleSelected==2) {//...
    cubiesBorder = color(255, 255, 0);
    cubeFaceColors = girlCFC;
  }
  else if (cubeStyleSelected==3) {
    cubiesBorder = color(32);
    cubeFaceColors = cF2C;
  }
  else if (cubeStyleSelected==4) {
    cubiesBorder = color(180);
    cubeFaceColors = cF3C;
  }
  else if (cubeStyleSelected==5) {
    cubiesBorder = color(0);
    cubeFaceColors = MirrorFC;
  }
  else if (cubeStyleSelected==6) {
    cubiesBorder = color(0);
    cubeFaceColors = MinxFC;
  }
  else if (cubeStyleSelected==7) {
    cubiesBorder = color(180);
    cubeFaceColors = OldStyle;
  }
  else if (cubeStyleSelected==8) {
    cubiesBorder = color(127, 0);//pas de bordure
    cubeFaceColors[0] = color(255, 255, 0);
    cubeFaceColors[1] = color(255, 127, 0);
    cubeFaceColors[2] = color(0, 0, 255);
    cubeFaceColors[3] = color(255, 0, 0);
    cubeFaceColors[4] = color(0, 255, 0);
    cubeFaceColors[5] = color(255);
  }
  else if (cubeStyleSelected==9) {
    cubiesBorder = color(0);
    cubeFaceColors = WCAClrSch;
  }
  else if (cubeStyleSelected==10) {
    cubiesBorder = color(0, 200);//a peine transparent
    cubeFaceColors = TwoFC;
  }
  else if (cubeStyleSelected==11) {
    cubiesBorder = color(64, 127);//semi opaque
    cubeFaceColors = Visual;
  }
  if (cubeStyleSelected==8) rc.setSize(5);//particularité visuelle/physique du style n°9
  else reset();//rc.setSize(height/8); pour éviter le sur écartement cubie-cubie sur la globalité des style
}
void faceMove(char face) {//mouvement de face
  char pVal;
  switch(face) {//condition multiple sur la valeur de face
  case 'R': //mouvement R
    axis = 0;//premier axe
    slice = 2;//dernière tranche
    direction = 1;//sens des aiguïlles d'une montre
    pVal = 'r';//mouvement pour l'undo
    break;//evite la boucle dans switch()
  case 'r': 
    axis = 0;
    slice = 2;
    direction = -1;//sens inverse ..
    pVal = 'R';
    break;
  case 'M': 
    axis = 0;
    slice = 1;
    direction = -1;
    pVal = 'm';
    break;
  case 'm': 
    axis = 0;
    slice = 1;
    direction = 1;
    pVal = 'M';
    break;
  case 'L': 
    axis = 0;
    slice = 0;
    direction = -1;
    pVal = 'l';
    break;
  case 'l': 
    axis = 0;
    slice = 0;
    direction = 1;
    pVal = 'L';
    break;
  case 'X': 
    axis = 0;//R
    slice = 2;
    direction = 1;
    axis = 0;//M'
    slice = 1;
    direction = 1;
    axis = 0;//L'
    slice = 2;
    direction = 1;
    pVal = 'x';
    break;
  case 'x': 
    axis = 0;//R'
    slice = 2;
    direction = -1;
    axis = 0;//M
    slice = 1;
    direction = -1;
    axis = 0;//L
    slice = 2;
    direction = -1;
    pVal = 'X';
    break;
  case 'D': 
    axis = 1;
    slice = 0;
    direction = -1;
    pVal = 'd';
    break;
  case 'd': 
    axis = 1;
    slice = 0;
    direction = 1;
    pVal = 'D';
    break;
  case 'E': 
    axis = 1;
    slice = 1;
    direction = -1;
    pVal = 'e';
    break;
  case 'e': 
    axis = 1;
    slice = 1;
    direction = 1;
    pVal = 'E';
    break;
  case 'U': 
    axis = 1;
    slice = 2;
    direction = 1;
    pVal = 'u';
    break;
  case 'u': 
    axis = 1;
    slice = 2;
    direction = -1;
    pVal = 'U';
    break;
  case 'Y': 
    axis = 1;//U
    slice = 2;
    direction = 1;
    axis = 1;//E'
    slice = 1;
    direction = 1;
    axis = 1;//D'
    slice = 0;
    direction = 1;
    pVal = 'y';
    break;
  case 'y': 
    axis = 1;//U'
    slice = 2;
    direction = -1;
    axis = 1;//E
    slice = 1;
    direction = -1;
    axis = 1;//D
    slice = 0;
    direction = -1;
    pVal = 'Y';
    break;
  case 'B': 
    axis = 2;
    slice = 0;
    direction = -1;
    pVal = 'b';
    break;
  case 'b': 
    axis = 2;
    slice = 0;
    direction = 1;
    pVal = 'B';
    break;
  case 'S': 
    axis = 2;
    slice = 1;
    direction = 1;
    pVal = 's';
    break;
  case 's': 
    axis = 2;
    slice = 1;
    direction = -1;
    pVal = 'S';
    break;
  case 'F': 
    axis = 2;
    slice = 2;
    direction = 1;
    pVal = 'f';
    break;
  case 'f': 
    axis = 2;
    slice = 2;
    direction = -1;
    pVal = 'F';
    break;
  case 'Z': 
    axis = 2;//F
    slice = 2;
    direction = 1;
    axis = 2;//S
    slice = 1;
    direction = 1;
    axis = 2;//B'
    slice = 0;
    direction = 1;
    pVal = 'z';
    break;
  case 'z': 
    axis = 2;//F'
    slice = 2;
    direction = -1;
    axis = 2;//S'
    slice = 1;
    direction = -1;
    axis = 2;//B
    slice = 0;
    direction = -1;
    pVal = 'Z';
    break;
  default:
    return;
  }
  println(pVal);
  //undoStr[undoStr.length] = pVal;//undoStr.push(pVal);
  move(true);//autorise le mouvement
}
void undo() {//comme son nom l'indique
  println("entré dans undo() pile="+stackOfMoves+" top="+stackOfMoves.top);
  //if(!inMove){//pour éviter d'interrompre l'algorithme en cour
  //println("pas en mouvement");
  char p = stackOfMoves.pop();//retire le dernier mouvements enregistré dans le stack
  println("undo par "+moveUndo(p)+" donné: "+stackOfMoves.data[0]+stackOfMoves.data[1]+" top="+stackOfMoves.top);
  faceMove(moveUndo(p));//refait les mouvements sans le dernier
  //moveStr = join(split(undoStr[undoStr.length-1]+"", ""), "");moveStrValid = true;// pour (char) pVal et (char[]) undoStr
  //undoStr.pop(undoStr.length-1);
  /*String poping = join(split(undoStr[undoStr.length-1]+"", ""), "").substring(0, undoStr.length-2);
   String[] popedStr = split(poping, "");*/
  //}else println("en mouvement");
}

void computeBoundaries() {//frontière du cube (pas important)
  PVector pt[] = new PVector[8];//tableau à 8 vecteur pour les premiers points
  PVector pt2[] = new PVector[8];//... les deuxièmes point
  for (int i=0;i<8;i++) {//remplis les deux tableau en fonction de l'abscisse et de l'ordonné des points de frontière du cube apparaisant sur le plan 2D de l'écran à partir du plan 3D du cube
    pt[i] = new PVector(screenX(rc.boundary.points[i].x, rc.boundary.points[i].y, rc.boundary.points[i].z), 
    screenY(rc.boundary.points[i].x, rc.boundary.points[i].y, rc.boundary.points[i].z), 0.0);
    pt2[i] = new PVector(screenX(rc.boundary2.points[i].x, rc.boundary2.points[i].y, rc.boundary2.points[i].z), 
    screenY(rc.boundary2.points[i].x, rc.boundary2.points[i].y, rc.boundary2.points[i].z), 0.0);
  }
  //points visible sur la vue avant
  //frontière du haut
  topBound = new PVector[4];
  topBound[0] = new PVector(pt[4].x, pt[4].y, pt[4].z);
  topBound[1] = new PVector(pt[5].x, pt[5].y, pt[5].z);
  topBound[2] = new PVector(pt[7].x, pt[7].y, pt[7].z);
  topBound[3] = new PVector(pt[6].x, pt[6].y, pt[6].z);
  //frontière du devant
  frontBound = new PVector[4];
  frontBound[0] = new PVector(pt[0].x, pt[0].y, pt[0].z);
  frontBound[1] = new PVector(pt[1].x, pt[1].y, pt[1].z);
  frontBound[2] = new PVector(pt[5].x, pt[5].y, pt[5].z);
  frontBound[3] = new PVector(pt[4].x, pt[4].y, pt[4].z);
  //frontière de droite
  rightBound = new PVector[4];
  rightBound[0] = new PVector(pt[0].x, pt[0].y, pt[0].z);
  rightBound[1] = new PVector(pt[2].x, pt[2].y, pt[2].z);
  rightBound[2] = new PVector(pt[6].x, pt[6].y, pt[6].z);
  rightBound[3] = new PVector(pt[4].x, pt[4].y, pt[4].z);
  //points visible sur la vue arrière
  //frontière du bas
  downBound = new PVector[4];
  downBound[0] = new PVector(pt2[0].x, pt2[0].y, pt2[0].z);
  downBound[1] = new PVector(pt2[2].x, pt2[2].y, pt2[2].z);
  downBound[2] = new PVector(pt2[3].x, pt2[3].y, pt2[3].z);
  downBound[3] = new PVector(pt2[1].x, pt2[1].y, pt2[1].z);
  //frontière de l'arrière
  backBound = new PVector[4];
  backBound[0] = new PVector(pt2[2].x, pt2[2].y, pt2[2].z);
  backBound[1] = new PVector(pt2[6].x, pt2[6].y, pt2[6].z);
  backBound[2] = new PVector(pt2[7].x, pt2[7].y, pt2[7].z);
  backBound[3] = new PVector(pt2[3].x, pt2[3].y, pt2[3].z);
  //frontière de gauche
  leftBound = new PVector[4];
  leftBound[0] = new PVector(pt2[1].x, pt2[1].y, pt2[1].z);
  leftBound[1] = new PVector(pt2[3].x, pt2[3].y, pt2[3].z);
  leftBound[2] = new PVector(pt2[7].x, pt2[7].y, pt2[7].z);
  leftBound[3] = new PVector(pt2[5].x, pt2[5].y, pt2[5].z);
}
void strOfMoves() {//algorithme
  if (!inMove) {//si il n'y pas de risque de perturber l'algorithme en cour
    if (strMoveCount < moveStr.length()) {//si le compte de mouvement est inférieur au nombre de mouvement
      faceMove(moveStr.charAt(strMoveCount));//se place au dernier mouvement comptabilisé par strMoveCount
      strMoveCount++;//incrémente strMoveCount de 1
      nbOfMoves++;
    }
    else {
      moveStrValid = false;//sinon l'ajout de mouvement est invalidé
      strMoveCount = 0;//remise à zero
    }
  }
}
int ms=00, s=00, min=00;
void startTimer() {//chronomètre
  if (!rc.isSolved()) {//si le cube est résolut ça n'a pas de sens
    ms++;//augmentation des milliseconde
    if (ms>=100) {
      s++;
      ms=00;
    }//si t=100ms : t=1s
    if (s>=60) {
      min++;
      s=00;
    }//si t=60s : t=1min
  }
  else if (ms>=0 && s>0) {
    println("["+millis()+"] "+min+":"+s+"."+ms);
    min=00;
    s=00;
    ms=00;
  }//affiche temps et le moment où la résolution c'est terminée et aussi pour éviter d'affiche le temps alors qu'il n'y a pas eu de résolution
}
char moveUndo(char move) {
  String str = move+"";
  if (str.equals(str.toLowerCase())) {
    return str.toUpperCase().charAt(0);
  }
  else return str.toLowerCase().charAt(0);
}