TwistyPuzzleLib

  public int[][] getMoveTable()

    {

    return mMoveTable;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int findMove(int ax, int row, int angle)

    {

    int num = mMoveTable.length;

    int basicAngle = mBasicAngles[ax][row];

    for( int m=0; m<num; m++)

      {

      int[] move = mMoveTable[m];

      if( ax==move[0] && row==move[1] && ((angle-move[2])%basicAngle)==0 ) return m;

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int[] findMove(int index)

    {

    return mMoveTable[index];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2024 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.algsolvers.implemented;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.algsolvers.*;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class Solver3x3Beginner  

{

  private final SolvedObject mObject;

  private final SolverPhased mSolver;

///////////////////////////////////////////////////////////////////////////////////////////////////

  public Solver3x3Beginner()

    {

    float A = 1.0f;

    float B = 0.0f;

    float[][] pos   = new float[][]

                       {

                               {-A,-A,-A},

                               {-A,-A, A},

                               {-A, A,-A},

                               {-A, A, A},

                               { A,-A,-A},

                               { A,-A, A},

                               { A, A,-A},

                               { A, A, A},

                               { B,-A,-A},

                               { B,-A, A},

                               { B, A,-A},

                               { B, A, A},

                               {-A, B,-A},

                               {-A, B, A},

                               { A, B,-A},

                               { A, B, A},

                               {-A,-A, B},

                               {-A, A, B},

                               { A,-A, B},

                               { A, A, B},

                               { A, B, B},

                               {-A, B, B},

                               { B, A, B},

                               { B,-A, B},

                               { B, B, A},

                               { B, B,-A}

                       };        

    Static3D[] axis = new Static3D[] { new Static3D(1,0,0), new Static3D(0,1,0), new Static3D(0,0,1) };

    int[] a = new int[] {4,4,4};

    int[][] angles  = new int[][] { a,a,a };

    float[] c = new float[] {-0.5f,0.5f};

    float[][] cuts  = new float[][] {c,c,c};

    boolean[] r = {true,false,true};

    boolean[][] rot = {r,r,r};

    mObject = new SolvedObject(pos,axis,angles,cuts,rot);

    int[][] moveTable   = mObject.getMoveTable();

    int[][] whiteCross   = new int[][]{ {12,13,16,17} };

    int[][] whiteCorners = new int[][]{ {0},{1},{2},{3} };

    int[][] secondLayer  = new int[][]{ {8},{9},{10},{11} };

    String a1 = "(3){-1,0,1,2}(6,3,8,3,15,5,17)";

    String a2 = "(3){-1,0,1,2}(15,5,17,5,6,3,8)";

    String a3 = "(3){-1,0,1,2}(12,3,14,3,8,5,6)";

    String a4 = "(3){-1,0,1,2}(8,5,6,5,12,3,14)";

    String a5 = "(3){-1,0,1,2}(11,3,9,3,14,5,12)";

    String a6 = "(3){-1,0,1,2}(14,5,12,5,11,3,9)";

    String a7 = "(3){-1,0,1,2}(17,3,15,3,9,5,11)";

    String a8 = "(3){-1,0,1,2}(9,5,11,5,17,3,15)";

    MoveProviderAll all = new MoveProviderAll(moveTable);

    MoveProviderAlgs asl = new MoveProviderAlgs(mObject, "["+a1+";"+a2+";"+a3+";"+a4+";"+a5+";"+a6+";"+a7+";"+a8+"]");

    MoveProviderAlgs aeO = new MoveProviderAlgs(mObject, "(3){-1,0,1,2}(11,17,5,15,3,9)");

    MoveProviderAlgs aeP = new MoveProviderAlgs(mObject, "(3){-1,0,1,2}(6,5,8,5,6,4,8){0,1}");

    MoveProviderAlgs acP = new MoveProviderAlgs(mObject, "(3){-1,0,1,2}(5,6,3,9,5,8,3,11){0,1}");

    MoveProviderAlgs acO = new MoveProviderAlgs(mObject, "(3){-1,0,1,2}(15,2,17,0){-2,0,2}");

    TargetProvider wcr = new TargetProviderAll(whiteCross);

    TargetProvider wco = new TargetProviderAll(whiteCorners);

    TargetProvider sla = new TargetProviderAll(secondLayer);

    TargetProvider oll = new TargetProviderOrie(mObject,14,1);

    TargetProvider pll = new TargetProviderPerm(mObject,14,1);

    TargetProvider pcl = new TargetProviderPerm(mObject, 4,1);

    TargetProvider ocl = new TargetProviderOrie(mObject, 4,1);

    Phase[] phases =

      {

      new PhaseMitm( mObject, all, wcr),

      new PhaseMitm( mObject, all, wco),

      new PhaseMitm( mObject, asl, sla),

      new PhaseMitm( mObject, aeO, oll),

      new PhaseMitm( mObject, aeP, pll),

      new PhaseMitm( mObject, acP, pcl),

      new PhaseMitm( mObject, acO, ocl),

      };

    mSolver = new SolverPhased(mObject,phases);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public SolvedObject getObject()

    {

    return mObject;      

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int[][] solution(int[] quats)

    {

    return mSolver.solution(quats);  

    }

}