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 java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

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

public class TwistySquare2 extends TwistySquare

{

  private int[][] mEdges;

  private int[] mQuatIndex;

  private float[][] mCenters;

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

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

    {

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

    }

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

  @Override

  public int[][] getSolvedQuats()

    {

    return new int[][]

      {

        { 2, 0,1 },                                   // 2 middle cubits in the first group

        {12, 2,4,6,8,10,12,14,16,19,21,23,25,  17 },  // 12 front and back edges and corners in the second group with quat[17]

        {12, 3,5,7,9,11,13,15,17,18,20,22,24,  23 }   // 12 left and right edges and corners in the third group with quat[23]

      };

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

        {

          { 0,2,1,2,2,2,3,2,4,2,5,2,6,2,7,2,8,2,9,2,10,2,

            33,1,34,1,33,1,34,1,33,1,34,1,33,1,34,1,33,1,34,1,33,1,34,1,

            35,3,36,3,37,3,38,3,39,3,40,3,41,3,42,3,43,3,44,3,45,3 },     // 0

          { 0,2,1,2,2,2,3,2,4,2,5,2,6,2,7,2,8,2,9,2,10,2,

            35,3,36,3,37,3,38,3,39,3,40,3,41,3,42,3,43,3,44,3,45,3 },     // 1 SL

          { 33,1,34,1,

            35,4,36,4,37,4,38,4,39,4,40,4,41,4,42,4,43,4,44,4,45,4 },     // 2 LO

          { 0,4,1,4,2,4,3,4,4,4,5,4,6,4,7,4,8,4,9,4,10,4,

            33,1,34,1 },                                                  // 3 UP

          { 33,1,34,1 }                                                   // 4 UL

        };

      }

    return mEdges;

    }

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

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

    {

    if( mCenters ==null )

      {

      float Y = 0.75f + X/2;

      mCenters = new float[][]

        {

         { 1.5f, 0.0f, 0.0f }, // 0

         {-1.5f, 0.0f, 0.0f },

         { 0.0f, 1.0f, 1.5f }, // 2

         { 1.5f, 1.0f, 0.0f },

         { 0.0f, 1.0f,-1.5f },

         {-1.5f, 1.0f, 0.0f },

         { 0.0f,-1.0f, 1.5f },

         { 1.5f,-1.0f, 0.0f },

         { 0.0f,-1.0f,-1.5f },

         {-1.5f,-1.0f, 0.0f },

         {    Y, 1.0f, 1.5f }, // 10

         { 1.5f, 1.0f,   -Y },

         {   -Y, 1.0f,-1.5f },

         {-1.5f, 1.0f,    Y },

         {    Y,-1.0f, 1.5f },

         { 1.5f,-1.0f,   -Y },

         {   -Y,-1.0f,-1.5f },

         {-1.5f,-1.0f,    Y },

         { 1.5f, 1.0f,    Y }, // 18

         {    Y, 1.0f,-1.5f },

         {-1.5f, 1.0f,   -Y },

         {   -Y, 1.0f, 1.5f },

         { 1.5f,-1.0f,    Y },

         {    Y,-1.0f,-1.5f },

         {-1.5f,-1.0f,   -Y },

         {   -Y,-1.0f, 1.5f },

        };

      }

    return mCenters;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[]

        {

        0, 6,

        0, 9, 6, 3,17,14,23,20,

        0, 9, 6, 3, 0, 9, 6, 3,14, 23, 20, 17, 14, 23, 20, 17

        };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][]

        {

         { -1.5f-X, 0.5f, 1.5f },

         {    0.0f, 0.5f, 1.5f },

         {    0.0f, 0.5f,-1.5f },

         { -1.5f+X, 0.5f,-1.5f },

         { -1.5f-X,-0.5f, 1.5f },

         {    0.0f,-0.5f, 1.5f },

         {    0.0f,-0.5f,-1.5f },

         { -1.5f+X,-0.5f,-1.5f }

        };

      }

    else if( variant==1 )

      {

      return new float[][]

        {

         {  -X, 0.5f, 0.0f },

         {  +X, 0.5f, 0.0f },

         {0.0f, 0.5f,-1.5f },

         {  -X,-0.5f, 0.0f },

         {  +X,-0.5f, 0.0f },

         {0.0f,-0.5f,-1.5f },

        };

      }

    else

      {

      return new float[][]

        {

         {-0.75f+X/2, 0.5f,  0.0f },

         { 0.75f-X/2, 0.5f,  0.0f },

         {-0.75f-X/2, 0.5f, -1.5f },

         {-0.75f+X/2,-0.5f,  0.0f },

         { 0.75f-X/2,-0.5f,  0.0f },

         {-0.75f-X/2,-0.5f, -1.5f }

        };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

        {

         {4,5,1,0},

         {5,6,2,1},

         {6,7,3,2},

         {7,4,0,3},

         {0,1,2,3},

         {7,6,5,4}

        };

      return new ObjectShape(getVertices(variant), indices);

      }

    else if( variant==1 )

      {

      int[][] indices =

        {

         {0,1,2},

         {3,4,1,0},

         {5,4,3},

         {4,5,2,1},

         {5,3,0,2}

        };

      return new ObjectShape(getVertices(variant), indices);

      }

    else

      {

      int[][] indices =

        {

         {0,1,2},

         {3,4,1,0},

         {5,4,3},

         {4,5,2,1},

         {5,3,0,2}

        };

      return new ObjectShape(getVertices(variant), indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float h1 = isInIconMode() ? 0.001f : 0.04f;

      float h2 = isInIconMode() ? 0.001f : 0.02f;

      float[][] bands = { {h1,35,0.2f,0.8f,5,2,1}, {h2,35,0.5f,1.0f,5,2,1}, {0.001f,35,0.3f,0.8f,5,2,1} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==1 )

      {

      float h1 = isInIconMode() ? 0.001f : 0.038f;

      float[][] bands = { {h1,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float h1 = isInIconMode() ? 0.001f : 0.03f;

      float[][] bands = { {h1,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners = { {0.03f,0.05f} };

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

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

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    else if( variant==1 )

      {

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

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

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

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    else

      {

      float[][] corners = { {0.05f,0.13f} };

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

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

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

    return cubit<2 ? 0 : (cubit<10 ? 1:2);

    }

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

  public float getStickerRadius()

    {

    return 0.12f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 0.10f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public String getShortName()

    {

    return ObjectType.SQU2_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectSignatures.SQU2_3);

    }

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

  public String getObjectName()

    {

    return "Square-2";

    }

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

  public String getInventor()

    {

    return "David Litwin";

    }

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

  public int getYearOfInvention()

    {

    return 1995;

    }

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

  public int getComplexity()

    {

    return 3;

    }

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

  public String[][] getTutorials()

    {

    return new String[][] {

                          {"gb","PPXojiFthEs","Square-2 Tutorial","SuperAntoniovivaldi"},

                          {"es","IiMwc51xKBQ","Cómo resolver Square-2","skieur cubb"},

                          {"ru","XZ6m8uF5oUk","Как собрать Square-2.","Илья Топор-Гилка"},

                          {"fr","R-m9IgYAFPA","Tutoriel: résolution du Square-2","skieur cubb"},

                          {"pl","SukHyoMzcgM","Square-2 TUTORIAL PL","MrUk"},

                          {"br","T3ts5gHLJV8","Tutorial do Square-2 1/2","Rafael Cinoto"},

                          {"br","4wwWE5Ni0Fw","Tutorial do Square-2 2/2","Rafael Cinoto"},

                          {"kr","psG9Ar4pBrc","초보자를 위한 스퀘어2 해법","SlowCuberToumai"},

                          {"vn","_37Pc8Y_-Hs","Square-2 Tutorial","VĂN CÔNG TÙNG"},

                         };

    }

}