TwistyPuzzleLib

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.main;

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.FactorySticker;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.QuatGroupGenerator;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.scrambling.ObjectScrambler;

import org.distorted.objectlib.json.JsonReader;

import org.distorted.objectlib.touchcontrol.*;

import static org.distorted.objectlib.touchcontrol.TouchControl.*;

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

public abstract class TwistyObject

  {

  public static final int MESH_NICE = 0;

  public static final int MESH_FAST = 1;

  public static final int MODE_ICON = 0;

  public static final int MODE_NORM = 1;

  public static final int COLOR_YELLOW   = 0xffffff00;

  public static final int COLOR_WHITE    = 0xffffffff;

  public static final int COLOR_BLUE     = 0xff0000ff;

  public static final int COLOR_GREEN    = 0xff00bb00;

  public static final int COLOR_RED      = 0xff990000;

  public static final int COLOR_ORANGE   = 0xffff6200;

  public static final int COLOR_GREY     = 0xff727c7b;

  public static final int COLOR_VIOLET   = 0xff7700bb;

  public static final int COLOR_STROKE   = 0xff000000;

  private static final int COLOR_INTERNAL= 0xff000000;

  public static final int TEXTURE_HEIGHT = 256;

  static final int NUM_STICKERS_IN_ROW = 4;

  public static final float SQ2 = (float)Math.sqrt(2);

  public static final float SQ3 = (float)Math.sqrt(3);

  public static final float SQ5 = (float)Math.sqrt(5);

  public static final float SQ6 = (float)Math.sqrt(6);

  private static final float MAX_SIZE_CHANGE = 1.35f;

  private static final float MIN_SIZE_CHANGE = 0.75f;

  private static final Static3D CENTER = new Static3D(0,0,0);

  private static final int POST_ROTATION_MILLISEC = 500;

  protected float[][] mStickerCoords;

  protected Static4D[] mObjectQuats;

  int mNumAxis, mMaxNumLayers;

  private int[][] mStickerVariants;

  private float[] mStickerScales;

  private Cubit[] mCubits;

  private MeshBase[] mMeshes;

  private int mNumCubits, mNumQuats, mNumFaceColors, mNumTextures;

  private int mNumCubitFaces, mNumStickerTypes;

  private Static3D[] mAxis;

  private float[][] mCuts;

  private int[] mNumCuts;

  private float[][] mOrigPos;

  private Static4D[] mOrigQuat;

  private Static4D mQuat;

  private final int[] mNumLayers;

  private final float mSize;

  private DistortedEffects mEffects;

  private VertexEffectRotate mRotateEffect;

  private Dynamic1D mRotationAngle;

  private Static3D mRotationAxis;

  private Static3D mObjectScale;

  private int[] mQuatDebug;

  private Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  private DistortedTexture mTexture;

  private float mInitScreenRatio;

  private int mSolvedFunctionIndex;

  private boolean mIsBandaged;

  private float mObjectScreenRatio;

  private int[][] mSolvedQuats;

  private int[][] mQuatMult;

  private int[] mTmpQuats;

  private int mNumTexRows, mNumTexCols;

  private int mRotRowBitmap;

  private int mCurrentRotAxis;

  private MeshBase mMesh;

  private ObjectScrambler mScrambler;

  private TouchControl mTouchControl;

  private DistortedNode mNode;

  private ObjectLibInterface mInterface;

  private Bitmap mBitmap;

  private ObjectSticker[] mStickers;

  private ObjectShape[] mShapes;

  private int mNumCubitVariants;

  private int[][] mCubitFaceColors;

  private int[][] mVariantFaceIsOuter;

  private int[] mBasicAngles;

  private int mIconMode;

  //////////////////// SOLVED1 ////////////////////////

  private int[] mFaceMap;

  private int[][] mScramble;

  private int[] mColors;

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

  TwistyObject(InputStream jsonStream, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream meshStream)

    {

    JsonReader reader = JsonReader.getInstance();

    reader.parseJsonFile(jsonStream);

    setReader(reader);

    mNumLayers = reader.getNumLayers();

    mSize      = reader.getSize();

    initialize(meshState,iconMode,quat,move,scale,meshStream,true);

    }

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

  TwistyObject(int[] numLayers, int meshState, int iconMode, float size, Static4D quat, Static3D move, float scale, InputStream meshStream)

    {

    mNumLayers = numLayers;

    mSize      = size;

    initialize(meshState,iconMode,quat,move,scale,meshStream,false);

    }

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

  private void initialize(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream, boolean fromJSON)

    {

    mIconMode = iconMode;

    mQuat = quat;

    mAxis = getRotationAxis();

    mInitScreenRatio = getScreenRatio();

    mSolvedFunctionIndex = getSolvedFunctionIndex();

    mBasicAngles = getBasicAngles();

    mObjectQuats = getQuats();

    mNumQuats = mObjectQuats.length;

    mOrigPos = getCubitPositions(mNumLayers);

    int numAxis = mAxis.length;

    mMaxNumLayers = -1;

    mCuts = getCuts(mNumLayers);

    mNumCuts = new int[numAxis];

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

      {

      if( mMaxNumLayers<mNumLayers[i] ) mMaxNumLayers = mNumLayers[i];

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

      }

    mNumCubits = mOrigPos.length;

    mNumFaceColors = getNumFaceColors();

    mNumAxis = mAxis.length;

    int scramblingType = getScrambleType();

    ScrambleState[] states = getScrambleStates();

    mScrambler = new ObjectScrambler(scramblingType, mNumAxis,mNumLayers,states);

    boolean bandaged=false;

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

      {

      if( mOrigPos[c].length>3 )

        {

        bandaged=true;

        break;

        }

      }

    mIsBandaged = bandaged;

    mQuatDebug = new int[mNumCubits];

    mRotationAngle= new Dynamic1D();

    mRotationAxis = new Static3D(1,0,0);

    mRotateEffect = new VertexEffectRotate(mRotationAngle, mRotationAxis, CENTER);

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    mObjectScale = new Static3D(scale,scale,scale);

    setObjectRatioNow(scale,720);

    MatrixEffectScale scaleEffect = new MatrixEffectScale(mObjectScale);

    MatrixEffectQuaternion quatEffect = new MatrixEffectQuaternion(mQuat, CENTER);

    MatrixEffectMove moveEffect = new MatrixEffectMove(move);

    boolean fromDMESH = (stream!=null && meshState==MESH_NICE);

    getQuatsAndShapes(fromDMESH,fromJSON);

    createMeshAndCubits(stream,meshState,fromDMESH);

    setUpTextures(fromDMESH,fromJSON);

    createDataStructuresForSolved();

    mEffects = new DistortedEffects();

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

      {

      VertexEffectQuaternion vq = new VertexEffectQuaternion(mObjectQuats[q],CENTER);

      vq.setMeshAssociation(0,q);

      mEffects.apply(vq);

      }

    mEffects.apply(mRotateEffect);

    mEffects.apply(quatEffect);

    mEffects.apply(scaleEffect);

    mEffects.apply(moveEffect);

    mNode = new DistortedNode(mTexture,mEffects,mMesh);

    }

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

  private Static3D getPos(float[] origPos)

    {

    int len = origPos.length/3;

    float sumX = 0.0f;

    float sumY = 0.0f;

    float sumZ = 0.0f;

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

      {

      sumX += origPos[3*i  ];

      sumY += origPos[3*i+1];

      sumZ += origPos[3*i+2];

      }

    sumX /= len;

    sumY /= len;

    sumZ /= len;

    return new Static3D(sumX,sumY,sumZ);

    }

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

  private void createOuterFaces()

    {

    for(int v=0; v<mNumCubitVariants; v++)

      {

      int[][] indices = mShapes[v].getVertIndices();

      int faces = indices.length;

      mVariantFaceIsOuter[v] = new int[faces];

      }

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

      {

      int variant = getCubitVariant(cubit,mNumLayers);

      int[][] indices = mShapes[variant].getVertIndices();

      int numFaces = indices.length;

      for(int face=0; face<numFaces; face++)

        if( getCubitFaceColor(cubit,face)>=0 )

          {

          mVariantFaceIsOuter[variant][face] = 1;

          }

      }

    }

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

  private void getQuatsAndShapes(boolean fromDMESH, boolean fromJSON)

    {

    mNumCubitVariants = getNumCubitVariants(mNumLayers);

    if( !fromDMESH || !fromJSON )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mOrigQuat = new Static4D[mNumCubits];

      for(int i=0; i<mNumCubits; i++) mOrigQuat[i] = getCubitQuats(i,mNumLayers);

      mShapes = new ObjectShape[mNumCubitVariants];

      for(int i=0; i<mNumCubitVariants; i++) mShapes[i] = getObjectShape(i);

      mNumCubitFaces = ObjectShape.computeNumComponents(mShapes);

      mVariantFaceIsOuter = new int[mNumCubitVariants][];

      if( !fromJSON )

        {

        mCubitFaceColors = ObjectShape.computeColors(mShapes,mOrigPos,mOrigQuat,this);

        createOuterFaces();

        }

      if( fromDMESH )

        {

        for(int i=0; i<mNumCubitVariants; i++) factory.createNewFaceTransform(mShapes[i], mVariantFaceIsOuter[i]);

        }

      }

    }

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

  private void createMeshAndCubits(InputStream stream, int meshState, boolean fromDMESH)

    {

    mCubits = new Cubit[mNumCubits];

    if( fromDMESH )

      {

      DataInputStream dos = new DataInputStream(stream);

      mMesh = new MeshFile(dos);

      try

        {

        stream.close();

        }

      catch(IOException e)

        {

        android.util.Log.e("meshFile", "Error closing InputStream: "+e.toString());

        }

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

        {

        mCubits[i] = new Cubit(this,mOrigPos[i], mNumAxis);

        mMesh.setEffectAssociation(i, mCubits[i].computeAssociation(), 0);

        }

      }

    else

      {

      MeshBase[] cubitMesh = new MeshBase[mNumCubits];

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

        {

        mCubits[i] = new Cubit(this,mOrigPos[i], mNumAxis);

        cubitMesh[i] = createCubitMesh(i,mNumLayers,meshState,mNumCubitFaces);

        Static3D pos = getPos(mOrigPos[i]);

        cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);

        cubitMesh[i].setEffectAssociation(0, mCubits[i].computeAssociation(), 0);

        }

      mMesh = new MeshJoined(cubitMesh);

      }

    }

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

  private MeshBase createCubitMesh(int cubit, int[] numLayers, int meshState, int numComponents)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( mMeshes==null ) mMeshes = new MeshBase[mNumCubitVariants];

    if( mMeshes[variant]==null )

      {

      ObjectFaceShape faceShape = getObjectFaceShape(variant);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(mShapes[variant],mVariantFaceIsOuter[variant]);

      mMeshes[variant] = factory.createRoundedSolid(mShapes[variant],faceShape,meshState, numComponents);

      }

    MeshBase mesh = mMeshes[variant].copy(true);

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( mOrigQuat[cubit], CENTER );

    mesh.apply(quat,0xffffffff,0);

    return mesh;

    }

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

  private void setUpTextures(boolean fromDMESH, boolean fromJSON)

    {

    mTexture = new DistortedTexture();

    if( fromJSON )

      {

      mNumStickerTypes = getNumStickerTypes();

      mNumCubitFaces = getNumCubitFaces();

      }

    else

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      mStickerCoords   = factory.getStickerCoords();

      mStickerVariants = factory.getStickerVariants();

      mStickerScales   = factory.getStickerScales();

      adjustStickerCoords();

      mNumStickerTypes = (mStickerCoords==null ? 0 : mStickerCoords.length);

      }

    mNumTextures= mNumFaceColors *mNumStickerTypes;

    mNumTexCols = NUM_STICKERS_IN_ROW;

    mNumTexRows = (mNumTextures+1)/NUM_STICKERS_IN_ROW;

    if( mNumTexCols*mNumTexRows < mNumTextures+1 ) mNumTexRows++;

    if( !fromDMESH || shouldResetTextureMaps() ) resetAllTextureMaps();

    setTexture();

    }

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

  private int getMultQuat(int index1, int index2)

    {

    if( mQuatMult==null )

      {

      mQuatMult = new int[mNumQuats][mNumQuats];

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

        for(int j=0; j<mNumQuats; j++) mQuatMult[i][j] = -1;

      }

    if( mQuatMult[index1][index2]==-1 )

      {

      mQuatMult[index1][index2] = mulQuat(index1,index2);

      }

    return mQuatMult[index1][index2];

    }

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

  public boolean isInIconMode()

    {

    return mIconMode==MODE_ICON;

    }

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

  public int getVariantFaceColor(int variant, int face)

    {

    return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face];

    }

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

  public boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  private void createDataStructuresForSolved()

    {

    mTmpQuats = new int[mNumQuats];

    mSolvedQuats = getSolvedQuats();

    }

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

// This is used to build internal data structures for the generic 'isSolved()'

//

// if this is an internal cubit (all faces black): return -1

// if this is a face cubit (one non-black face): return the color index of the only non-black face.

// Color index, i.e. the index into the 'FACE_COLORS' table.

// else (edge or corner cubit, more than one non-black face): return -2.

  protected int retCubitSolvedStatus(int cubit)

    {

    int numNonBlack=0, nonBlackIndex=-1, varColor, cubColor;

    int variant = getCubitVariant(cubit,mNumLayers);

    for(int face=0; face<mNumCubitFaces; face++)

      {

      varColor = getVariantFaceColor(variant,face);

      int numFaces = mCubitFaceColors[cubit].length;

      cubColor = face<numFaces ? mCubitFaceColors[cubit][face] : -1;

      if( varColor>=0 && cubColor>=0 )

        {

        numNonBlack++;

        nonBlackIndex = cubColor;

        }

      }

    if( numNonBlack==0 ) return -1;

    if( numNonBlack>=2 ) return -2;

    return nonBlackIndex;

    }

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

  protected void displayCubitQuats()

    {

    StringBuilder builder = new StringBuilder();

    float[] tmp = new float[4];

    float MAXERR = 0.01f;

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

      {

      int refCubit,variant = getCubitVariant(cubit,mNumLayers);

      for(refCubit=0; refCubit<mNumCubits; refCubit++)

        {

        if( getCubitVariant(refCubit,mNumLayers)==variant ) break;

        }

      float[] curpos = mOrigPos[cubit];

      float[] refpos = mOrigPos[refCubit];

      float refX = refpos[0];

      float refY = refpos[1];

      float refZ = refpos[2];

      float curX = curpos[0];

      float curY = curpos[1];

      float curZ = curpos[2];

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

        {

        QuatHelper.rotateVectorByQuat(tmp,refX,refY,refZ,0,mObjectQuats[quat]);

        float dx = tmp[0]-curX;

        float dy = tmp[1]-curY;

        float dz = tmp[2]-curZ;

        if( dx>-MAXERR && dx<MAXERR && dy>-MAXERR && dy<MAXERR && dz>-MAXERR && dz<MAXERR )

          {

          builder.append(quat);

          builder.append(',');

          }

        }

      builder.append('\n');

      }

    android.util.Log.e("D", "cubitQuats: \n"+builder.toString() );

    }

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

  protected int[] buildSolvedQuats(Static3D faceAx)

    {

    final float MAXD = 0.0001f;

    float x = faceAx.get0();

    float y = faceAx.get1();

    float z = faceAx.get2();

    float a,dx,dy,dz,qx,qy,qz;

    Static4D quat;

    int place = 0;

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

      {

      quat = mObjectQuats[q];

      qx = quat.get0();

      qy = quat.get1();

      qz = quat.get2();

           if( x!=0.0f ) { a = qx/x; }

      else if( y!=0.0f ) { a = qy/y; }

      else               { a = qz/z; }

      dx = a*x-qx;

      dy = a*y-qy;

      dz = a*z-qz;

      if( dx>-MAXD && dx<MAXD && dy>-MAXD && dy<MAXD && dz>-MAXD && dz<MAXD )

        {

        mTmpQuats[place++] = q;

        }

      }

    if( place!=0 )

      {

      int[] ret = new int[place];

      System.arraycopy(mTmpQuats,0,ret,0,place);

      return ret;

      }

    return null;

    }

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

  public int[][] getSolvedQuats()

    {

    int[] groups = new int[mNumCubits];

    int numGroups = 1;

    int numFirst  = 0;

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

      {

      groups[cubit] = retCubitSolvedStatus(cubit);

      if( groups[cubit]>=0 ) numGroups++;

      else                   numFirst++;

      }

    int firstIndex = 1;

    int groupIndex = 1;

    int[][] solvedQuats = new int[numGroups][];

    solvedQuats[0] = new int[1+numFirst];

    solvedQuats[0][0] = numFirst;

    Static3D[] axis = getFaceAxis();

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

      {

      int group = groups[cubit];

      if( group<0 )

        {

        solvedQuats[0][firstIndex] = cubit;

        firstIndex++;

        }

      else

        {

        int[] quats = buildSolvedQuats(axis[group]);

        int len = quats==null ? 0 : quats.length;

        solvedQuats[groupIndex] = new int[2+len];

        solvedQuats[groupIndex][0] = 1;

        solvedQuats[groupIndex][1] = cubit;

        for(int i=0; i<len; i++) solvedQuats[groupIndex][i+2] = quats[i];

        groupIndex++;

        }

      }

/*

    String dbg = "SOLVED GROUPS:\n";

    for(int g=0; g<numGroups; g++)

      {

      int len = solvedQuats[g].length;

      for(int i=0; i<len; i++) dbg += (" "+solvedQuats[g][i]);

      dbg+="\n";

      }

    android.util.Log.e("D", dbg);

*/

    return solvedQuats;

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

// special SolvedQuats for the case where there are no corner of edge cubits.

// first row {0} - means there are no corners or edges.

// each next defines all cubits of a singe face (numCubits, firstCubit, cubit1,..,cubitN-1, quat0,..., quatM

  private boolean isSolvedCentersOnly()

    {

    int numGroups = mSolvedQuats.length;

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

      {

      int numEntries= mSolvedQuats[group].length;

      int numCubits = mSolvedQuats[group][0];

      int firstCubit= mSolvedQuats[group][1];

      int firstQuat = mCubits[firstCubit].mQuatIndex;

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

        {

        int currCubit= mSolvedQuats[group][cubit];

        int currQuat = mCubits[currCubit].mQuatIndex;

        boolean isGood= (firstQuat==currQuat);

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

          {

          int quat = mSolvedQuats[group][q];

          if( firstQuat == getMultQuat(currQuat,quat) ) isGood = true;

          }

        if( !isGood ) return false;

        }

      }

    return true;

    }

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

  private boolean isSolved0()

    {

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

    for( int[] solvedQuat : mSolvedQuats )

      {

      int numCubits = solvedQuat[0];

      int firstCubit= solvedQuat[1];

      int quat = mCubits[firstCubit].mQuatIndex;

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

        {

        int c = solvedQuat[cubit];

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

        }

      }

    int cubit= mSolvedQuats[0][1];

    int quat0= mCubits[cubit].mQuatIndex;

    int numGroups = mSolvedQuats.length;

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

      {

      int firstCubit= mSolvedQuats[group][1];

      int currQuat  = mCubits[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( quat0 == getMultQuat(currQuat,quat) )

          {

          isGood = true;

          break;

          }

        }

      if( !isGood ) return false;

      }

    return true;

    }

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

  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;

      }

    return -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 boolean isSolved1()

    {

    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[mCubits[c].mQuatIndex][c];

      mColors[index] = mFaceMap[c];

      }