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

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

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

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyMirror 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 static final int[] FACE_COLORS = new int[] { COLOR_WHITE };

  private static final float DX = 0.10f;

  private static final float DY = 0.25f;

  private static final float DZ = 0.40f;

  private int[][] mEdges;

  private float[][] mCuts;

  private int[][] mBasicAngle;

  private float[][] mPositions;

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

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

    {

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

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff333333;

    }

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

  @Override

  public int getColor(int face)

    {

    return FACE_COLORS[face];

    }

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

  @Override

  public int getNumFaceColors()

    {

    return 1;

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int nL = getNumLayers()[0];

      mEdges = ScrambleEdgeGenerator.getScrambleEdgesCuboid(nL,nL,nL);

      }

    return mEdges;

    }

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

  private int getRow(int cubit, int numLayers, int dim)

    {

    return (int)(mPositions[cubit][dim] + 0.5f*(numLayers-1));

    }

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

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

    {

    if( mPositions==null )

      {

      int numL = numLayers[0];

      int numCubits = getNumCubitVariants(numLayers);

      mPositions = new float[numCubits][];

      float diff = 0.5f*(numL-1);

      int currentPosition = 0;

      for(int x = 0; x<numL; x++)

        for(int y = 0; y<numL; y++)

          for(int z = 0; z<numL; z++)

            if( x==0 || x==numL-1 || y==0 || y==numL-1 || z==0 || z==numL-1 )

              {

              mPositions[currentPosition++] = new float[] {x-diff,y-diff,z-diff};

              }

      }

    return mPositions;

    }

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

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

    {

    return mObjectQuats[0];

    }

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

  private float[][] getVertices(int variant)

    {

    int numL = getNumLayers()[0];

    int xrow = getRow(variant,numL,0);  // cubit == variant

    int yrow = getRow(variant,numL,1);

    int zrow = getRow(variant,numL,2);

    float XL = -0.5f + (xrow==     0 ? DX : 0);

    float XR =  0.5f + (xrow==numL-1 ? DX : 0);

    float YL = -0.5f - (yrow==     0 ? DY : 0);

    float YR =  0.5f - (yrow==numL-1 ? DY : 0);

    float ZL = -0.5f - (zrow==     0 ? DZ : 0);

    float ZR =  0.5f - (zrow==numL-1 ? DZ : 0);

    return new float[][]

          {

              { XR, YR, ZR },

              { XR, YR, ZL },

              { XR, YL, ZR },

              { XR, YL, ZL },

              { XL, YR, ZR },

              { XL, YR, ZL },

              { XL, YL, ZR },

              { XL, YL, ZL },

          };

    }

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

  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)

    {

    int extraI, extraV, num, numL = getNumLayers()[0];

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

    switch(numL)

      {

      case 2 : num = 6; extraI = 2; extraV = 2; break;

      case 3 : num = 5; extraI = 2; extraV = 2; break;

      case 4 : num = 5; extraI = 0; extraV = 0; break;

      default: num = 4; extraI = 0; extraV = 0; break;

      }

    float[][] bands = { {height,35,0.5f,0.7f,num,extraI,extraV} };

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

    return new ObjectFaceShape(bands,indices,null);

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

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

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

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

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

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    int numL = numLayers[0];

    return numL>1 ? 6*numL*numL - 12*numL + 8 : 1;

    }

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

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

    {

    return cubit;

    }

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

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

    {

    if( mCuts==null )

      {

      int numL = numLayers[0];

      mCuts = new float[3][numL-1];

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

        {

        float cut = (2-numL)*0.5f + i;

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        }

      }

    return mCuts;

    }

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

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

    {

    int num = numLayers[0];

    boolean[] tmp = new boolean[num];

    for(int i=0; i<num; i++) tmp[i] = true;

    return new boolean[][] { tmp,tmp,tmp };

    }

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

  public int getTouchControlType()

    {

    return TC_CHANGING_MIRROR;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return null;

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    int N = numLayers[0];

    return new float[] { 0.5f+DX/N, 0.5f-DX/N, 0.5f-DY/N, 0.5f+DY/N, 0.5f-DZ/N, 0.5f+DZ/N };

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public float getStickerRadius()

    {

    return 0.10f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      stroke*= ( numLayers[0]==2 ? 1.8f : 2.0f );

      }

    return stroke;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle==null )

      {

      int num = getNumLayers()[0];

      int[] tmp = new int[num];

      for(int i=0; i<num; i++) tmp[i] = 4;

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return ObjectType.MIRR_2.name();

      case 3: return ObjectType.MIRR_3.name();

      case 4: return ObjectType.MIRR_4.name();

      }

    return ObjectType.MIRR_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

      case 2: return new ObjectSignature(ObjectSignatures.MIRR_2);

      case 3: return new ObjectSignature(ObjectSignatures.MIRR_3);

      case 4: return new ObjectSignature(ObjectSignatures.MIRR_4);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Pocket Mirror";

      case 3: return "Mirror Cube";

      case 4: return "Master Mirror Blocks";

      }

    return null;

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Thomas de Bruin";

      case 3: return "Hidetoshi Takeji";

      case 4: return "Traiphum Prungtaengkit";

      }

    return null;

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 2007;

      case 3: return 2006;

      case 4: return 2014;

      }

    return 2006;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1;

      case 3: return 2;

      case 4: return 3;

      }

    return 2;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                          {"gb","rSH-ZEqTmxs","Solve 2x2 Mirror Blocks","King of Cubing"},

                          {"es","Ipz-Ajpd4Fg","Como resolver el mirror 2x2","RUBI CUBI"},

                          {"ru","rGqZq0bjZlM","Как собрать Зеркальный кубик 2x2","maggam1000"},

                          {"de","fFMf1G7MYmA","2x2 Mirror Cube Anfängerlösung","rofrisch"},

                          {"pl","ERUtLe30vXA","Jak ułożyć kostkę mirror 2x2","Korzuu"},

                          {"kr","9S4QTkyNm4Y","2x2 Mirror Cube","큐브놀이터"},

                          {"vn","6zENEJlv5gA","Hướng Dẫn Giải Mirror 2x2","Rubik Cube"},

                         };

      case 3: return new String[][] {

                          {"gb","YkzXIWnqbSw","How to Solve the Mirror Cube","Z3"},

                          {"es","ZTkunMo51l0","Resolver cubo de Rubik MIRROR","Cuby"},

                          {"ru","1QPAD3Q4r78","Как собрать Зеркальный Куб","Алексей Ярыгин"},

                          {"fr","tlFLE2UvjFo","Tutoriel: le rubik's cube mirroir","Le Cubiste"},

                          {"de","Qf2EadLLiZo","Mirror Cube lösen","Pezcraft"},

                          {"pl","r1-MzAL3TxE","Jak ułożyć kostkę mirror","Cube Masters"},

                          {"br","HWGGpIKRT_I","Como resolver o Mirror Blocks","Pedro Filho"},

                          {"kr","p3OJSbWopqg","미러블럭 해법","듀나메스 큐브 해법연구소"},

                          {"vn","F3Gh6JxW1VI","Tutorial N.15 - Mirror Block","Duy Thích Rubik"},

                         };

      case 4: return new String[][] {

                          {"gb","6gyQ5qBK8GU","4x4 Mirror: Introduction","SuperAntoniovivaldi"},

                          {"gb","jvKLW7vxKx4","4x4 Mirror: Layer by Layer","SuperAntoniovivaldi"},

                          {"gb","efHeHrXFNTQ","4x4 Mirror: Reduction","SuperAntoniovivaldi"},

                          {"gb","bKHQn_ARNZ8","4x4 Mirror: Parity Free Solve","SuperAntoniovivaldi"},

                          {"gb","Us1Dlr0PyEA","4x4 Mirror: Superparity","SuperAntoniovivaldi"},

                          {"es","tN2D3j0o-wk","Como hacer un mirror 4x4x4","JGOM Designer"},

                          {"vn","ZGkVOQ3FCOg","Tutorial N.137 - Mirror 4x4x4","Duy Thích Rubik"},

                         };

      }

    return null;

    }

}