TwistyPuzzleLib

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

// Copyright 2022 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 java.io.InputStream;

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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.Cubit;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

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

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

public class TwistyCrazy2x2 extends ShapeHexahedron

{

  private static final float DIAMETER_RATIO = 0.60f;

  private static final float DIFF = 1.0f;

  private static final int NUMBER_CORNER_SEGMENTS = 4;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private ScrambleState[] mStates;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPositions;

  private int[] mQuatIndex;

  private float[][] mOffsets;

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

  public TwistyCrazy2x2(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

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

    }

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

  @Override

  public void adjustStickerCoords()

    {

    final float A = 0.50000f;

    final float B = 0.45424f;

    final float C = 0.11830f;

    mStickerCoords = new float[][]

      {

        {  B, A,-A, A,-A,-B,-C,-B, B, C },

        { -A, A,-A,-A, A,-A }

      };

    }

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

  @Override

  public int getCubitRotationType(int cubit)

    {

    return cubit<8 ? Cubit.TYPE_NORMAL : ( cubit<11 ? Cubit.TYPE_DECIDER : Cubit.TYPE_FOLLOWER);

    }

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

  @Override

  public float[] getCubitRowOffset(int cubitIndex)

    {

    if( mOffsets==null )

      {

      float[] tmp = new float[] {0,0,0};

      int numCubits = mPositions.length;

      mOffsets = new float[numCubits][];

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

        {

        switch(i)

          {

          case  8: mOffsets[i] = new float[] { 1,0,0}; break;

          case  9: mOffsets[i] = new float[] {0, 1,0}; break;

          case 10: mOffsets[i] = new float[] {0,0,-1}; break;

          default: mOffsets[i] = tmp;

          }

        }

      }

    return mOffsets[cubitIndex];

    }

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

// Normal 2x2

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] m = new int[] { 0,-1,0,0,1,0,0,2,0, 1,-1,0,1,1,0,1,2,0 };

      mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { m,m,m } )

          };

      }

    return mStates;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = new float[] {0};

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

      }

    return mCuts;

    }

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

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

    {

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

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

    }

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

  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( mPositions==null )

      {

      final float E = -DIFF+0.5f;

      mPositions = new float[][]

         {

             { 0.5f, 0.5f, 0.5f},

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

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

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

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

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

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

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

             { E, 0.5f,-0.5f}, //

             { 0.5f, E,-0.5f}, // Deciders first

             { 0.5f, 0.5f,-E}, //

             { 0.5f, 0.5f, E},

             { 0.5f,-0.5f, E},

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

             {-0.5f, 0.5f, E},

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

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

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

             { 0.5f, E, 0.5f},

             { 0.5f,-E, 0.5f},

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

             {-0.5f, E, 0.5f},

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

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

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

             { E, 0.5f, 0.5f},

             {-E, 0.5f, 0.5f},

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

             { E,-0.5f, 0.5f},

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

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

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

         };

      }

    return mPositions;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] { 0,1,17,22,4,5,8,19,

                                                    6,1,18,

                                                    0,7,2, 9,5,8,19, 13,3,22, 14,23,15,11, 21,4,10, 17,20,12,16 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      final float INIT_ALPHA = 0.0f;

      final float STEP_CORNER= (float)((Math.PI/2)/NUMBER_CORNER_SEGMENTS);

      final int SINGLE_ARC = NUMBER_CORNER_SEGMENTS+1;

      final int SINGLE_INNER_ARC = (NUMBER_CORNER_SEGMENTS+1)/2;

      final int NUM_VERTICES = 4 + 3*SINGLE_ARC + 1 + 3*SINGLE_INNER_ARC;

      float[][] tmp = new float[SINGLE_ARC][2];

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

        {

        float alpha = INIT_ALPHA + i*STEP_CORNER;

        tmp[i][0] = (float)(DIAMETER_RATIO*Math.sin(alpha) - 0.5f);

        tmp[i][1] = (float)(DIAMETER_RATIO*Math.cos(alpha) - 0.5f);

        }

      float[][] vertices = new float[NUM_VERTICES][];

      vertices[0] = new float[] { +0.5f, +0.5f, +0.5f };

      vertices[1] = new float[] { -0.5f, +0.5f, +0.5f };

      vertices[2] = new float[] { +0.5f, -0.5f, +0.5f };

      vertices[3] = new float[] { +0.5f, +0.5f, -0.5f };

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

        {

        float s = tmp[i][0];

        float c = tmp[i][1];

        vertices[4             +i] = new float[] {0.5f,+s,+c};

        vertices[4+  SINGLE_ARC+i] = new float[] {+c,0.5f,+s};

        vertices[4+2*SINGLE_ARC+i] = new float[] {+s,+c,0.5f};

        }

      final float EXTRA = (NUMBER_CORNER_SEGMENTS%2)==0 ? 1.0f : (float)Math.cos((Math.PI/2)/(2*NUMBER_CORNER_SEGMENTS));

      final float LEN   = DIAMETER_RATIO*EXTRA;

      final float M     = (float)(LEN*Math.sin(Math.PI/4) - 0.5f);

      vertices[4+3*SINGLE_ARC] = new float[] {M,M,M};

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

        {

        float s = tmp[i][0];

        float c = tmp[i][1];

        vertices[4+3*SINGLE_ARC+1                   +i] = new float[] {s,c,c};

        vertices[4+3*SINGLE_ARC+1+  SINGLE_INNER_ARC+i] = new float[] {c,s,c};

        vertices[4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+i] = new float[] {c,c,s};

        }

      return vertices;

      }

    else

      {

      final float D = DIFF+0.02f;

      final float H = DIAMETER_RATIO-0.5f;

      final float INIT_ALPHA = 0;

      final float STEP_CORNER= (float)((Math.PI/2)/NUMBER_CORNER_SEGMENTS);

      final int NUM_VERTICES = 6 + 2*(NUMBER_CORNER_SEGMENTS-1);

      float[][] vertices = new float[NUM_VERTICES][];

      vertices[0] = new float[] {-0.5f,    H, 0.5f+D};

      vertices[1] = new float[] {    H,-0.5f, 0.5f+D};

      vertices[2] = new float[] {-0.5f,-0.5f, 0.5f+D};

      vertices[3] = new float[] {-0.5f,    H,-0.5f+D};

      vertices[4] = new float[] {    H,-0.5f,-0.5f+D};

      vertices[5] = new float[] {-0.5f,-0.5f,-0.5f+D};

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

        {

        float alpha = INIT_ALPHA + (i+1)*STEP_CORNER;

        float A = (float)(DIAMETER_RATIO*Math.sin(alpha) - 0.5f);

        float B = (float)(DIAMETER_RATIO*Math.cos(alpha) - 0.5f);

        vertices[6                       +i] = new float[] {A,B, 0.5f+D};

        vertices[5+NUMBER_CORNER_SEGMENTS+i] = new float[] {A,B,-0.5f+D};

        }

      return vertices;

      }

    }

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

  private ObjectShape getCornerShape()

    {

    final int SINGLE_ARC = NUMBER_CORNER_SEGMENTS+1;

    final int SINGLE_INNER_ARC = (NUMBER_CORNER_SEGMENTS+1)/2;

    final int NUM_FACES = 6 + 3*NUMBER_CORNER_SEGMENTS;

    final int NUM_VERTS = 4 +   NUMBER_CORNER_SEGMENTS;

    int[][] indices = new int[NUM_FACES][];

    indices[0] = new int[NUM_VERTS];

    indices[1] = new int[NUM_VERTS];

    indices[2] = new int[NUM_VERTS];

    indices[0][0] = 3;

    indices[0][1] = 0;

    indices[0][2] = 2;

    indices[1][0] = 1;

    indices[1][1] = 0;

    indices[1][2] = 3;

    indices[2][0] = 2;

    indices[2][1] = 0;

    indices[2][2] = 1;

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

      {

      indices[0][3+i] = 4+i;

      indices[1][3+i] = 4+i+  SINGLE_ARC;

      indices[2][3+i] = 4+i+2*SINGLE_ARC;

      }

    indices[3] = new int[] { 1, 4+2*SINGLE_ARC-1, 4+3*SINGLE_ARC+1                   , 4+2*SINGLE_ARC};

    indices[4] = new int[] { 2, 4+3*SINGLE_ARC-1, 4+3*SINGLE_ARC+1+  SINGLE_INNER_ARC, 4             };

    indices[5] = new int[] { 3, 4+  SINGLE_ARC-1, 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC, 4+  SINGLE_ARC};

    int start,i0,i1,i2,i3;

    int MID = (NUMBER_CORNER_SEGMENTS)/2;

    int MID2= (NUMBER_CORNER_SEGMENTS+1)/2;

    if( (NUMBER_CORNER_SEGMENTS%2) == 0 )

      {

      start = 12;

      indices[ 6] = new int[] { 4+3*SINGLE_ARC, 4+SINGLE_ARC+MID, 4+SINGLE_ARC+MID-1, 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+MID-1};

      indices[ 7] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+MID-1,  4+SINGLE_ARC+MID+1, 4+SINGLE_ARC+MID};

      indices[ 8] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+MID-1, 4+MID+1, 4+MID };

      indices[ 9] = new int[] { 4+3*SINGLE_ARC, 4+MID, 4+MID-1, 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+MID-1 };

      indices[10] = new int[] { 4+3*SINGLE_ARC, 4+2*SINGLE_ARC+MID, 4+2*SINGLE_ARC+MID-1, 4+3*SINGLE_ARC+1+MID-1 };

      indices[11] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+MID-1, 4+2*SINGLE_ARC+MID+1, 4+2*SINGLE_ARC+MID };

      }

    else

      {

      start = 9;

      indices[ 6] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+MID, 4+SINGLE_ARC+MID+1, 4+SINGLE_ARC+MID, 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+MID};

      indices[ 7] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+MID,  4+MID+1, 4+MID, 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+MID};

      indices[ 8] = new int[] { 4+3*SINGLE_ARC, 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+MID, 4+2*SINGLE_ARC+MID+1, 4+2*SINGLE_ARC+MID, 4+3*SINGLE_ARC+1+MID};

      }

    for(int j=0; j<MID2-1; j++)

      {

      i0 = 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+j;

      i1 = 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+j+1;

      i2 = 4+SINGLE_ARC+j+1;

      i3 = 4+SINGLE_ARC+j;

      indices[start+j] = new int[] {i0,i1,i2,i3};

      i0 = 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+j+1;

      i1 = 4+3*SINGLE_ARC+1+2*SINGLE_INNER_ARC+j;

      i2 = 4+(SINGLE_ARC-1)-j;

      i3 = 4+(SINGLE_ARC-1)-(j+1);

      indices[start+j+(MID2-1)] = new int[] {i0,i1,i2,i3};

      i0 = 4+3*SINGLE_ARC+1+j;

      i1 = 4+3*SINGLE_ARC+1+j+1;

      i2 = 4+2*SINGLE_ARC+j+1;

      i3 = 4+2*SINGLE_ARC+j;

      indices[start+j+2*(MID2-1)] = new int[] {i0,i1,i2,i3};

      i0 = 4+3*SINGLE_ARC+1+j+1;

      i1 = 4+3*SINGLE_ARC+1+j;

      i2 = 4+(2*SINGLE_ARC-1)-j;

      i3 = 4+(2*SINGLE_ARC-1)-(j+1);

      indices[start+j+3*(MID2-1)] = new int[] {i0,i1,i2,i3};

      i0 = 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+j;

      i1 = 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+j+1;

      i2 = 4+j+1;

      i3 = 4+j;

      indices[start+j+4*(MID2-1)] = new int[] {i0,i1,i2,i3};

      i0 = 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+j+1;

      i1 = 4+3*SINGLE_ARC+1+SINGLE_INNER_ARC+j;

      i2 = 4+(3*SINGLE_ARC-1)-j;

      i3 = 4+(3*SINGLE_ARC-1)-(j+1);

      indices[start+j+5*(MID2-1)] = new int[] {i0,i1,i2,i3};

      }

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

    return new ObjectShape(vertices,indices);

    }

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

  private ObjectShape getSmallCircleShape()

    {

    final int NUM_FACES = 4 + NUMBER_CORNER_SEGMENTS;

    int[][] indices = new int[NUM_FACES][];

    int NUMV = 2+NUMBER_CORNER_SEGMENTS;

    indices[0] = new int[NUMV];

    indices[0][0] = 0;

    indices[0][1] = 2;

    indices[0][2] = 1;

    for(int i=3; i<NUMV; i++) indices[0][i] = 5+(NUMBER_CORNER_SEGMENTS-1)-(i-3);

    indices[1] = new int[NUMV];

    indices[1][0] = 4;

    indices[1][1] = 5;

    indices[1][2] = 3;

    for(int i=3; i<NUMV; i++) indices[1][i] = 5+NUMBER_CORNER_SEGMENTS+(i-3);

    indices[2] = new int[] {0,3,5,2};

    indices[3] = new int[] {1,2,5,4};

    indices[4] = new int[] {5+NUMBER_CORNER_SEGMENTS,3,0,6};

    indices[5] = new int[] {1,4,5+2*(NUMBER_CORNER_SEGMENTS-1),5+(NUMBER_CORNER_SEGMENTS-1)};

    for(int i=0; i<NUMBER_CORNER_SEGMENTS-2; i++)

      {

      int i0 = 6+i;

      int i1 = 7+i;

      int i2 = 6+NUMBER_CORNER_SEGMENTS+i;

      int i3 = 5+NUMBER_CORNER_SEGMENTS+i;

      indices[6+i] = new int[] {i0,i1,i2,i3};

      }

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

    return new ObjectShape(vertices,indices);

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    switch(variant)

      {

      case 0: return getCornerShape();

      case 1: return getSmallCircleShape();

      }

    return null;

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

      float h2 = 0.001f;

      float[][] bands   = { {h1,45,0.3f,0.7f,5,0,0}, {h2,5,0.3f,0.2f,5,0,0}, {h2,5,0.3f,0.2f,2,0,0} };

      final int NUM_BANDS = 6+3*NUMBER_CORNER_SEGMENTS;

      int[] indices = new int[NUM_BANDS];

      indices[0] = indices[1] = indices[2] = indices[3] = indices[4] = indices[5] = 0;

      for(int i=6; i<NUM_BANDS; i++) indices[i] = 2;

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float[][] bands   = { {h1,45,0.2f,0.4f,5,0,0}, {0.001f,1,0.3f,0.5f,3,0,0}, {0.001f,1,0.3f,0.5f,2,0,0} };

      final int NUM_BANDS = 4 + NUMBER_CORNER_SEGMENTS;

      int[] indices = new int[NUM_BANDS];

      indices[0] = 0;

      indices[1] = 2;

      indices[2] = indices[3] = 1;

      for(int i=4; i<NUM_BANDS; i++) indices[i] = 2;

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

      final int SINGLE_ARC = NUMBER_CORNER_SEGMENTS+1;

      final int SINGLE_INNER_ARC = (NUMBER_CORNER_SEGMENTS+1)/2;

      final int NUM_VERTICES = 4 + 3*SINGLE_ARC + 1 + 3*SINGLE_INNER_ARC;

      int[] indices = new int[NUM_VERTICES];

      indices[0] = indices[1] = indices[2] = indices[3] = 0;

      for(int i=4; i<NUM_VERTICES; i++) indices[i] = -1;

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

      }

    else

      {

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

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

      final int NUM_VERTICES = 6 + 2*(NUMBER_CORNER_SEGMENTS-1);

      int[] indices = new int[NUM_VERTICES];

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

      indices[0] = indices[1] = indices[2] = 0;

      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<8?0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.07f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.17f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

    float D = (float)(Math.PI/4);

    return new float[][] { { 0,0,0,-D,0 },{ 0,0,D } };

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle==null )

      {

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

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ObjectType.CRA1_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectType.CRA1_2);

    }

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

  public String getObjectName()

    {

    return "Circle 2x2";

    }

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

  public String getInventor()

    {

    return "Aleh Hladzilin";

    }

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

  public int getYearOfInvention()

    {

    return 2007;

    }

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

  public int getComplexity()

    {

    return 2;

    }

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

  public String[][] getTutorials()

    {

     return new String[][] {

                            {"gb","DKLIQghl66c","Circle 2x2 Demonstration","SuperAntoniovivaldi"},

                            {"es","Wq9lwfDfg4E","Resolucion del 2x2 Crazy","RUBIKworld"},

                            {"es","K4bFs4BFdXc","Tutorial Crazy 2x2 de Sengso","Manzacuber"},

                            {"vn","TlT5MYiz4RY","Tutorial N.216 Circular 2x2","Duy Thích Rubik"},

                           };

    }

}