TwistyPuzzleLib

// METHOD 0

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

// ATM this works only for puzzles which do not have clearly defined external walls - i.e. do not

// have flat surfaces perpendicular to some axis passing through the center of the puzzle as their

// external walls. I.e: the Penrose Cubes and the Masterball.

// And in case of the 3 Mirror objects ( MirrorJing, MirrorPyraminx, MirrorSkewb) - TBH I am not

// sure if those three couldn't be the default.

// Maybe they could right now, but the default can get it wrong if the 'surfaces' (all cuts at the

// initial state multiplied by all the quats) are too close to each other --> maybe if the change

// the 'offset' vector of the Mirrors, the solved state detection will suddenly stop working. Ergo:

// this is much safer.

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

  private boolean isSolved0(TwistyObjectCubit[] cubits)

    if( mSolvedQuats[0][0]==0 ) return isSolvedCentersOnly(cubits);

    for( int[] solvedQuat : mSolvedQuats )

      int numCubits = solvedQuat[0];

      int firstCubit= solvedQuat[1];

      int quat = cubits[firstCubit].mQuatIndex;

      for( int cubit=2; cubit<=numCubits; cubit++ )

        int c = solvedQuat[cubit];

        if( quat != cubits[c].mQuatIndex ) return false;

      }

    int cubit= mSolvedQuats[0][1];

    int quat0= cubits[cubit].mQuatIndex;

    int numGroups = mSolvedQuats.length;

    for(int group=1; group<numGroups; group++)

      {

      int firstCubit= mSolvedQuats[group][1];

      int currQuat  = cubits[firstCubit].mQuatIndex;

      if( quat0==currQuat ) continue;

      boolean isGood= false;

      int numEntries= mSolvedQuats[group].length;

      int numCubits = mSolvedQuats[group][0];

      for(int q=numCubits+1; q<numEntries; q++)

        int quat = mSolvedQuats[group][q];

        if( currQuat == getMultQuat(quat0,quat) )

          {

          isGood = true;

          break;

          }

      if( !isGood ) return false;

      }

    return true;

    }

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

// METHOD 1

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

// Dino4 uses this. It is solved if and only if groups of cubits

// (0,3,7), (1,2,5), (4,8,9), (6,10,11)

// or

// (0,1,4), (2,3,6), (5,9,10), (7,8,11)

// are all the same color.

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

  private int computeScramble(int quatNum, int centerNum)

    {

    float MAXDIFF = 0.01f;

    float[] center= mOrigPos[centerNum];

    Static4D sc = new Static4D(center[0], center[1], center[2], 1.0f);

    Static4D result = QuatHelper.rotateVectorByQuat(sc,mObjectQuats[quatNum]);

    float x = result.get0();

    float y = result.get1();

    float z = result.get2();

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

      {

      float[] cent = mOrigPos[c];

      float qx = cent[0] - x;

      float qy = cent[1] - y;

      float qz = cent[2] - z;

      if( qx>-MAXDIFF && qx<MAXDIFF &&

          qy>-MAXDIFF && qy<MAXDIFF &&

          qz>-MAXDIFF && qz<MAXDIFF  ) return c;

  private boolean isSolved1(TwistyObjectCubit[] cubits)

    if( mScramble==null )

      {

      mScramble = new int[mNumQuats][mNumCubits];

      mColors   = new int[mNumCubits];

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

        for(int c=0; c<mNumCubits; c++) mScramble[q][c] = computeScramble(q,c);

      }

    if( mFaceMap==null )

      {

      mFaceMap = new int[] { 4, 2, 2, 4, 0, 2, 1, 4, 0, 0, 1, 1 };

      }

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

      {

      int index = mScramble[cubits[c].mQuatIndex][c];

      mColors[index] = mFaceMap[c];

      }

    if( mColors[0]==mColors[3] && mColors[0]==mColors[7] &&

        mColors[1]==mColors[2] && mColors[1]==mColors[5] &&

        mColors[4]==mColors[8] && mColors[4]==mColors[9]  ) return true;

    if( mColors[0]==mColors[1] && mColors[0]==mColors[4] &&

        mColors[2]==mColors[3] && mColors[2]==mColors[6] &&

        mColors[5]==mColors[9] && mColors[5]==mColors[10] ) return true;

    return false;

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

// METHOD 2

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

// The main solver - works by checking if all external walls of the puzzle are monochromatic.

// Almost all puzzles use this one.

  private int surfaceExists(ArrayList<TwistyObjectSurface> list, TwistyObjectSurface surface)

    int size = list.size();

    for(int s=0; s<size; s++)

      if( surface.isSame(list.get(s)) ) return s;

    return -1;

    }

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

  private int adjoinNewSurface(ArrayList<TwistyObjectSurface> list, TwistyObjectSurface si)

    {

    int index = surfaceExists(list,si);

    if( index>=0 ) return index;

    list.add(si);

    return list.size()-1;

    ArrayList<TwistyObjectSurface> tmpSurfaces = new ArrayList<>();

        TwistyObjectSurface si = new TwistyObjectSurface(surface);

        int index = surfaceExists(tmpSurfaces,si);

            TwistyObjectSurface ts = si.rotateSurface(mObjectQuats[q]);

      TwistyObjectSurface si = tmpSurfaces.get(s);

      if( si.getIndices() == null )

          TwistyObjectSurface ts = si.rotateSurface(mObjectQuats[q]);

      mSurfaceTable[s] = si.getIndices();

  private void debugSurfaceTable(ArrayList<TwistyObjectSurface> surfaces)

    int numSurfaces = surfaces.size();

    android.util.Log.e("D", "numSurfaces: "+numSurfaces);

    for(int s=0; s<numSurfaces; s++)

      sb.append(surfaces.get(s).print());

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

// PUBLIC API

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

  TwistyObjectSolved(TwistyObject parent, float[][] orig, int index)

    {

    mParent = parent;

    mObjectQuats = mParent.mObjectQuats;

    mNumQuats = mObjectQuats.length;

    mOrigPos = orig;

    mNumCubits = orig.length;

    mFunctionIndex = index;

    mTmpQuats = new int[mNumQuats];

    if( mFunctionIndex==2 )

      {

      computeSurfaceTable();

      int numFaces = parent.getNumPuzzleFaces();

      mTmpFaceColorTable = new int[numFaces][2];

      }

    }

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

  void setupSolvedQuats(int[][] quats)

    {

    mSolvedQuats = quats;

    }

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

  void setPuzzleFaceColor(int[] color)

    {

    mPuzzleFaceColor = color;

    }

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

  boolean isSolved(TwistyObjectCubit[] cubits)

    {

    switch(mFunctionIndex)

      {

      case 0: return isSolved0(cubits);

      case 1: return isSolved1(cubits);

      case 2: return isSolved2(cubits);

      }

    return false;

    }

  }

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

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

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.type.Static4D;

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

// a Surface - i.e. a group of cubit faces which must be all of the same color if the puzzle is to

// be in a solved state. For example: the 3x3 cube has 6 such surfaces - defines by 6 planes, each

// defined by a quad of floats - a normal vector (nx.ny.nz) and the distance from the origin.

//

// So far simple - only capable of such planes, which means that the puzzles which contain curved

// monochromatic surfaces (Masterball, Penroses) cannot use this method..

//

// 'indices' is a map which shows which surface our surface changes to when rotated by all the

// 'numQuats' quats.

//

// Used only in TwistyObjectSolved's method2.

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

class TwistyObjectSurface

{

  private final float[] surface;

  private int[] indices;

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

  TwistyObjectSurface(float[] s)

    {

    surface = s;

    }

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

  void setIndices(int[] i)

    {

    indices = i;

    }

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

  int[] getIndices()

    {

    return indices;

    }

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

  String print()

    {

    return surface[0]+" "+surface[1]+" "+surface[2]+" "+surface[3];

    }

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

  boolean isSame(TwistyObjectSurface s)

    {

    final float MAX_ERROR = 0.01f;

    float dnx,dny,dnz,dnw;

    float[] sur = s.surface;

    dnx = sur[0] + surface[0];

    dny = sur[1] + surface[1];

    dnz = sur[2] + surface[2];

    dnw = sur[3] + surface[3];

    if( dnx*dnx + dny*dny + dnz*dnz + dnw*dnw < MAX_ERROR ) return true;

    dnx = sur[0] - surface[0];

    dny = sur[1] - surface[1];

    dnz = sur[2] - surface[2];

    dnw = sur[3] - surface[3];

    if( dnx*dnx + dny*dny + dnz*dnz + dnw*dnw < MAX_ERROR ) return true;

    return false;

    }

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

  TwistyObjectSurface rotateSurface(Static4D quat)

    {

    float[] ret = new float[4];

    QuatHelper.rotateVectorByQuat(ret,surface[0],surface[1],surface[2],0,quat);

    ret[3] = surface[3];

    return new TwistyObjectSurface(ret);

    }

}