TwistyPuzzleLib

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

// Copyright 2023 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.TC_HEXAHEDRON;

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

import org.distorted.library.helpers.QuatHelper;

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

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.signature.ObjectConstants;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyO2 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 final int N = 6;  // has to be even

  private final float D1 = 0.67f;

  private final float D2 = 0.99f;

  private final float PX = 0.6f;

  private final float PY = 0.6f;

  private final float PZ = 0.6f;

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private boolean[][] mRotatable;

  private int[] mQuatIndex;

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

  public TwistyO2(int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

    super(iconMode, data.getNumLayers()[0], quat, move, scale, data, asset);

    }

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

// ditto, manually provide the sticker coordinates.

  @Override

  public void adjustStickerCoords()

    {

    final float A = 0.50f;

    final float B = 0.5f*D1;

    final float C = 0.50f;

    // stickers with holes are not collapsed into one; we need to repeat this 6 times

    float[][][] t = new float[][][] { { { A,-A},{A,A},{-A, A},{-A,-A} } , { {B,0},{-B,0} } };

    mStickerCoords = new float[][][][] { t,t,t,t,t,t, { { { C,0},{-C,0} } } };

  }

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

  public float[][][] getStickerAngles()

    {

    float A = (float)(Math.PI/2);

    float[][] t = new float[][] { {0,0,0,0},{-A,-A} };

    return new float[][][] { t,t,t,t,t,t,{{A,A}} };

    }

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

  @Override

  public float getPillowCoeff()

    {

    return 1.2f;

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    float C = 1.5f;

    float[] f = new float[] { C,C };

    return new float[][] { f,f,f };

    }

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

// If the first move was a 180 deg rotation along any ax, we need to forbid the second move to

// also be a 180 deg rotation - because such a scramble can be solved with just one move.

// state 0: last move wasn't a 180 deg.

// state 1: last move was a 180 deg.

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

              {

                      {0,0,1,0,2,1,3,0,4,0,5,1,6,0,7,0,8,1},

                      {0,0,1,0,    3,0,4,0,    6,0,7,0    }

              };

      }

    return mEdges;

    }

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

  @Override

  public int[][] getScrambleAlgorithms()

    {

    setUpRotatable();

    return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngle, mRotatable);

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = new float[] {0.5f};

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

      }

    return mCuts;

    }

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

  private void setUpRotatable()

    {

    if( mRotatable==null )

      {

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

      mRotatable = new boolean[][] { tmp,tmp,tmp };

      }

    }

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

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

    {

    setUpRotatable();

    return mRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  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 float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    if( mPosition==null ) mPosition = new float[][] { {PX,PY,PZ},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0} };

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] { 0, 6,4,1,3,0,2 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private void generateCirclePoint(int index, float[] output, float y, float z)

    {

    float alpha = (float)((Math.PI*index)/(2*N));

    float sin = (float)Math.sin(alpha);

    float cos = (float)Math.cos(alpha);

    output[0] = y*sin;

    output[1] = y*cos;

    output[2] = z;

    }

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

  private void rotateVertices(float[][] vertices, int start, int end, int quatIndex)

    {

    Static4D quat = mObjectQuats[quatIndex];

    float[] tmp = new float[4];

    for(int i=start; i<end; i++)

      {

      float[] v = vertices[i];

      QuatHelper.rotateVectorByQuat(tmp, v[0],v[1],v[2],1, quat);

      v[0] = tmp[0];

      v[1] = tmp[1];

      v[2] = tmp[2];

      }

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      float[][] ret = new float[24*(N+4)][3];

      int index = 0;

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

        {

        int startIndex = index;

        for(int j=0; j<N; j++) generateCirclePoint(j,ret[index++],D1,1);

        ret[index][0] = D1;

        ret[index][1] = 0;

        ret[index][2] = 1;

        index++;

        ret[index][0] = 1;

        ret[index][1] = 0;

        ret[index][2] = 1;

        index++;

        ret[index][0] = 1;

        ret[index][1] = 1;

        ret[index][2] = 1;

        index++;

        ret[index][0] = 0;

        ret[index][1] = 1;

        ret[index][2] = 1;

        index++;

        rotateVertices(ret,startIndex,index,i);

        for(int j=0; j<N+4; j++)

          {

          float[] r = ret[startIndex+j];

          r[0] -= PX;

          r[1] -= PY;

          r[2] -= PZ;

          }

        }

      return ret;

      }

    else

      {

      float[][] ret = new float[8*N][3];

      int index = 0;

      for(int j=0; j<4*N; j++) generateCirclePoint(j,ret[index++],D1,1);

      for(int j=0; j<4*N; j++) generateCirclePoint(j,ret[index++],D2,0);

      return ret;

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int NUM = N/2 + 3;

      int[][][] indices = new int[6][8][NUM];

      int[][] quatIndices = new int[][] { {6,12,17,21}, {4,10,16,20}, {1,13,14,15}, {3,11,22,23}, {0,7,8,9}, {2,5,18,19} };

      for(int f=0; f<6; f++)

        for(int c=0; c<4; c++)

          {

          int index = quatIndices[f][c];

          int[] ind1 = indices[f][2*c];

          int[] ind2 = indices[f][2*c+1];

          for(int v=0; v<NUM-2; v++)

            {

            ind1[v] = index*(N+4) + v;

            ind2[v] = index*(N+4) + v + N/2;

            }

          ind1[NUM-2] = index*(N+4) + N+2;

          ind2[NUM-2] = index*(N+4) + N+1;

          ind1[NUM-1] = index*(N+4) + N+3;

          ind2[NUM-1] = index*(N+4) + N+2;

          }

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

      }

    else

      {

      int[][] indices = new int[4*N+2][];

      indices[0] = new int[4*N];

      indices[1] = new int[4*N];

      for(int i=0; i<4*N; i++)

        {

        indices[0][i] = 4*N-1-i;

        indices[1][i] = 4*N+i;

        }

      for(int i=2; i<4*N+1; i++)

        {

        indices[i] = new int[4];

        indices[i][0] = i-2;

        indices[i][1] = i-2 + 1;

        indices[i][2] = i-2 + 4*N+1;

        indices[i][3] = i-2 + 4*N;

        }

      indices[4*N+1] = new int[4];

      indices[4*N+1][0] = 4*N-1;

      indices[4*N+1][1] = 0;

      indices[4*N+1][2] = 4*N;

      indices[4*N+1][3] = 8*N-1;

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float h = 0.0001f;

      float[][] bands = { {h, 25,0.2f,0.5f,5,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float h2 = 0.001f;

      float[][] bands = { {h2,35,0.3f,0.5f,2,0,0} , {h1,35,0.3f,0.3f,6,0,0} };

      int[] indices = new int[4*N+2];

      indices[0] = 1;

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners = { {0.02f,0.10f} };

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

      int[] indices     = new int[24*(N+4)];

      for(int i=0; i<24*(N+4); i++) indices[i] = -1;

      indices[          N+2] = 0;

      indices[   (N+4)+ N+2] = 0;

      indices[ 2*(N+4)+ N+2] = 0;

      indices[ 3*(N+4)+ N+2] = 0;

      indices[ 4*(N+4)+ N+2] = 0;

      indices[ 5*(N+4)+ N+2] = 0;

      indices[ 8*(N+4)+ N+2] = 0;

      indices[11*(N+4)+ N+2] = 0;

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

      }

    else

      {

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

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

      int num = 8*N;

      int[] indices = new int[num];

      for(int i=0; i<num; i++) indices[i] = -1;

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<1 ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.15f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 0.15f;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle ==null )

      {

      int[] tmp = new int[] {4,4};

      mBasicAngle = new int[][] { tmp,tmp,tmp };

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ObjectType.O2_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectConstants.O2_2);

    }

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

  public String getObjectName()

    {

    return "O2 Cube";

    }

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

  public String getInventor()

    {

    return "Alexander Sosnovsky";

    }

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

  public int getYearOfInvention()

    {

    return 2019;

    }

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

  public float getComplexity()

    {

    return 0.1f;

    }

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

  public String[][] getTutorials()

    {

    return new String[][] {

                    {"gb","m1nHBUnGsZc","1x1x1 O2 Cube","Richie's EZCubing"},

                    {"tw","mcgD9iN4NHU","一階方塊 介紹+教學","不正常魔術方塊研究中心"},

                 };

    }

}