TwistyPuzzleLib

import org.distorted.objectlib.algsolvers.TargetQuats;

  protected int mNumCubitsInThisPhase;

  protected TargetQuats mTargetQuats;

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

  Phase(SolvedObject object)

    {

    float[][] pos = object.getCubitPositions();

    mNumCubits = pos.length;

    }

      for(int j : mCubitGroups[g])

  public int[] endQuatIndices(SolvedObject object, int cubit)

  public void setTargetQuats(SolvedObject object, boolean[] inPreviousPhases)

    int len = inPreviousPhases.length;

    int[][] target = new int[len][];

    for(int c=0; c<len; c++)

      {

      if( inPreviousPhases[c] ) target[c] = INDICES;

      else if( contains(c) )    target[c] = endQuatIndices(object,c);

      else                      target[c] = null;

      }

    mTargetQuats = new TargetQuats(target);

    super(object);

    mNumCubitsInThisPhase = (int)(numTurns+0.5f);

    mCubitGroups  = new int[1][mNumCubitsInThisPhase];

    for(int c=1; c<mNumCubitsInThisPhase; c++)

  public int[] endQuatIndices(SolvedObject object, int cubit)

    int[] retQuats = new int[mNumCubitsInThisPhase];

    for(int i=2; i<mNumCubitsInThisPhase; i++)

    super(object);

    mNumCubitsInThisPhase = (int)(numTurns+0.5f);

    mCubitGroups  = new int[1][mNumCubitsInThisPhase];

    for(int c=1; c<mNumCubitsInThisPhase; c++)

    super(object);

    mNumCubitsInThisPhase = (int)(numTurns+0.5f);

    mCubitGroups  = new int[1][mNumCubitsInThisPhase];

    for(int c=1; c<mNumCubitsInThisPhase; c++)

  public int[] endQuatIndices(SolvedObject object, int cubit)

      QuatHelper.rotateVectorByQuat(tmp,x,y,z,1,mObjectQuats[q]);

        tmpQuats[q] = 1;

    super(object);

    mNumCubitsInThisPhase = (int)(numTurns+0.5f);

    mCubitGroups  = new int[1][mNumCubitsInThisPhase];

    for(int c=1; c<mNumCubitsInThisPhase; c++)

import org.distorted.objectlib.algsolvers.TargetQuats;

  private int mDepth, mGroup;

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

  PhaseMitm(SolvedObject object)

    {

    super(object);

    }

    return table.tryReaching(object,mTargetQuats,tmpBackward,tmpForward);

    table.prepareForSubPhase(mTargetQuats);

    int multiplier = mTargetQuats.computeNumCombinations();

    mWhichSubphase = new int[mNumCubits];

    for(int c=0; c<mNumCubits; c++) mWhichSubphase[c] = whichSubPhase(c);

    mGroup = 0;

  public boolean solveAnySubphase( SolvedObject object, MitmTable table, int[][] solution, int subPhase)

    int maxDepth = mDepth+1;  // this might mean that we do one extra depth, but if we set it to

                              // mDepth then if after current mGroups there are no more unsolved

                              // subgroups, we will simply give up and end solving altogether!

    TargetQuats tmp = new TargetQuats(mTargetQuats);

    for( ; mDepth<=maxDepth; mDepth++,mGroup=0)

      for(int g=mGroup; g<mNumGroups; g++)

        if( !mSolved[g] )

          for(int q=0; q<mNumCubits; q++)

            // -1 means that the cubit doesn't belong to the current phase. Cubits belonging to

            // the next phase already have their targetQuats set to null (see Phase.setTargetQuats)

            // Here we set to null (mark that we do not care about) the quats of all cubits which

            int wsp = mWhichSubphase[q];

            int[] newValue = (wsp==-1 || wsp==g || mSolved[wsp]) ? tmp.getQuat(q) : null;

            mTargetQuats.setQuat(newValue,q);

          solution[subPhase] = findSol(object,table,mDepth);

          if( solution[subPhase]!=null )

            mTargetQuats.set(tmp);

            mSolved[g] = true;

            mGroup = g+1;   // when we get called next time, do not repeat the calculations

    mTargetQuats.set(tmp);

import org.distorted.objectlib.algsolvers.SolvedObject;

  public PhaseNotCyclic(SolvedObject object, int[][] cubitgroups)

    super(object);

    mNumCubitsInThisPhase = numCubits;

import org.distorted.objectlib.algsolvers.TargetQuats;

    super(object);

    mNumCubitsInThisPhase = numCubits;

    mTmp = new int[mNumCubits][];

    mWhichSubphase = new int[mNumCubits];

    for(int c=0; c<mNumCubits; c++) mWhichSubphase[c] = whichSubPhase(c);

      boolean solved = mTargetQuats.matchesQuats(qts);

    TargetQuats tmp = new TargetQuats(mTargetQuats);

        for(int q=0; q<mNumCubits; q++)

          int[] newValue = (sp==-1 || sp==p || mSolved[sp]) ? mTmp[q] : null;

          mTargetQuats.setQuat(newValue,q);

          mTargetQuats.set(tmp);

    mTargetQuats.set(tmp);

  public void prepareForSubPhase(TargetQuats quats)

    int numUsedCubits = quats.computeUsedCubitTable(mUseCubit);

  public int[] tryReaching(SolvedObject object, TargetQuats target, int lenb, int lenf)

    int[] quats = target.getFirst();

      object.setUpStartingQuats(quats);

      quats = target.getNext();

    while( quats!=null );

    int subPhase=0;

    int[][] solution = new int[numSubphases][];

    for(; subPhase<numSubphases; subPhase++)

      if( !phase.solveAnySubphase(mObject,mTable,solution,subPhase) )

        System.out.println("findSolutionSubphases: failed to solve subphase "+subPhase);

    if( subPhase>0 )

      for(int i=0; i<subPhase; i++) num += (solution[i].length-1);

      for(int i=0; i<subPhase; i++)

  private int[] solutionOfPhase(int currentPhase)

    boolean[] previousPhases = new boolean[numCubits];

      for(int p=0; p<currentPhase; p++)

        if( mPhases[p].contains(c) )

          {

          previousPhases[c] = true;

          break;

          }

    Phase phase = mPhases[currentPhase];

    int numSubphases = phase.numSubphases();

    phase.setTargetQuats(mObject,previousPhases);

      return findSolutionSubphases(phase,numSubphases);

      return phase.findSolution(mObject,mTable);

    for(int p=0; p<mNumPhases; p++)

      solution_moves[p] = solutionOfPhase(p);

      if( solution_moves[p]==null )

        System.out.println("AlgSolver: error solving phase "+p);

        System.out.println("AlgSolver: phase "+p+" solution len: "+solution_moves[p][0]+" time: "+(next-millis));

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

// 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;

public class TargetQuats

{

  private final int[][] mEndQuats;

  private final int[] mTmp;

  private final int[] mIndices;

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

  public TargetQuats(int[][] endQuats)

    {

    int len = endQuats.length;

    mEndQuats = endQuats;

    mTmp = new int[len];

    mIndices = new int[len];

    }

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

  public TargetQuats(TargetQuats source)

    {

    int len = source.mEndQuats.length;

    mEndQuats = new int[len][];

    System.arraycopy(source.mEndQuats,0,mEndQuats,0,len);

    mTmp = new int[len];

    mIndices = new int[len];

    }

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

  public String debug()

    {

    return MitmTable.getMultiQuatString(mEndQuats);

    }

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

  public void set(TargetQuats source)

    {

    int len = mEndQuats.length;

    System.arraycopy(source.mEndQuats,0,mEndQuats,0,len);

    }

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

  public void setQuat(int[] source, int quat)

    {

    mEndQuats[quat] = source;

    }

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

  public int[] getQuat(int quat)

    {

    return mEndQuats[quat];

    }

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

// how many combinations are we going to have to start from when reachingBack to the MitmTable?

  public int computeNumCombinations()

    {

    int num = 1;

    for( int[] quats : mEndQuats )

      if( quats!=null ) num *= quats.length;

    return num;

    }

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

  public int computeUsedCubitTable(boolean[] table)

    {

    int len = mEndQuats.length;

    int numUsedCubits = 0;

    for(int e=0; e<len; e++)

      {

      if( mEndQuats[e]!=null )

        {

        numUsedCubits++;

        table[e] = true;

        }

      else

        {

        table[e] = false;

        }

      }

    return numUsedCubits;

    }

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

  public int[] getFirst()

    {

    int len = mEndQuats.length;

    for(int q=0; q<len; q++) mIndices[q] = 0;

    return getCurrent();

    }

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

  public int[] getNext()

    {

    if( incIndices() ) return getCurrent();

    return null;

    }

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

  public boolean matchesQuats(int[] quats)

    {

    int numQuats = quats.length;

    for(int q=0; q<numQuats; q++)

      {

      int[] eq = mEndQuats[q];

      if( eq!=null && doesntMatch(quats[q],eq) ) return false;

      }

    return true;

    }

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

  private boolean incIndices()

    {

    for(int i=mIndices.length-1; i>=0; i--)

      {

      int[] q = mEndQuats[i];

      int len = q!=null ? q.length-1 : 0;

      if( mIndices[i]<len )

        {

        mIndices[i]++;

        return true;

        }

      }

    return false;

    }

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

  private boolean doesntMatch(int quat, int[] endquats)

    {

    for(int endquat : endquats)

      if( quat==endquat ) return false;

    return true;

    }

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

  private int[] getCurrent()

    {

    int len = mEndQuats.length;

    for(int q=0; q<len; q++)

      {

      int[] qs = mEndQuats[q];

      mTmp[q] = (qs==null ? -1 : qs[mIndices[q]]);

      }

    return mTmp;

    }

}