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.objects;

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

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

import java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.ShapeHexahedron;

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

public class TwistySkewb extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(+SQ3/3,+SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,+SQ3/3,-SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)

         };

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private float[][] mCuts;

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

  public TwistySkewb(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(numL, meshState, 2*numL[0]-2, quat, move, scale, stream);

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      int numL = numLayers[0];

      int[] tmp = {0,-1,0, 0,1,0, numL-1,-1,0, numL-1,1,0 };

      mStates = new ScrambleState[]

        {

        new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} )

        };

      }

    return mStates;

    }

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

  private int getNumCorners()

    {

    return 8;

    }

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

  private int getNumEdges(int numLayers)

    {

    return (numLayers-2)*12;

    }

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

  private int getNumCentersPerFace(int numLayers)

    {

    return ((numLayers-2)*(numLayers-2) + (numLayers-1)*(numLayers-1));

    }

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

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

    {

    if( mCuts==null )

      {

      float[] c = numLayers[0]==2 ? (new float[] {0.0f}) : (new float[] {-SQ3/6,+SQ3/6});

      mCuts = new float[][] {c,c,c,c};

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = numLayers[0]==2 ? (new boolean[] {true,true}) : (new boolean[] {true,false,true});

    return new boolean[][] { tmp,tmp,tmp,tmp };

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_CORNER;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{0,1},{3,1},{2,3},{0,2}},

          {{2,3},{3,1},{0,1},{0,2}},

          {{1,2},{0,1},{0,3},{2,3}},

          {{1,2},{2,3},{0,3},{0,1}},

          {{0,3},{0,2},{1,2},{1,3}},

          {{1,2},{0,2},{0,3},{1,3}},

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    int numL = numLayers[0];

    final float DIST_CORNER = numL-1;

    final float DIST_EDGE   = numL-1;

    final float DIST_CENTER = numL-1;

    final int numCorners = getNumCorners();

    final int numEdges   = getNumEdges(numL);

    final int numCenters = 6*getNumCentersPerFace(numL);

    final float[][] CENTERS = new float[numCorners+numEdges+numCenters][];

    /// CORNERS //////////////////////////////////////////////

    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    CENTERS[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    /// CENTERS //////////////////////////////////////////////

    int index=8;

    final float X= -1000.0f;

    final float Y= -1001.0f;

    final float[][]  centerTable =

        {

            {+DIST_CENTER,X,Y},

            {-DIST_CENTER,X,Y},

            {X,+DIST_CENTER,Y},

            {X,-DIST_CENTER,Y},

            {X,Y,+DIST_CENTER},

            {X,Y,-DIST_CENTER}

        };

    float x,y, cen0, cen1, cen2;

    for( float[] centers : centerTable )

      {

      x = 2-numL;

      for(int i=0; i<numL-1; i++, x+=2)

        {

        y = 2-numL;

        for(int j=0; j<numL-1; j++, y+=2, index++)

          {

               if( centers[0]==Y ) cen0 = y;

          else if( centers[0]==X ) cen0 = x;

          else                     cen0 = centers[0];

               if( centers[1]==Y ) cen1 = y;

          else if( centers[1]==X ) cen1 = x;

          else                     cen1 = centers[1];

               if( centers[2]==Y ) cen2 = y;

          else if( centers[2]==X ) cen2 = x;

          else                     cen2 = centers[2];

          CENTERS[index] = new float[] {cen0,cen1,cen2};

          }

        }

      x = 3-numL;

      for(int i=0; i<numL-2; i++, x+=2)

        {

        y = 3-numL;

        for(int j=0; j<numL-2; j++, y+=2, index++)

          {

               if( centers[0]==Y ) cen0 = y;

          else if( centers[0]==X ) cen0 = x;

          else                     cen0 = centers[0];

               if( centers[1]==Y ) cen1 = y;

          else if( centers[1]==X ) cen1 = x;

          else                     cen1 = centers[1];

               if( centers[2]==Y ) cen2 = y;

          else if( centers[2]==X ) cen2 = x;

          else                     cen2 = centers[2];

          CENTERS[index] = new float[] {cen0,cen1,cen2};

          }

        }

      }

    /// EDGES ///////////////////////////////////////////////

    final float[][]  edgeTable =

        {

            {0,+DIST_EDGE,+DIST_EDGE},

            {+DIST_EDGE,0,+DIST_EDGE},

            {0,-DIST_EDGE,+DIST_EDGE},

            {-DIST_EDGE,0,+DIST_EDGE},

            {+DIST_EDGE,+DIST_EDGE,0},

            {+DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,+DIST_EDGE,0},

            {0,+DIST_EDGE,-DIST_EDGE},

            {+DIST_EDGE,0,-DIST_EDGE},

            {0,-DIST_EDGE,-DIST_EDGE},

            {-DIST_EDGE,0,-DIST_EDGE}

        };

    for (float[] edges : edgeTable)

      {

      float c = 3-numL;

      for (int j=0; j<numL-2; j++, c+=2, index++)

        {

        CENTERS[index] = new float[] { edges[0]==0 ? c : edges[0] ,

                                       edges[1]==0 ? c : edges[1] ,

                                       edges[2]==0 ? c : edges[2] };

        }

      }

    return CENTERS;

    }

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

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    int numL = numLayers[0];

    int numCorners = getNumCorners();

    int numCentersPerFace = getNumCentersPerFace(numL);

    int numCenters = 6*numCentersPerFace;

    if( cubit<numCorners )

      {

      switch(cubit)

        {

        case  0: return mObjectQuats[0];                   //  unit quat

        case  1: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X

        case  2: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X

        case  3: return mObjectQuats[9];                   // 180 along X

        case  4: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y

        case  5: return mObjectQuats[11];                  // 180 along Y

        case  6: return mObjectQuats[10];                   // 180 along Z

        case  7: return new Static4D(SQ2/2,0,-SQ2/2,0);    // 180 along (SQ2/2,0,-SQ2/2)

        }

      }

    else if( cubit<numCorners+numCenters )

      {

      int center = (cubit-numCorners)/numCentersPerFace;

      switch(center)

        {

        case 0: return new Static4D(0,-SQ2/2,0,SQ2/2);    // -90 along Y

        case 1: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y

        case 2: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X

        case 3: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X

        case 4: return mObjectQuats[0];                   //  unit quaternion

        case 5: return mObjectQuats[9];                   // 180 along X

        }

      }

    else

      {

      int edge = (cubit-numCorners-numCenters)/(numL-2);

      switch(edge)

        {

        case  0: return mObjectQuats[ 0];

        case  1: return mObjectQuats[ 2];

        case  2: return mObjectQuats[10];

        case  3: return mObjectQuats[ 8];

        case  4: return mObjectQuats[ 1];

        case  5: return mObjectQuats[ 4];

        case  6: return mObjectQuats[ 6];

        case  7: return mObjectQuats[ 7];

        case  8: return mObjectQuats[11];

        case  9: return mObjectQuats[ 5];

        case 10: return mObjectQuats[ 9];

        case 11: return mObjectQuats[ 3];

        }

      }

    return null;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      float[][] vertices= { {-1,0,0},{0,-1,0},{0,0,-1},{-1,-1,-1},{0,0,0} };

      int[][] indices   = { {0,1,4},{2,0,4},{1,2,4},{3,1,0},{3,2,1},{3,0,2} };

      return new ObjectShape(vertices, indices);

      }

    else if( variant==1 )

      {

      float[][] vertices= { {-1,0,0},{0,-1,0},{1,0,0},{0,1,0},{0,0,-1} };

      int[][] indices   = { {0,1,2,3},{4,1,0},{4,2,1},{4,3,2},{4,0,3} };

      return new ObjectShape(vertices, indices);

      }

    else

      {

      float[][] vertices= { {-1,0,0},{1,0,0},{0,-1,0},{0,0,-1} };

      int[][] indices   = { {2,1,0},{3,0,1},{2,3,1},{3,2,0} };

      return new ObjectShape(vertices, indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

    if( variant==0 )

      {

      int N = numL==2 ? 7:5;

      int E1= numL==2 ? 3:2;

      int E2= numL==2 ? 5:3;

      float[][] bands     = { {0.020f,35,0.16f,0.7f,N,E1,E1}, {0.000f, 0,1.00f,0.0f,3,1,E2} };

      int[] bandIndices   = { 0,0,0,1,1,1 };

      float[][] corners   = { {0.05f,0.25f}, {0.05f,0.20f} };

      int[] cornerIndices = { 1,1,1,0,0 };

      float[][] centers   = { {-0.5f, -0.5f, -0.5f} };

      int[] centerIndices = { 0,0,0,-1,0 };

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    else if( variant==1 )

      {

      int N = numL==2 ? 7:6;

      int E = numL==2 ? 3:1;

      float[][] bands     = { {0.04f,35,SQ2/8,0.9f,N,E,E}, {0.000f,0,1,0.0f,3,0,0} };

      int[] bandIndices   = { 0,1,1,1,1 };

      float[][] corners   = { {0.06f,0.15f} };

      int[] cornerIndices = { 0,0,0,0,0 };

      float[][] centers   = { {0,0,-0.4f} };

      int[] centerIndices = { 0,0,0,0,-1 };

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    else

      {

      int N = numL==2 ? 7:5;

      int E = numL==2 ? 5:2;

      float[][] bands     = { {0.035f,30,0.16f,0.8f,N,2,E}, {0.020f,45,0.16f,0.2f,3,1,2} };

      int[] bandIndices   = { 0,0,1,1 };

      float[][] corners   = { {0.07f,0.20f}, {0.02f,0.30f} };

      int[] cornerIndices = { 0,0,1,1 };

      float[][] centers   = { {0.0f, -0.5f, -0.5f} };

      int[] centerIndices = { 0,0,0,0 };

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return numLayers[0]==2 ? 2:3;

    }

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

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    return cubit<8 ? 0 : (cubit<8+6*getNumCentersPerFace(numLayers[0]) ? 1:2);

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( ObjectControl.isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      stroke *= (numLayers[0]==2 ? 2.0f : 2.7f);

      }

    return stroke;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngles()

    {

    if( mBasicAngle ==null ) mBasicAngle = new int[] { 3,3,3,3 };

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int[] numLayers)

    {

    switch(numLayers[0])

      {

      case 2: return ObjectType.SKEW_2;

      case 3: return ObjectType.SKEW_3;

      }

    return ObjectType.SKEW_2;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Skewb";

      case 3: return "Master Skewb";

      }

    return "Skewb";

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Tony Durham";

      case 3: return "Katsuhiko Okamoto";

      }

    return "Tony Durham";

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1982;

      case 3: return 2003;

      }

    return 1982;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1;

      case 3: return 3;

      }

    return 5;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                          {"gb","I6132yshkeU","How to Solve the Skewb","Z3"},

                          {"es","wxQX3HhPgds","Resolver Skewb (Principiantes)","Cuby"},

                          {"ru","EICw3aqn6Bc","Как собрать Скьюб?","Алексей Ярыгин"},

                          {"fr","lR-GuIroh4k","Comment réussir le skewb","Rachma Nikov"},

                          {"de","7RX6D5pznOk","Skewb lösen","Pezcraft"},

                          {"pl","ofRu1fByNpk","Jak ułożyć: Skewb","DżoDżo"},

                          {"br","mNycauwshWs","Como resolver o Skewb","Pedro Filho"},

                          {"kr","5R3sU-_bMAI","SKEWB 초보 공식","iamzoone"},

                     //   {"tw","8srf9xhsS9k","Skewb斜轉方塊解法","1hrBLD"},

                         };

      case 3: return new String[][] {

                          {"gb","Jiuf7zQyPYI","Master Skewb Cube Tutorial","Bearded Cubing"},

                          {"es","8TP6p63KQCA","Master Skewb en Español","jorlozCubes"},

                          {"ru","7155QSp3T74","часть 1: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","14ey-RihjgY","часть 2: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","watq6TLa5_E","часть 2.5: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","UnsvseFBXmo","часть 3: Как собрать мастер Скьюб","Иван Циков"},

                          {"fr","tYMoY4EOHVA","Résolution du Master Skewb","Asthalis"},

                          {"de","LSErzqGNElI","Master Skewb lösen","JamesKnopf"},

                          {"pl","Y7l3AYFvDJI","Master Skewb TUTORIAL PL","MrUk"},

                          {"kr","ycR-WmXJCG0","마스터 스큐브 3번째 해법","듀나메스 큐브 해법연구소"},

                         };

      }

    return null;

    }

}