TwistyPuzzleLib

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

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

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

public class TwistySquare1 extends TwistySquare

{

  private int[] mQuatNumber;

  private float[][] mCenters;

  private int[][] mStickerColor;

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

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

    {

    super(numL, meshState, quat, move, scale, stream);

    }

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

  public ScrambleState[] getScrambleStates()

    {

    return null;

    }

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

  public int getScrambleType()

    {

    return 1;

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(TouchControlHexahedron.FACE_AXIS[status],mQuats);

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      float[][] vertices =

        {

         { -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 }

        };

      int[][] indices =

        {

         {4,5,1,0},

         {5,6,2,1},

         {6,7,3,2},

         {7,4,0,3},

         {0,1,2,3},

         {4,5,6,7}

        };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 3);

      }

    else if( variant==1 )

      {

      float[][] vertices =

        {

         {  -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 },

        };

      int[][] indices =

        {

         {0,1,2},

         {3,4,1,0},

         {3,4,5},

         {4,5,2,1},

         {5,3,0,2}

        };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 2);

      }

    else

      {

      float[][] vertices =

        {

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

         {   0.0f, 0.5f,  0.0f },

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

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

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

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

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

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

        };

      int[][] indices =

        {

         {0,1,2,3},

         {4,5,1,0},

         {5,6,2,1},

         {7,4,0,3},

         {6,7,3,2},

         {4,5,6,7}

        };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 3);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float[][] bands     = { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} };

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

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

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

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

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

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

      }

    else if( variant==1 )

      {

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

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

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

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

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

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

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

      }

    else

      {

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

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

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

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

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

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

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

      }

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

    if( mQuatNumber ==null )

      {

      mQuatNumber = new int[]

        {

        0, 6,

        0, 9, 6, 3, 18, 15, 12, 21,

        0, 9, 6, 3, 15, 12, 21, 18

        };

      }

    return mQuats[mQuatNumber[cubit]];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

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

    }

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

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

    {

    if( mCenters==null )

      {

      mCenters = new float[][]

        {

         { 1.5f, 0.0f, 0.0f },

         {-1.5f, 0.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 },

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

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

         { 1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f },

         { 1.0f, 1.0f,-2.0f, 2.0f, 1.0f,-1.0f },

         {-1.0f, 1.0f,-2.0f,-2.0f, 1.0f,-1.0f },

         {-1.0f, 1.0f, 2.0f,-2.0f, 1.0f, 1.0f },

         { 1.0f,-1.0f, 2.0f, 2.0f,-1.0f, 1.0f },

         { 1.0f,-1.0f,-2.0f, 2.0f,-1.0f,-1.0f },

         {-1.0f,-1.0f,-2.0f,-2.0f,-1.0f,-1.0f },

         {-1.0f,-1.0f, 2.0f,-2.0f,-1.0f, 1.0f }

        };

      }

    return mCenters;

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  public int getCubitFaceColor(int cubit, int face, int[] numLayers)

    {

    if( mStickerColor==null )

      {

      // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5

      mStickerColor = new int[][]

        {

          { 4, 0, 5, 0, 0, 0 },

          { 5, 1, 4, 0, 0, 0 },

          { 2, 4, 0, 0, 0, 0 },

          { 2, 0, 0, 0, 0, 0 },

          { 2, 5, 0, 0, 0, 0 },

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

          { 3, 4, 0, 0, 0, 0 },

          { 3, 0, 0, 0, 0, 0 },

          { 3, 5, 0, 0, 0, 0 },

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

          { 2, 4, 0, 0, 0, 0 },

          { 2, 0, 5, 0, 0, 0 },

          { 2, 5, 1, 0, 0, 0 },

          { 2, 1, 4, 0, 0, 0 },

          { 3, 0, 4, 0, 0, 0 },

          { 3, 5, 0, 0, 0, 0 },

          { 3, 1, 5, 0, 0, 0 },

          { 3, 4, 1, 0, 0, 0 },

        };

      }

    return mStickerColor[cubit][face];

    }

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

  public float getStickerRadius()

    {

    return 0.12f;

    }

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

  public float getStickerStroke()

    {

    return ObjectControl.isInIconMode() ? 0.20f : 0.10f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public ObjectType intGetObjectType(int[] numLayers)

    {

    return ObjectType.SQU1_3;

    }

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

  public String getObjectName()

    {

    return "Square-1";

    }

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

  public String getInventor()

    {

    return "V. Kopsky, K. Hrsel";

    }

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

  public int getYearOfInvention()

    {

    return 1999;

    }

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

  public int getComplexity()

    {

    return 3;

    }

}