Example #1
0
  /**
   * Résout le cas de permutation dans lequel on se trouve
   *
   * @param _permutation La permutation à effectuer
   */
  private void resoudrePermutation(TypePermutation _permutation) throws PositionNonValideException {
    Algorithme algoPermutation = null;
    switch (_permutation) {
      case EDGES:
        /* On est dans les cas où les corners sont tous bien permutés, seulement des edges à permuter */
        {
          /* Teste si 3-cycle sens anti-trigo càd algo PLL 1 */
          if ((cube.obtenirCouleurDUnePositionOrientation(new Position(3, 2, 3), Orientation.F)
                  != cube.obtenirCouleurDUnePositionOrientation(
                      new Position(3, 1, 3), Orientation.F))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 3, 3), Orientation.R)
                  != cube.obtenirCouleurDUnePositionOrientation(
                      new Position(3, 3, 3), Orientation.R))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(1, 2, 3), Orientation.B)
                  != cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 3, 3), Orientation.B))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 1, 3), Orientation.L)
                  != cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 1, 3), Orientation.L))) {
            // algoPermutation=new Algorithme("R R U R U Rp Up Rp Up Rp U Rp");
            algoPermutation = baseAlgo.obtenirPLL(1);
          } else
          /* Si côté plein en F */
          if (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 2, 3), Orientation.F)
              == cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)) {
            algoPermutation = new Algorithme("U U");
            /* Si PLL 1*/
            if ((cube.obtenirCouleurDUnePositionOrientation(new Position(1, 2, 3), Orientation.B)
                == cube.obtenirCouleurDUnePositionOrientation(
                    new Position(1, 3, 3), Orientation.R))) {
              // algoPermutation=new Algorithme("U U R R U R U Rp Up Rp Up Rp U Rp");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(1));
            }
            /* Sinon PLL 2 */
            else {
              // algoPermutation=new Algorithme("U U R Up R U R U R Up Rp Up R R");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(2));
            }
          }
          /* Sinon si côté plein en L */
          else if (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 1, 3), Orientation.L)
              == cube.obtenirCouleurDUnePositionOrientation(new Position(1, 1, 3), Orientation.L)) {
            algoPermutation = new Algorithme("U");

            /* Si PLL 1 */
            if ((cube.obtenirCouleurDUnePositionOrientation(new Position(2, 3, 3), Orientation.R)
                == cube.obtenirCouleurDUnePositionOrientation(
                    new Position(3, 3, 3), Orientation.F))) {
              // algoPermutation=new Algorithme("U R R U R U Rp Up Rp Up Rp U Rp");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(1));
            }
            /* Sinon PLL 2 */
            else {
              // algoPermutation=new Algorithme("U R Up R U R U R Up Rp Up R R");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(2));
            }
          }
          /* Sinon si côté plein en B */
          else if (cube.obtenirCouleurDUnePositionOrientation(new Position(1, 2, 3), Orientation.B)
              == cube.obtenirCouleurDUnePositionOrientation(new Position(1, 3, 3), Orientation.B)) {
            /* Si PLL 1*/
            if ((cube.obtenirCouleurDUnePositionOrientation(new Position(3, 2, 3), Orientation.F)
                == cube.obtenirCouleurDUnePositionOrientation(
                    new Position(3, 1, 3), Orientation.L))) {
              // algoPermutation=new Algorithme("R R U R U Rp Up Rp Up Rp U Rp");
              algoPermutation = baseAlgo.obtenirPLL(1);
            }
            /* Sinon PLL 2*/
            else {
              // algoPermutation=new Algorithme("R Up R U R U R Up Rp Up R R");
              algoPermutation = baseAlgo.obtenirPLL(2);
            }
          }
          /* Sinon il ne reste que côté plein en R possible ou alors il y avait 4 edges mal permutés */
          else {
            algoPermutation = new Algorithme("Up");
            /* Si PLL 1 */
            if ((cube.obtenirCouleurDUnePositionOrientation(new Position(2, 1, 3), Orientation.L)
                == cube.obtenirCouleurDUnePositionOrientation(
                    new Position(1, 1, 3), Orientation.B))) {
              // algoPermutation=new Algorithme("Up R R U R U Rp Up Rp Up Rp U Rp");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(1));
            }
            /* Sinon PLL 2*/
            else {
              // algoPermutation=new Algorithme("Up R Up R U R U R Up Rp Up R R");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(2));
            }
          }
        }
        break;

      case CORNERS:
        {
          /* Si 2 corners à permuter en diagonale càd PLL 12 */
          if ((cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)
                  != (cube.obtenirCouleurDUnePositionOrientation(
                      new Position(3, 3, 3), Orientation.F)))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 3, 3), Orientation.R)
                  != (cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 3, 3), Orientation.R)))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.L)
                  != (cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 1, 3), Orientation.L)))
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(1, 1, 3), Orientation.B)
                  != (cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 3, 3), Orientation.B))))
            algoPermutation = baseAlgo.obtenirPLL(12);

          /* Sinon c'est qu'il y a 2 corners adjacents à permuter */
          else {
            /* Si les 2 corners bien placés sont en F */
            if (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)
                == (cube.obtenirCouleurDUnePositionOrientation(
                    new Position(3, 3, 3), Orientation.F))) {
              // algoPermutation=new Algorithme("Up F F R U Rp F F L Dp L D L L");
              algoPermutation = new Algorithme("Up");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(8));
            }
            /* Sinon si les 2 corners bien placés sont en R */
            else if (cube.obtenirCouleurDUnePositionOrientation(
                    new Position(3, 3, 3), Orientation.R)
                == (cube.obtenirCouleurDUnePositionOrientation(
                    new Position(1, 3, 3), Orientation.R))) {
              algoPermutation = baseAlgo.obtenirPLL(8);
            }
            /* Sinon si les 2 corners bien placés sont en L */
            else if (cube.obtenirCouleurDUnePositionOrientation(
                    new Position(3, 1, 3), Orientation.L)
                == (cube.obtenirCouleurDUnePositionOrientation(
                    new Position(1, 1, 3), Orientation.L))) {
              algoPermutation = baseAlgo.obtenirPLL(7);
            }
            /* Sinon les 2 corners bien placés sont forcément  en B */
            else {
              algoPermutation = new Algorithme("U");
              algoPermutation.concatenerAlgorithmes(baseAlgo.obtenirPLL(8));
            }
          }
        }
        break;
    }
    this.solution.concatenerAlgorithmes(algoPermutation);
    algoPermutation.executerSurCube(this.cube);
  }
Example #2
0
  /**
   * Résout le cas d'orientation dans lequel on se trouve
   *
   * @param _orientation L'orientation à effectuer
   */
  private void resoudreOrientation(TypeOrientation _orientation) throws PositionNonValideException {
    Algorithme algoOrientation = null;
    Algorithme setupOrientation = null;
    switch (_orientation) {
      case POINT:
        {
          // algoOrientation=new Algorithme("F R U Rp Up Fp f R U Rp Up fp");
          algoOrientation = baseAlgo.obtenirOLL(2);
        }
        break;

      case BARRE:
        {
          if (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 2, 3), Orientation.U)
              == COULEUR_U) {
            // algoOrientation=new Algorithme("U F R U Rp Up Fp");
            algoOrientation = new Algorithme("U");
            algoOrientation.concatenerAlgorithmes(baseAlgo.obtenirOLL(21));
          } else algoOrientation = baseAlgo.obtenirOLL(21);
        }
        break;

      case HORLOGE:
        {
          if ((cube.obtenirCouleurDUnePositionOrientation(new Position(3, 2, 3), Orientation.U)
                  == COULEUR_U)
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 1, 3), Orientation.U)
                  == COULEUR_U)) {
            // algoOrientation=new Algorithme("Up f R U Rp Up fp");
            algoOrientation = new Algorithme("Up");
            algoOrientation.concatenerAlgorithmes(baseAlgo.obtenirOLL(43));
          } else if ((cube.obtenirCouleurDUnePositionOrientation(
                      new Position(3, 2, 3), Orientation.U)
                  == COULEUR_U)
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 3, 3), Orientation.U)
                  == COULEUR_U)) {
            // algoOrientation=new Algorithme("f R U Rp Up fp");
            algoOrientation = baseAlgo.obtenirOLL(43);
          } else if ((cube.obtenirCouleurDUnePositionOrientation(
                      new Position(1, 2, 3), Orientation.U)
                  == COULEUR_U)
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(2, 3, 3), Orientation.U)
                  == COULEUR_U)) {
            // algoOrientation=new Algorithme("U f R U Rp Up fp");
            algoOrientation = new Algorithme("U");
            algoOrientation.concatenerAlgorithmes(baseAlgo.obtenirOLL(43));
          } else {
            // algoOrientation=new Algorithme("U U f R U Rp Up fp");
            algoOrientation = new Algorithme("U U");
            algoOrientation.concatenerAlgorithmes(baseAlgo.obtenirOLL(43));
          }
        }
        break;

      case CROIX:
        {
          while (!(cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)
                  != COULEUR_U)
              && (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 3, 3), Orientation.F)
                  != COULEUR_U)) {
            if (setupOrientation == null) setupOrientation = new Algorithme("U");
            else setupOrientation.concatenerAlgorithmes(new Algorithme("U"));

            this.solution.concatenerAlgorithmes(setupOrientation);
            setupOrientation.executerSurCube(this.cube);
          }
          // algoOrientation=new Algorithme("R U Rp U R U U Rp");
          algoOrientation = baseAlgo.obtenirOLL(56);
        }
        break;

      case MARTEAU_DOUBLEPOISSON:
        {
          while (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)
              != COULEUR_U) {
            if (setupOrientation == null) setupOrientation = new Algorithme("U");
            else setupOrientation.concatenerAlgorithmes(new Algorithme("U"));

            this.solution.concatenerAlgorithmes(setupOrientation);
            setupOrientation.executerSurCube(this.cube);
          }
          // algoOrientation=new Algorithme("R U Rp U R U U Rp");
          algoOrientation = baseAlgo.obtenirOLL(56);
        }
        break;

      case POISSON:
        {
          while (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 3, 3), Orientation.U)
              != COULEUR_U) {
            if (setupOrientation == null) setupOrientation = new Algorithme("U");
            else setupOrientation.concatenerAlgorithmes(new Algorithme("U"));

            this.solution.concatenerAlgorithmes(setupOrientation);
            setupOrientation.executerSurCube(this.cube);
          }
          if (cube.obtenirCouleurDUnePositionOrientation(new Position(3, 1, 3), Orientation.F)
              == COULEUR_U) {
            // algoOrientation=new Algorithme("Lp Up L Up Lp U U L");
            algoOrientation = baseAlgo.obtenirOLL(55);
          } else {
            // algoOrientation=new Algorithme("U R U Rp U R U U Rp");
            algoOrientation = new Algorithme("U");
            algoOrientation.concatenerAlgorithmes(baseAlgo.obtenirOLL(56));
          }
        }
        break;

      default:
        algoOrientation = null;
        break;
    }
    this.solution.concatenerAlgorithmes(algoOrientation);
    algoOrientation.executerSurCube(this.cube);
  }