TwistyPuzzleLib

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

// Copyright 2021 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.objects;

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

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import java.io.InputStream;

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

public abstract class TwistyBandagedAbstract extends ShapeHexahedron

{

  // the three rotation axis of a 3x3 Cube. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private int[][] mSolvedQuatsAbstract;

  protected ObjectShape[] mTmpShapes;

  protected int mNumVariants;

  protected float[][] mPosition;

  protected ObjectSignature mSignature;

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

  public TwistyBandagedAbstract(InitData data, int meshState, int iconMode, float size, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, size, quat, move, scale, stream);

    }

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

// return 0 if cubit is 'external' (it has at least two walls which belong to two different faces

// of the cuboid, faces which do not both rotate along the same axis! So: it is an edge, a corner,

// or a bandaged cubit which 'comes out' in two different, non-opposite, faces.

// Otherwise, if the cubit only comes out in one face or in two faces which are opposite to each other,

// return the index of the first of the three quats which rotate stuff in this face (so right or left

// return 1 because quats 1,2,3 are the ones rotating along the X axis)

  private int cubitIsExternal(float[] pos, float dx, float dy, float dz)

    {

    int len = pos.length/3;

    int x=0, y=0, z=0;

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

      {

      float cx = pos[3*i  ];

      float cy = pos[3*i+1];

      float cz = pos[3*i+2];

      if( cx>dx || cx<-dx ) x=1;

      if( cy>dy || cy<-dy ) y=1;

      if( cz>dz || cz<-dz ) z=1;

      }

    if( x+y+z>=2 ) return 0;

    if( x==1 ) return 1;

    if( y==1 ) return 4;

    if( z==1 ) return 7;

    android.util.Log.e("D", "ERROR: unsupported: internal cubit! ");

    return 0;

    }

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

  float[][] getPositions()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    return mPosition;

    }

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

// If we have a flat cuboid than retCubitSolvedStatus() wrongly reports that the internal cubits

// are edges (they do have two non-black faces after all!) which leads to wrong solvedQuats and

// mis-detection of a solved status. Correct this manually here.

//

// Note that this is still not completely good in case of bandaged cuboids - there can be a 4x4x2

// bandaged cuboid whose 4 'internal' cubits from the 4x4 face are fused with the other 4 internal

// cubits from the other 4x4 face - and those would again get mis-detected as edges...

  @Override

  public int[][] getSolvedQuats()

    {

    if( mSolvedQuatsAbstract==null )

      {

      int[] numLayers = getNumLayers();

      float dx = 0.5f*(numLayers[0]-1) - 0.1f;

      float dy = 0.5f*(numLayers[1]-1) - 0.1f;

      float dz = 0.5f*(numLayers[2]-1) - 0.1f;

      float[][] pos = getPositions();

      int numTotal = pos.length;

      boolean[] isExternal = new boolean[numTotal];

      int[] internalQuat = new int[numTotal];

      int numExternal = 0;

      int pointer = 0;

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

        {

        int q = cubitIsExternal(pos[cubit],dx,dy,dz);

        if( q<=0 )

          {

          isExternal[cubit] = true;

          numExternal++;

          }

        else

          {

          isExternal[cubit] = false;

          internalQuat[pointer] = q;

          pointer++;

          }

        }

      int numInternal = numTotal - numExternal;

      mSolvedQuatsAbstract = new int[numInternal+1][];

      mSolvedQuatsAbstract[0] = new int[numExternal+1];

      mSolvedQuatsAbstract[0][0] = numExternal;

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

        {

        int q = internalQuat[i];

        mSolvedQuatsAbstract[i+1] = new int[5];

        mSolvedQuatsAbstract[i+1][0] = 1;

        mSolvedQuatsAbstract[i+1][2] = q;

        mSolvedQuatsAbstract[i+1][3] = q+1;

        mSolvedQuatsAbstract[i+1][4] = q+2;

        }

      int pointerExternal = 1;

      int pointerInternal = 1;

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

        {

        if( isExternal[cubit] ) mSolvedQuatsAbstract[0][pointerExternal++] = cubit;

        else                    mSolvedQuatsAbstract[pointerInternal++][1] = cubit;

        }

      }

    return mSolvedQuatsAbstract;

    }

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

// Computing scramble states of many a bandaged cubes takes way too long time and too much space.

// Return null here and turn to construction of scramble tables just-in-time.

  public int[][] getScrambleEdges()

    {

    return null;

    }

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

  @Override

  public int getScrambleType()

    {

    return 2;

    }

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

  public float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      mCuts = new float[3][];

      for(int axis=0; axis<3; axis++)

        {

        int len = numLayers[axis];

        float start = (2-len)*0.5f;

        if( len>=2 )

          {

          mCuts[axis] = new float[len-1];

          for(int i=0; i<len-1; i++) mCuts[axis][i] = start+i;

          }

        }

      }

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

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

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}} };

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

  public float[][] getCubitPositions(int[] numLayers)

    {

    return getPositions();

    }

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

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

     if( mBasicAngle==null )

      {

      int[] num = getNumLayers();

      int numX = num[0];

      int numY = num[1];

      int numZ = num[2];

      int x = numY==numZ ? 4 : 2;

      int y = numX==numZ ? 4 : 2;

      int z = numX==numY ? 4 : 2;

      int[] tmpX = new int[numX];

      for(int i=0; i<numX; i++) tmpX[i] = x;

      int[] tmpY = new int[numY];

      for(int i=0; i<numY; i++) tmpY[i] = y;

      int[] tmpZ = new int[numZ];

      for(int i=0; i<numZ; i++) tmpZ[i] = z;

      mBasicAngle = new int[][] { tmpX,tmpY,tmpZ };

      }

    return mBasicAngle;

    }

}