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.metadata.Metadata;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public abstract class TwistyBandagedAbstract extends ShapeHexahedron

{

  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(int iconMode, float size, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    super(iconMode, size, quat, move, scale, meta, asset);

    }

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

  boolean isAShapeshifter(int[] numLayers)

    {

    int x = numLayers[0];

    int y = numLayers[1];

    int z = numLayers[2];

    return ( (((x-y)%2)==0 && x!=y) || (((x-z)%2)==0 && x!=z) || (((y-z)%2)==0 && y!=z) );

    }

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

  @Override

  public int getInternalColor()

    {

    int[] numL = getNumLayers();

    return isAShapeshifter(numL) ? 0xff333333 : 0xff000000;

    }

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

// 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 = getMetadata().getPos();

    return mPosition;

    }

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

  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;

      }

    if( isAShapeshifter(numLayers) && (numLayers[0]==1 || numLayers[1]==1 || numLayers[2]==1) )

      {

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

        {

        if( (numLayers[i]%2)==1 )

          {

          int mid = (numLayers[i]-1)/2;

          layerRotatable[i][mid] = false;

          }

        }

      }

    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;

    }

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

// switch off shape-shifting cuboids here - problems with scrambling.

  private int basicAngle(int d1, int d2)

    {

    return d1==d2 ? 4 : 2;

    }

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

  public int[][] getBasicAngles()

    {

     if( mBasicAngle==null )

      {

      int[] num = getNumLayers();

      int numX = num[0];

      int numY = num[1];

      int numZ = num[2];

      int x = basicAngle(numY,numZ);

      int y = basicAngle(numX,numZ);

      int z = basicAngle(numX,numY);

      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;

    }

}