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

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ShapeHexahedron;

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

abstract class TwistyDino extends ShapeHexahedron

{

  // the four rotation axis of a RubikDino. Must be normalized.

  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 int[] mBasicAngle;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private ObjectSticker[] mStickers;

  private float[][] mCenters;

  ScrambleState[] mStates;

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

  TwistyDino(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(numL, numL[0], quat, move, scale, stream);

    }

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

  private void initializeQuats()

    {

    mQuats = new Static4D[]

         {

         new Static4D(  0.0f,  0.0f,  0.0f,  1.0f ),

         new Static4D(  0.5f,  0.5f,  0.5f, -0.5f ),

         new Static4D(  0.0f,  0.0f,  1.0f,  0.0f ),

         new Static4D(  0.5f, -0.5f, -0.5f, -0.5f ),

         new Static4D(  0.5f,  0.5f,  0.5f,  0.5f ),

         new Static4D(  0.5f,  0.5f, -0.5f, -0.5f ),

         new Static4D(  0.5f, -0.5f,  0.5f, -0.5f ),

         new Static4D(  0.5f, -0.5f, -0.5f,  0.5f ),

         new Static4D(  0.0f,  1.0f,  0.0f,  0.0f ),

         new Static4D(  0.5f, -0.5f,  0.5f,  0.5f ),

         new Static4D(  1.0f,  0.0f,  0.0f,  0.0f ),

         new Static4D(  0.5f,  0.5f, -0.5f,  0.5f )

         };

    }

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

  public Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = new float[] { -SQ3/3, +SQ3/3 };

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

      }

    return mCuts;

    }

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

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

    {

    int numAxis = ROT_AXIS.length;

    boolean[] tmp = new boolean[] {true,false,true};

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

    for(int i=0; i<numAxis; i++) layerRotatable[i] = tmp;

    return layerRotatable;

    }

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

  public int getMovementType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getMovementSplit()

    {

    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 null;

    }

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

  public int getNumStickerTypes(int[] numLayers)

    {

    return 1;

    }

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

  public int getNumCubitFaces()

    {

    return 4;

    }

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

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

    {

    if( mCenters ==null )

      {

      mCenters = new float[][]

         {

             { 0.0f, 1.5f, 1.5f },

             { 1.5f, 0.0f, 1.5f },

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

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

             { 1.5f, 1.5f, 0.0f },

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

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

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

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

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

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

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

         };

      }

    return mCenters;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    double[][] vertices = new double[][] { {-1.5, 0.0, 0.0},{ 1.5, 0.0, 0.0},{ 0.0,-1.5, 0.0},{ 0.0, 0.0,-1.5} };

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

    float[][] bands     = new float[][] { {0.035f,30,0.16f,0.8f,6,2,2}, {0.010f,30,0.16f,0.2f,6,2,2} };

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

    float[][] corners   = new float[][] { {0.07f,0.40f}, {0.05f,0.30f} };

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

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

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

    return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

    return mQuats[cubit];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 1;

    }

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

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

    {

    return 0;

    }

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

  public int getVariantFaceColor(int variant, int face, int[] numLayers)

    {

    return 0;

    }

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

  public ObjectSticker retSticker(int sticker)

    {

    if( mStickers==null )

      {

      float[][] STICKERS = new float[][] { { 0.0f, -1.0f/3, 0.5f, 1.0f/6, -0.5f, 1.0f/6 } };

      float radius = 0.025f;

      float stroke = 0.050f;

      float[] radii = new float[] {radius,radius,radius};

      if( ObjectControl.isInIconMode() )

        {

        stroke*=1.5f;

        }

      mStickers     = new ObjectSticker[STICKERS.length];

      mStickers[0]  = new ObjectSticker(STICKERS[0],null,radii,stroke);

      }

    return mStickers[sticker];

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public int getComplexity()

    {

    return 2;

    }

}