TwistyPuzzleLib

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

// Copyright 2019 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_CHANGING_SHAPEMOD;

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

import org.distorted.library.effect.EffectName;

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.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.touchcontrol.TouchControlCuboids;

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

public class TwistyTestGhost extends ShapeHexahedron

{

  private static final int GHOST_ANGLE = 30;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private int[][] mEdges;

  private float[][] mCuts;

  private int[][] mBasicAngle;

  private int[] mQuatIndex;

  private float[][] mPosition;

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

  public TwistyTestGhost(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    super(iconMode, (meta.getNumLayers()[0]+meta.getNumLayers()[1]+meta.getNumLayers()[2])/3.0f, quat, move, scale, meta, asset);

    }

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

  @Override

  public int getGhostAngle()

    {

    return GHOST_ANGLE;

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

  private float[][] getVertices(int variant)

    {

    float D = variant==0 ? 0.0f : (float)Math.tan( (Math.PI*GHOST_ANGLE)/180 );

    return new float[][]

          {

              { 0.5f, 0.5f-D, 0.5f   },

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

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

              { 0.5f,-0.5f  ,-0.5f-D },

              {-0.5f, 0.5f-D, 0.5f   },

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

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

              {-0.5f,-0.5f  ,-0.5f-D },

          };

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    int[][] indices =

          {

              {2,3,1,0},

              {7,6,4,5},

              {4,0,1,5},

              {7,3,2,6},

              {6,2,0,4},

              {3,7,5,1}

          };

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

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    float height = isInIconMode() ? 0.001f : 0.045f;

    int angle = 35;

    float R = 0.5f;

    float S = 0.7f;

    float[][] bands  =

         {

             {height,angle,R,S,6,2,2},

             {0.001f,angle,R,S,6,2,2},

         };

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

    return new ObjectFaceShape(bands,indices, null);

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners = {{0.036f, 0.12f}};

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

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

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

      }

    else

      {

      float[][] corners = {{0.036f, 0.12f}};

      float[][] centers = {{0,0,0}};

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

      float[][] vertices = getVertices(variant);

      int numEff = vertices.length+1;

      String[] names = new String[numEff];

      float[][] vars = new float[numEff][];

      float[][] cents= new float[numEff][];

      float[][] regs = new float[numEff][];

      boolean[] uses = new boolean[numEff];

      String NAME = EffectName.DEFORM.name();

      for(int i=0; i<numEff-1; i++)

        {

        int index = indices[i];

        float[] ce = centers[index];

        float[] ve = vertices[i];

        float S = corners[index][0];

        float R = corners[index][1];

        float CX = ve[0];

        float CY = ve[1];

        float CZ = ve[2];

        float X = S*(ce[0]-CX);

        float Y = S*(ce[1]-CY);

        float Z = S*(ce[2]-CZ);

        names[i]= NAME;

        vars[i] = new float[] { 0, X,Y,Z, 1 };

        cents[i]= new float[] { CX, CY, CZ };

        regs[i] = new float[] { 0,0,0, R };

        uses[i] = false;

        }

      names[numEff-1] = EffectName.VERTEX_ROTATE.name();

      vars[numEff-1]  = new float[] { 0,-GHOST_ANGLE,1,0,0 };  // see VertexEffect.constructEffect

      cents[numEff-1] = new float[] { 0.0f,0.5f,-0.5f };

      regs[numEff-1]  = new float[] { 0,0,0,0 };

      uses[numEff-1]  = true;

      return new ObjectVertexEffects(names,vars,cents,regs,uses);

      }

    }

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

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

    {

    if( mPosition==null )

      {

      final float D = 0.5f;

      mPosition = new float[][]

        {

          {-3*D,-D,-D },

          {-3*D,-D, D },

          {-3*D, D,-D },

          {-3*D, D, D },

          {  -D,-D,-D },

          {  -D,-D, D },

          {  -D, D,-D },

          {  -D, D, D },

          {   D,-D,-D },

          {   D,-D, D },

          {   D, D,-D },

          {   D, D, D },

          { 3*D,-D,-D },

          { 3*D,-D, D },

          { 3*D, D,-D },

          { 3*D, D, D },

        };

      }

    return mPosition;

    }

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

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

    {

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

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<8 ? 0:1;

    }

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

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

    {

    if( mCuts==null )

      {

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

      float[] c2 = {0};

      mCuts = new float[][] { c1,c2,c2 };

      }

    return mCuts;

    }

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

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

    {

    boolean[] r1 = new boolean[] {true,true,true,true};

    boolean[] r2 = new boolean[] {true,true};

    return new boolean[][] { r1,r2,r2 };

    }

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

  public int getTouchControlType()

    {

    return TC_CHANGING_SHAPEMOD;

    }

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

  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)

    {

    float x = numLayers[0];

    float y = numLayers[1];

    float z = numLayers[2];

    float a = (x+y+z)/1.5f;

    return new float[] {x/a,x/a,y/a,y/a,z/a,z/a};

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlCuboids.FACE_AXIS;

    }

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

  public float getStickerRadius()

    {

    return 0.10f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.08f ;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public String getShortName()

    {

    return "TEST_GHO";

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(1000);

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle==null )

      {

      int[] a1 = {4,4,4,4};

      int[] a2 = {2,2};

      mBasicAngle = new int[][] { a1,a2,a2 };

      }

    return mBasicAngle;

    }

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

  public String getObjectName()

    {

    return "Ghost Test";

    }

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

  public String getInventor()

    {

    return "Leszek";

    }

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

  public int getYearOfInvention()

    {

    return 2023;

    }

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

  public float getComplexity()

    {

    return 1;

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}