TwistyPuzzleLib

  CRA1_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.CRAZY  )),

  CRA2_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.MERCURY)),

  CRA3_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.VENUS  )),

  CRA4_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.EARTH  )),

  CRA5_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.MARS   )),

  CRA6_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.JUPITER)),

  CRA7_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.SATURN )),

  CRA8_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.URANUS )),

  CRA9_3 ( TwistyCrazy.class         , 22, R.drawable.cra1_3, true, new InitData(new int[] {3,3,3}, TwistyCrazy.NEPTUNE)),

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

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

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.main.Cubit;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.main.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 TwistyCrazy extends ShapeHexahedron

{

  public static final int CRAZY   = 0x3f;

  public static final int MERCURY = 0x2f;

  public static final int VENUS   = 0x0f;

  public static final int EARTH   = 0x2b;

  public static final int MARS    = 0x0b;

  public static final int JUPITER = 0x10;

  public static final int SATURN  = 0x30;

  public static final int URANUS  = 0x14;

  public static final int NEPTUNE = 0x16;

  private static final float DIAMETER_RATIO = 0.75f;

  private static final float DIFF = 0.6f;

  private static final int NUMBER_CORNER_SEGMENTS = 4;

  private static final int NUMBER_EDGE_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 TwistyCrazy(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.3645522f;

    final float B = 0.0744520f;

    final float C = 0.1823852f;

    final float D = 0.3098326f;

    final float E = 0.1033291f;

    final float F = 0.4044531f;

    final float G = 0.4103489f;

    mStickerCoords = new float[][]

      {

         { A, 0.5f, -0.5f, 0.5f, -0.5f, -A, -B, -A, A, B },

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

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

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

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

      };

    }

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

  @Override

  public int getCubitRotationType(int cubit)

    {

    int[] numLayers = getNumLayers();

    int variant = getCubitVariant(cubit,numLayers);

    switch(variant)

      {

      case  2: return Cubit.TYPE_DECIDER;

      case  3:

      case  4: return Cubit.TYPE_FOLLOWER;

      default: return Cubit.TYPE_NORMAL;

      }

    }

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

  @Override

  public float[] getCubitRowOffset(int cubitIndex)

    {

    if( mOffsets==null )

      {

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

      int numCubits = mPositions.length;

      mOffsets = new float[numCubits][];

      int param = getInitData().getParam();

      int R = (param>>5)&0x1;

      int L = (param>>4)&0x1;

      int U = (param>>3)&0x1;

      int D = (param>>2)&0x1;

      int F = (param>>1)&0x1;

      int B = (param   )&0x1;

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

        {

        switch(i)

          {

          case 20: mOffsets[i] = new float[] {0,0,-DIFF*F}; break;

          case 21: mOffsets[i] = new float[] {0,0,+DIFF*B}; break;

          case 22: mOffsets[i] = new float[] {0,-DIFF*U,0}; break;

          case 23: mOffsets[i] = new float[] {0,+DIFF*D,0}; break;

          case 24: mOffsets[i] = new float[] {-DIFF*R,0,0}; break;

          case 25: mOffsets[i] = new float[] {+DIFF*L,0,0}; break;

          default: mOffsets[i] = tmp;

          }

        }

      }

    return mOffsets[cubitIndex];

    }

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

// Normal 3x3

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[][] m = new int[16][];

      for(int i=0; i<16; i++) m[i] = new int[] { 0,-1,i,0,1,i,0,2,i, 1,-1,i,1,1,i,1,2,i, 2,-1,i,2,1,i,2,2,i};

      mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ),  //  0 0

          new ScrambleState( new int[][] {  null, m[ 4], m[ 5] } ),  //  1 x

          new ScrambleState( new int[][] { m[ 6],  null, m[ 7] } ),  //  2 y

          new ScrambleState( new int[][] { m[ 8], m[ 9],  null } ),  //  3 z

          new ScrambleState( new int[][] { m[10],  null, m[ 7] } ),  //  4 xy

          new ScrambleState( new int[][] { m[11], m[ 9],  null } ),  //  5 xz

          new ScrambleState( new int[][] {  null, m[12], m[ 5] } ),  //  6 yx

          new ScrambleState( new int[][] { m[ 8], m[13],  null } ),  //  7 yz

          new ScrambleState( new int[][] {  null, m[ 4], m[14] } ),  //  8 zx

          new ScrambleState( new int[][] { m[ 6],  null, m[15] } ),  //  9 zy

          new ScrambleState( new int[][] {  null,  null, m[ 5] } ),  // 10 xyx

          new ScrambleState( new int[][] {  null, m[ 4],  null } ),  // 11 xzx

          new ScrambleState( new int[][] {  null,  null, m[ 7] } ),  // 12 yxy

          new ScrambleState( new int[][] { m[ 6],  null,  null } ),  // 13 yzy

          new ScrambleState( new int[][] {  null, m[ 9],  null } ),  // 14 zxz

          new ScrambleState( new int[][] { m[ 8],  null,  null } ),  // 15 zyz

          };

      }

    return mStates;

    }

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

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

    {

    if( mCuts==null )

      {

      float C = 0.5f;

      float[] cut = new float[] {-C,+C};

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = new boolean[] {true,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 )

      {

      mPositions = new float[][]

         {

             { 1.0f, 1.0f, 1.0f},

             { 1.0f, 1.0f,-1.0f},

             { 1.0f,-1.0f, 1.0f},

             { 1.0f,-1.0f,-1.0f},

             {-1.0f, 1.0f, 1.0f},

             {-1.0f, 1.0f,-1.0f},

             {-1.0f,-1.0f, 1.0f},

             {-1.0f,-1.0f,-1.0f},

             { 1.0f, 1.0f, 0.0f},

             { 1.0f,-1.0f, 0.0f},

             { 1.0f, 0.0f, 1.0f},

             { 1.0f, 0.0f,-1.0f},

             {-1.0f, 1.0f, 0.0f},

             {-1.0f,-1.0f, 0.0f},

             {-1.0f, 0.0f, 1.0f},

             {-1.0f, 0.0f,-1.0f},

             { 0.0f, 1.0f, 1.0f},

             { 0.0f, 1.0f,-1.0f},

             { 0.0f,-1.0f, 1.0f},

             { 0.0f,-1.0f,-1.0f},

             { 0.0f, 0.0f, DIFF},

             { 0.0f, 0.0f,-DIFF},

             { 0.0f, DIFF, 0.0f},

             { 0.0f,-DIFF, 0.0f},

             { DIFF, 0.0f, 0.0f},

             {-DIFF, 0.0f, 0.0f},

             { 0.0f, 1.0f, DIFF},

             {-DIFF, 1.0f, 0.0f},

             { 0.0f, 1.0f,-DIFF},

             { DIFF, 1.0f, 0.0f},

             { 0.0f,-1.0f, DIFF},

             {-DIFF,-1.0f, 0.0f},

             { 0.0f,-1.0f,-DIFF},

             { DIFF,-1.0f, 0.0f},

             { DIFF, 0.0f, 1.0f},

             { 0.0f,-DIFF, 1.0f},

             {-DIFF, 0.0f, 1.0f},

             { 0.0f, DIFF, 1.0f},

             { DIFF, 0.0f,-1.0f},

             { 0.0f,-DIFF,-1.0f},

             {-DIFF, 0.0f,-1.0f},

             { 0.0f, DIFF,-1.0f},

             { 1.0f, DIFF, 0.0f},

             { 1.0f, 0.0f,-DIFF},

             { 1.0f,-DIFF, 0.0f},

             { 1.0f, 0.0f, DIFF},

             {-1.0f, DIFF, 0.0f},

             {-1.0f, 0.0f,-DIFF},

             {-1.0f,-DIFF, 0.0f},

             {-1.0f, 0.0f, DIFF},

             { 1.0f, 1.0f, DIFF},

             { 1.0f, 1.0f,-DIFF},

             { 1.0f,-1.0f, DIFF},

             { 1.0f,-1.0f,-DIFF},

             {-1.0f, 1.0f, DIFF},

             {-1.0f, 1.0f,-DIFF},

             {-1.0f,-1.0f, DIFF},

             {-1.0f,-1.0f,-DIFF},

             { 1.0f, DIFF, 1.0f},

             { 1.0f,-DIFF, 1.0f},

             { 1.0f, DIFF,-1.0f},

             { 1.0f,-DIFF,-1.0f},

             {-1.0f, DIFF, 1.0f},

             {-1.0f,-DIFF, 1.0f},

             {-1.0f, DIFF,-1.0f},

             {-1.0f,-DIFF,-1.0f},

             { DIFF, 1.0f, 1.0f},

             {-DIFF, 1.0f, 1.0f},

             { DIFF, 1.0f,-1.0f},

             {-DIFF, 1.0f,-1.0f},

             { DIFF,-1.0f, 1.0f},

             {-DIFF,-1.0f, 1.0f},

             { DIFF,-1.0f,-1.0f},

             {-DIFF,-1.0f,-1.0f},

         };

      }

    return mPositions;

    }

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

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

    {

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

                                                    6,17,7,12,4,16,9,10,0,5,3,2,

                                                    0,2,1,3,6,4,

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

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

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private ObjectShape getCornerShape()

    {

    final float INIT_ALPHA = (float)Math.asin(1/(3*DIAMETER_RATIO));

    final float STEP_CORNER= (float)((Math.PI/2-2*INIT_ALPHA)/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)(1.5f*DIAMETER_RATIO*Math.sin(alpha) - 1.0f);

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

      }

    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*INIT_ALPHA)/(2*NUMBER_CORNER_SEGMENTS));

    final float LEN = 1.5f*DIAMETER_RATIO*EXTRA;

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

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

      }

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

      }

    return new ObjectShape(vertices,indices);

    }

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

  private ObjectShape getEdgeShape()

    {

    final int NUM_VERTICES = 8 + 3*(NUMBER_EDGE_SEGMENTS-1);

    final float INIT_ALPHA = (float)Math.asin(1/(3*DIAMETER_RATIO));

    final float H = 0.5f*((float)Math.sqrt(9*DIAMETER_RATIO*DIAMETER_RATIO-1))-1.0f;

    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,    H,+0.5f};

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

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

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

    vertices[6] = new float[] {-0.5f,    H,    H};

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

    final int NUM_VERTS = NUMBER_EDGE_SEGMENTS-1;

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

      {

      float beta = INIT_ALPHA*((2.0f*(i+1))/NUMBER_EDGE_SEGMENTS -1 );

      float A = (float)(1.5f*DIAMETER_RATIO*Math.sin(beta));

      float B = (float)(1.5f*DIAMETER_RATIO*Math.cos(beta)-1.0f);

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

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

      vertices[8+2*NUM_VERTS+i] = new float[] {A,B,B};

      }

    final int NUM_FACES = 4 + 2*NUMBER_EDGE_SEGMENTS;

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

    int NUMV = 3+NUMBER_EDGE_SEGMENTS;

    indices[0] = new int[NUMV];

    indices[0][0] = 3;

    indices[0][1] = 1;

    indices[0][2] = 0;

    indices[0][3] = 2;

    for(int i=0; i<NUM_VERTS; i++) indices[0][4+i] = 8+i;

    indices[1] = new int[NUMV];

    indices[1][0] = 4;

    indices[1][1] = 0;

    indices[1][2] = 1;

    indices[1][3] = 5;

    for(int i=0; i<NUM_VERTS; i++) indices[1][4+i] = 7+2*NUM_VERTS-i;

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

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

    indices[4] = new int[] {8,2,6,8+2*NUM_VERTS};

    indices[5] = new int[] {3,7+NUM_VERTS,7+3*NUM_VERTS,7};

    indices[6] = new int[] {6,4,8+NUM_VERTS,8+2*NUM_VERTS};

    indices[7] = new int[] {5,7,7+3*NUM_VERTS,7+2*NUM_VERTS};

    int i0,i1,i2,i3;

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

      {

      i0 = 9+i;

      i1 = 8+i;

      i2 = 8+2*NUM_VERTS+i;

      i3 = 9+2*NUM_VERTS+i;

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

      i0 = 9+2*NUM_VERTS+i;

      i1 = 8+2*NUM_VERTS+i;

      i2 = 8+NUM_VERTS+i;

      i3 = 9+NUM_VERTS+i;

      indices[8+NUMBER_EDGE_SEGMENTS-2+i] = new int[] {i0,i1,i2,i3};

      }

    return new ObjectShape(vertices,indices);

    }

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

  private ObjectShape getCenterShape(float D)

    {

    float[][] vertices = new float[][]

        {

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

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

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

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

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

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

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

            {+0.5f,+0.5f,+0.5f+D},

        };

    int[][] indices = new int[][]

        {

            {1,5,7,3},

            {5,4,6,7},

            {0,1,3,2},

            {3,7,6,2},

            {0,4,5,1},

            {4,0,2,6}

        };

    return new ObjectShape(vertices,indices);

    }

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

  private ObjectShape getBigCircleShape(float D)

    {

    final float INIT_ALPHA = (float)Math.asin(1/(3*DIAMETER_RATIO));

    final float H = 0.5f*((float)Math.sqrt(9*DIAMETER_RATIO*DIAMETER_RATIO-1))-1.0f;

    final int NUM_VERTICES = 8 + 2*(NUMBER_EDGE_SEGMENTS-1);

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

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

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

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

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

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

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

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

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

    final int NUM_VERTS = NUMBER_EDGE_SEGMENTS-1;

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

      {

      float beta = INIT_ALPHA*((2.0f*(i+1))/NUMBER_EDGE_SEGMENTS -1 );

      float A = (float)(1.5f*DIAMETER_RATIO*Math.sin(beta));

      float B = (float)(1.5f*DIAMETER_RATIO*Math.cos(beta)-1.0f);

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

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

      }

    final int NUM_FACES = 5 + NUMBER_EDGE_SEGMENTS;

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

    int NUMV = 4+NUM_VERTS;

    indices[0] = new int[NUMV];

    indices[0][0] = 4;

    indices[0][1] = 0;

    indices[0][2] = 2;

    indices[0][3] = 6;

    for(int i=0; i<NUM_VERTS; i++) indices[0][4+i] = 7+NUM_VERTS-i;

    indices[1] = new int[NUMV];

    indices[1][0] = 7;

    indices[1][1] = 3;

    indices[1][2] = 1;

    indices[1][3] = 5;

    for(int i=0; i<NUM_VERTS; i++) indices[1][4+i] = 8+NUM_VERTS+i;

    indices[2] = new int[] {7,3,2,6};

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

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

    indices[5] = new int[] {5,4,8,8+NUM_VERTS};

    indices[6] = new int[] {7+NUM_VERTS,6,7,7+2*NUM_VERTS};

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

      {

      int i0 = 8+i;

      int i1 = 9+i;

      int i2 = 9+NUM_VERTS+i;

      int i3 = 8+NUM_VERTS+i;

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

      }

    return new ObjectShape(vertices,indices);

    }

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

  private ObjectShape getSmallCircleShape(float D)

    {

    final float H = 0.5f*((float)Math.sqrt(9*DIAMETER_RATIO*DIAMETER_RATIO-1))-1.0f;

    final float INIT_ALPHA = (float)Math.asin(1/(3*DIAMETER_RATIO));

    final float STEP_CORNER= (float)((Math.PI/2-2*INIT_ALPHA)/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)(1.5f*DIAMETER_RATIO*Math.sin(alpha) - 1.0f);

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

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

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

      }

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

      }

    return new ObjectShape(vertices,indices);

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    switch(variant)

      {

      case 0: return getCornerShape();

      case 1: return getEdgeShape();

      case 2: return getCenterShape(1.0f-DIFF);

      case 3: return getBigCircleShape(1.0f-DIFF);

      case 4: return getSmallCircleShape(1.02f-DIFF);

      }

    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,2,0,0} };

      final int NUM_BANDS = 6+3*NUMBER_CORNER_SEGMENTS;

      int[] bandIndices = new int[NUM_BANDS];

      bandIndices[0] = bandIndices[1] = bandIndices[2] = 0;

      for(int i=3; i<NUM_BANDS; i++) bandIndices[i] = 1;

      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 new ObjectFaceShape(bands,bandIndices,corners,indices,centers,indices,null);

      }

    if( variant==1 )

      {

      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 + 2*NUMBER_EDGE_SEGMENTS;

      int[] bandIndices = new int[NUM_BANDS];

      bandIndices[0] = bandIndices[1] = 0;

      bandIndices[2] = bandIndices[3] = 1;

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

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

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

      final int NUM_VERTICES = 8 + 3*(NUMBER_EDGE_SEGMENTS-1);

      int[] indices = new int[NUM_VERTICES];

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

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

      return new ObjectFaceShape(bands,bandIndices,corners,indices,centers,indices,null);

      }

    if( variant==2 )

      {

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

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

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

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

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

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

      return new ObjectFaceShape(bands,bandIndices,corners,indices,centers,indices,null);

      }

    if( variant==3 )

      {

      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 = 5 + NUMBER_EDGE_SEGMENTS;

      int[] bandIndices = new int[NUM_BANDS];

      bandIndices[0] = 0;

      bandIndices[1] = 2;

      bandIndices[2] = bandIndices[3] = bandIndices[4] = 1;

      for(int i=5; i<NUM_BANDS; i++) bandIndices[i] = 2;

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

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

      final int NUM_VERTICES = 8 + 2*(NUMBER_EDGE_SEGMENTS-1);

      int[] indices = new int[NUM_VERTICES];

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

      indices[0] = indices[2] = indices[4] = indices[6] = 0;

      return new ObjectFaceShape(bands,bandIndices,corners,indices,centers,indices,null);

      }

    else

      {

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

      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[] bandIndices = new int[NUM_BANDS];

      bandIndices[0] = 0;

      bandIndices[1] = 2;

      bandIndices[2] = bandIndices[3] = 1;

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

      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 new ObjectFaceShape(bands,bandIndices,corners,indices,centers,indices,null);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 5;

    }

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

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

    {

    if( cubit< 8 ) return 0;

    if( cubit<20 ) return 1;

    if( cubit<26 ) return 2;

    if( cubit<50 ) return 3;

    return 4;

    }

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

  public float getStickerRadius()

    {

    return 0.07f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

    float D1 = (float)(Math.PI/8);

    float D2 = (float)(Math.PI/6);

    return new float[][] { { 0,0,0,-D1,0 },{ 0,0,0,-D2 },{0,0,0,0},{ 0,0,0,D2 },{ 0,0,D1 } };

    }

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

// 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()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case CRAZY  : return ObjectType.CRA1_3.name();

      case MERCURY: return ObjectType.CRA2_3.name();

      case VENUS  : return ObjectType.CRA3_3.name();

      case EARTH  : return ObjectType.CRA4_3.name();

      case MARS   : return ObjectType.CRA5_3.name();

      case JUPITER: return ObjectType.CRA6_3.name();

      case SATURN : return ObjectType.CRA7_3.name();

      case URANUS : return ObjectType.CRA8_3.name();

      case NEPTUNE: return ObjectType.CRA9_3.name();

      }

    return null;

    }

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

  public ObjectSignature getSignature()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case CRAZY  : return new ObjectSignature(ObjectType.CRA1_3);

      case MERCURY: return new ObjectSignature(ObjectType.CRA2_3);

      case VENUS  : return new ObjectSignature(ObjectType.CRA3_3);

      case EARTH  : return new ObjectSignature(ObjectType.CRA4_3);

      case MARS   : return new ObjectSignature(ObjectType.CRA5_3);

      case JUPITER: return new ObjectSignature(ObjectType.CRA6_3);

      case SATURN : return new ObjectSignature(ObjectType.CRA7_3);

      case URANUS : return new ObjectSignature(ObjectType.CRA8_3);

      case NEPTUNE: return new ObjectSignature(ObjectType.CRA9_3);

      }

    return null;

    }

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

  public String getObjectName()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case CRAZY  : return "Crazy 3x3";

      case MERCURY: return "Crazy Plus Mercury";

      case VENUS  : return "Crazy Plus Venus";

      case EARTH  : return "Crazy Plus Earth";

      case MARS   : return "Crazy Plus Mars";

      case JUPITER: return "Crazy Plus Jupiter";

      case SATURN : return "Crazy Plus Saturn";

      case URANUS : return "Crazy Plus Uranus";

      case NEPTUNE: return "Crazy Plus Neptune";

      }

    return null;

    }

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

  public String getInventor()

    {

    return getInitData().getParam()==CRAZY ? "Aleh Hladzilin" : "Daqing Bao";

    }

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

  public int getYearOfInvention()

    {

    return getInitData().getParam()==CRAZY ? 2008 : 2010;

    }

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

  public int getComplexity()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case CRAZY  : return 2;

      case MERCURY: return 4;

      case VENUS  : return 4;

      case EARTH  : return 4;

      case MARS   : return 4;

      case JUPITER: return 3;

      case SATURN : return 4;

      case URANUS : return 3;

      case NEPTUNE: return 4;

      }

    return 2;

    }

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

  public String[][] getTutorials()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case CRAZY  : return new String[][]{

                                          {"gb","7xUE8ond_Mg","Crazy 3x3x3 Cube Tutorial","SuperAntoniovivaldi"},

                                          {"vn","N_AWJjHzqk0","Circle Crazy 3x3 Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case MERCURY: return new String[][]{

                                          {"gb","SeLGhxZP0E8","Crazy 3x3 Plus Mercury 1/3","SuperAntoniovivaldi"},

                                          {"gb","nTBabfkdMe8","Crazy 3x3 Plus Mercury 2/3","SuperAntoniovivaldi"},

                                          {"gb","Hd87z-VpTgM","Crazy 3x3 Plus Mercury 3a/3","SuperAntoniovivaldi"},

                                          {"gb","MeMJ21vJLBc","Crazy 3x3 Plus Mercury 3b/3","SuperAntoniovivaldi"},

                                          {"gb","s-kUXY5o5AQ","Crazy Mercury Plus Tutorial","twistypuzzling"},

                                          {"es","LYMTrcGiAho","Crazy 3x3 Plus Mercurio","QBAndo"},

                                          {"ru","2jtTsBwu3WY","Как собрать Crazy Mercury","RBcuber"},

                                          {"fr","uxW652tv3_c","Solution crazy 3x3x3 Mercure 1/4","Laurent Boss"},

                                          {"fr","QKuesX-0DaU","Solution crazy 3x3x3 Mercure 2a/4","Laurent Boss"},

                                          {"fr","vDnAy1qYSCc","Solution crazy 3x3x3 Mercure 2b/4","Laurent Boss"},

                                          {"fr","_eEILlsLurc","Solution crazy 3x3x3 Mercure 3/4","Laurent Boss"},

                                          {"fr","4D3V9c3u7so","Solution crazy 3x3x3 Mercure 4/4","Laurent Boss"},

                                          {"br","bMuDIEemCkI","Resolver Crazy Mercurio 1/5","Rafael Cinoto"},

                                          {"br","FPP_nvOsnIQ","Resolver Crazy Mercurio 2/5","Rafael Cinoto"},

                                          {"br","ouz20eYDlLM","Resolver Crazy Mercurio 3/5","Rafael Cinoto"},

                                          {"br","IDHXszSX-UQ","Resolver Crazy Mercurio 4/5","Rafael Cinoto"},

                                          {"br","Wbq701nq900","Resolver Crazy Mercurio 5/5","Rafael Cinoto"},

                                          {"kr","NYBrUY9ngnc","크레이지 333 수성 1/3","듀나메스 큐브 해법연구소"},

                                          {"kr","snT8xxMb0E0","크레이지 333 수성 2/3","듀나메스 큐브 해법연구소"},

                                          {"kr","Pbfm3FZy_3k","크레이지 333 수성 3/3","듀나메스 큐브 해법연구소"},

                                          {"vn","_1Pn2nqDF3A","Crazy Mercury 3x3 Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case VENUS  : return new String[][]{

                                          {"gb","I4f7UngHofc","Crazy 3x3 Plus Venus 1/3","SuperAntoniovivaldi"},

                                          {"gb","p57W1iBXa0k","Crazy 3x3 Plus Venus 2/3","SuperAntoniovivaldi"},

                                          {"gb","IUQcgfgYW3A","Crazy 3x3 Plus Venus 3/3","SuperAntoniovivaldi"},

                                          {"es","L_o5b6i6iQc","Crazy 3x3 Plus Venus","QBAndo"},

                                          {"ru","e6rFPDlpBoI","Как собрать Crazy Venus","Илья Топор-Гилка"},

                                          {"fr","Ccu2XugYAhw","Solution crazy 3x3x3 Venus 1/6","Laurent Boss"},

                                          {"fr","sz5JjDsBB4c","Solution crazy 3x3x3 Venus 2/6","Laurent Boss"},

                                          {"fr","ap_m3-xY7LU","Solution crazy 3x3x3 Venus 3/6","Laurent Boss"},

                                          {"fr","BkV1dyWIH1Q","Solution crazy 3x3x3 Venus 4/6","Laurent Boss"},

                                          {"fr","spO_rh09h9s","Solution crazy 3x3x3 Venus 5/6","Laurent Boss"},

                                          {"fr","kEmXDJgO0B4","Solution crazy 3x3x3 Venus 6/6","Laurent Boss"},

                                          {"br","i781Mf0Fuag","Resolver Crazy Venus 1/3","Rafael Cinoto"},

                                          {"br","3m0eyKbLaQ4","Resolver Crazy Venus 2/3","Rafael Cinoto"},

                                          {"br","nKamBHo7oxo","Resolver Crazy Venus 3/3","Rafael Cinoto"},

                                          {"kr","hsWfqlOa4_0","크레이지 (Crazy) 333 금성 1/5","듀나메스 큐브 해법연구소"},

                                          {"kr","Z2sJczk29kg","크레이지 (Crazy) 333 금성 2/5","듀나메스 큐브 해법연구소"},

                                          {"kr","8r1la2KEiBo","크레이지 (Crazy) 333 금성 3/5","듀나메스 큐브 해법연구소"},

                                          {"kr","S9IcRa5AQHk","크레이지 (Crazy) 333 금성 4/5","듀나메스 큐브 해법연구소"},

                                          {"kr","fs78ZSlShm0","크레이지 (Crazy) 333 금성 3/5","듀나메스 큐브 해법연구소"},

                                          {"vn","_fG3VIKUwNo","Crazy Venus 3x3 Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case EARTH  : return new String[][]{

                                          {"gb","brNQ6Nl1-Mw","Crazy 3x3 Plus Earth 1/4","SuperAntoniovivaldi"},

                                          {"gb","-3RSoC5OZGc","Crazy 3x3 Plus Earth 2/4","SuperAntoniovivaldi"},

                                          {"gb","ahuXWFLTKRg","Crazy 3x3 Plus Earth 3/4","SuperAntoniovivaldi"},

                                          {"gb","Lwt-7XKesUg","Crazy 3x3 Plus Earth 4/4","SuperAntoniovivaldi"},

                                          {"es","GFHcLpYF620","Crazy 3x3 Plus Tierra","QBAndo"},

                                          {"ru","YmEoI0XI5E4","Как собрать Crazy Earth","Илья Топор-Гилка"},

                                          {"fr","QT4T4JV-L44","Solution crazy 3x3x3 Terre 1/6","Laurent Boss"},

                                          {"fr","8On3fbrG5aA","Solution crazy 3x3x3 Terre 2/6","Laurent Boss"},

                                          {"fr","IPEvUnVumJg","Solution crazy 3x3x3 Terre 3/6","Laurent Boss"},

                                          {"fr","0awyEJmfuMM","Solution crazy 3x3x3 Terre 4/6","Laurent Boss"},

                                          {"fr","xLKGyRXuaGs","Solution crazy 3x3x3 Terre 5/6","Laurent Boss"},

                                          {"fr","CcunFHHhQ7g","Solution crazy 3x3x3 Terre 6/6","Laurent Boss"},

                                          {"kr","4YBV9TnAzlg","크레이지(Crazy) 333 지구 1/5","듀나메스 큐브 해법연구소"},

                                          {"kr","uWbAgUq-IqU","크레이지(Crazy) 333 지구 2/5","듀나메스 큐브 해법연구소"},

                                          {"kr","glZqE9hQXK8","크레이지(Crazy) 333 지구 3/5","듀나메스 큐브 해법연구소"},

                                          {"kr","WF2RGp8E97k","크레이지(Crazy) 333 지구 4/5","듀나메스 큐브 해법연구소"},

                                          {"kr","RC-w26wLtQg","크레이지(Crazy) 333 지구 5/5","듀나메스 큐브 해법연구소"},

                                          {"vn","MsFqHGuWspE","Crazy Earth 3x3 Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case MARS   : return new String[][]{

                                          {"gb","AJC0dZx2T-M","Crazy 3x3 Plus Mars 1/4","SuperAntoniovivaldi"},

                                          {"gb","BcrYXklwEow","Crazy 3x3 Plus Mars 2/4","SuperAntoniovivaldi"},

                                          {"gb","L_Y0qRG8F-0","Crazy 3x3 Plus Mars 3/4","SuperAntoniovivaldi"},

                                          {"gb","PRyeKOV0Pbg","Crazy 3x3 Plus Mars 4/4","SuperAntoniovivaldi"},

                                          {"es","P5NsxqMx9Bo","Crazy 3x3 Plus Marte","QBAndo"},

                                          {"ru","syzb9hOojEs","Как собрать Crazy Mars","Илья Топор-Гилка"},

                                          {"fr","tSqak16XJjw","Solution crazy 3x3x3 Mars 1/6","Laurent Boss"},

                                          {"fr","Dm47WsF8OZg","Solution crazy 3x3x3 Mars 2/6","Laurent Boss"},

                                          {"fr","gl-VL1NAslY","Solution crazy 3x3x3 Mars 3/6","Laurent Boss"},

                                          {"fr","TlgsnVdkNh4","Solution crazy 3x3x3 Mars 4/6","Laurent Boss"},

                                          {"fr","XxVeGY1IYIc","Solution crazy 3x3x3 Mars 5/6","Laurent Boss"},

                                          {"fr","aK9YYEYMsyA","Solution crazy 3x3x3 Mars 6/6","Laurent Boss"},

                                          {"kr","QKu2p9nNxFk","크레이지 333 화성 1/4","듀나메스 큐브 해법연구소"},

                                          {"kr","f5YYqm6PPms","크레이지 333 화성 2a/4","듀나메스 큐브 해법연구소"},

                                          {"kr","nmNxrpvucIg","크레이지 333 화성 2b/4","듀나메스 큐브 해법연구소"},

                                          {"kr","rJLpMPCEc_s","크레이지 333 화성 3/4","듀나메스 큐브 해법연구소"},

                                          {"kr","bBRAfOvUu8M","크레이지 333 화성 4/4","듀나메스 큐브 해법연구소"},

                                          {"vn","lzw0Gfi-dM8","Crazy Mars 3x3 Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case JUPITER: return new String[][]{

                                          {"gb","HMnbVoOPk5E","Crazy 3x3 Plus Jupiter 1/2","SuperAntoniovivaldi"},

                                          {"gb","Nw-LBWVu7yM","Crazy 3x3 Plus Jupiter 2/2","SuperAntoniovivaldi"},

                                          {"es","p2HTOQZNfx4","Crazy 3x3 Plus Jupiter","QBAndo"},

                                          {"ru","PGiYCgJYPAY","Как собрать Crazy Jupiter","RBcuber"},

                                          {"fr","sKi_cXmywVs","Solution crazy 3x3x3 Jupiter 1/3","Laurent Boss"},

                                          {"fr","HYnQCifSzFY","Solution crazy 3x3x3 Jupiter 2/3","Laurent Boss"},

                                          {"fr","DNfV8gnaRXw","Solution crazy 3x3x3 Jupiter 3/3","Laurent Boss"},

                                          {"pl","eJmQ50vcQcU","Crazy 3x3 Jupiter TUTORIAL PL","MrUK"},

                                          {"br","pwYhThiSKLQ","Resolver Crazy Jupiter 1/2","Rafael Cinoto"},

                                          {"br","VhuBtUU866U","Resolver Crazy Jupiter 2/2","Rafael Cinoto"},

                                          {"kr","WQ3ad3DrBwY","크레이지 333 목성 1/2","듀나메스 큐브 해법연구소"},

                                          {"kr","3LLL34HsqUs","크레이지 333 목성 2/2","듀나메스 큐브 해법연구소"},

                                          {"vn","QH4ywmKNGVo","Jupiter Crazy Plus Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case SATURN : return new String[][]{

                                          {"gb","7fPXML8hZ-I","Crazy 3x3 Plus Saturn 1/3","SuperAntoniovivaldi"},

                                          {"gb","ixVVVoxsg4A","Crazy 3x3 Plus Saturn 2/3","SuperAntoniovivaldi"},

                                          {"gb","Dd8ZaGzbvjE","Crazy 3x3 Plus Saturn 3/3","SuperAntoniovivaldi"},

                                          {"es","EyQXl0llt2M","Crazy 3x3 Plus Saturno","QBAndo"},

                                          {"ru","T2uYDHyQZnE","Как собрать Crazy Saturn","Илья Топор-Гилка"},

                                          {"fr","kuSYpTXoXUM","Solution crazy 3x3x3 Saturn 1/6","Laurent Boss"},

                                          {"fr","u1OsRGuBcHA","Solution crazy 3x3x3 Saturn 2/6","Laurent Boss"},

                                          {"fr","ra0MspIkctU","Solution crazy 3x3x3 Saturn 3/6","Laurent Boss"},

                                          {"fr","dm3WBtGdxYA","Solution crazy 3x3x3 Saturn 4/6","Laurent Boss"},

                                          {"fr","jVwPmbYot_U","Solution crazy 3x3x3 Saturn 5/6","Laurent Boss"},

                                          {"fr","raYIoRIZPmc","Solution crazy 3x3x3 Saturn 6/6","Laurent Boss"},

                                          {"br","0oKu1NXiQcY","Resolver Crazy Saturn 1/4","Rafael Cinoto"},

                                          {"br","bRD73Lb1NTw","Resolver Crazy Saturn 2/4","Rafael Cinoto"},

                                          {"br","v9nZrwCyNLs","Resolver Crazy Saturn 3/4","Rafael Cinoto"},

                                          {"br","aipwvc2udbM","Resolver Crazy Saturn 4/4","Rafael Cinoto"},

                                          {"kr","hfogu6lCLvs","크레이지 (Crazy) 333 토성 1/5","듀나메스 큐브 해법연구소"},

                                          {"kr","rKjRzKxXHyA","크레이지 (Crazy) 333 토성 2/5","듀나메스 큐브 해법연구소"},

                                          {"kr","7tKfu5RJCVc","크레이지 (Crazy) 333 토성 3/5","듀나메스 큐브 해법연구소"},

                                          {"kr","L68nVvMhxVc","크레이지 (Crazy) 333 토성 4/5","듀나메스 큐브 해법연구소"},

                                          {"kr","fvOcR9-TQpA","크레이지 (Crazy) 333 토성 5/5","듀나메스 큐브 해법연구소"},

                                          {"vn","jiGMQ9Mn14w","Saturn Crazy Plus Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case URANUS : return new String[][]{

                                          {"gb","wOyVb2TMZlk","Crazy 3x3 Plus Uranus 1/3","SuperAntoniovivaldi"},

                                          {"gb","UbTBBQ-gvk0","Crazy 3x3 Plus Uranus 2/3","SuperAntoniovivaldi"},

                                          {"gb","_7k57cV81BM","Crazy 3x3 Plus Uranus 3/3","SuperAntoniovivaldi"},

                                          {"es","vuPcyvE6EVE","Crazy 3x3 Plus Urano","QBAndo"},

                                          {"ru","tm6sxFSeeBg","Как собрать Crazy Uranus","Илья Топор-Гилка"},

                                          {"fr","i9lU26McP38","Solution crazy 3x3x3 Uranus 1/4","Laurent Boss"},

                                          {"fr","Zr6fTayObJk","Solution crazy 3x3x3 Uranus 2/4","Laurent Boss"},

                                          {"fr","nCmCxrY_QMU","Solution crazy 3x3x3 Uranus 3/4","Laurent Boss"},

                                          {"fr","YNs8IohERKs","Solution crazy 3x3x3 Uranus 4/4","Laurent Boss"},

                                          {"pl","pKPQJoGJtno","Crazy 3x3 Uranus TUTORIAL PL","MrUK"},

                                          {"br","jjcqHXOD9eo","Resolver Crazy Urano 1/2","Rafael Cinoto"},

                                          {"br","1B73Z2XE2ss","Resolver Crazy Urano 2/2","Rafael Cinoto"},

                                          {"kr","_m3S5DiVRMw","크레이지 333 천왕성 1/2","듀나메스 큐브 해법연구소"},

                                          {"kr","z9Wh6FXr0og","크레이지 333 천왕성 2/2","듀나메스 큐브 해법연구소"},

                                          {"vn","bHiQ3YSEb2I","Uranus Crazy Plus Tutorial","VĂN CÔNG TÙNG"},

                                         };

      case NEPTUNE: return new String[][]{

                                          {"gb","1gFmuFpU5-Y","Crazy 3x3 Plus Neptune 1a/4","SuperAntoniovivaldi"},

                                          {"gb","UPRIH0MtmPM","Crazy 3x3 Plus Neptune 1b/4","SuperAntoniovivaldi"},

                                          {"gb","Trqruz1NZ5E","Crazy 3x3 Plus Neptune 2/4","SuperAntoniovivaldi"},

                                          {"gb","1gFmuFpU5-Y","Crazy 3x3 Plus Neptune 3/4","SuperAntoniovivaldi"},

                                          {"gb","Rfa5y8NGqdY","Crazy 3x3 Plus Neptune 4/4","SuperAntoniovivaldi"},

                                          {"es","LOR1cNs4NWM","Crazy 3x3 Plus Neptuno","QBAndo"},

                                          {"ru","qvaRxJJrdi8","Как собрать Crazy Neptune","Илья Топор-Гилка"},

                                          {"kr","6Avdw2zX5XI","크레이지 333 해왕성 1/2","듀나메스 큐브 해법연구소"},

                                          {"kr","YbfWfDDBN9k","크레이지 333 해왕성 2/2","듀나메스 큐브 해법연구소"},

                                          {"vn","hmf1YShJuZg","Neptune Crazy Plus Tutorial","VĂN CÔNG TÙNG"},

                                         };

      }

    return null;

    }

}