Magic Cube

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

// Copyright 2020 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.objects;

import android.content.res.Resources;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.helpers.FactoryCubit;

import org.distorted.helpers.FactorySticker;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.main.R;

import org.distorted.main.RubikSurfaceView;

import java.util.Random;

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

public class TwistySkewb extends TwistyObject

{

  private static final int FACES_PER_CUBIT =6;

  // the four rotation axis of a RubikSkewb. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(+SQ3/3,+SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,+SQ3/3,-SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)

         };

  private static final int[] FACE_COLORS = new int[]

         {

           COLOR_YELLOW, COLOR_WHITE,

           COLOR_BLUE  , COLOR_GREEN,

           COLOR_RED   , COLOR_ORANGE

         };

  // All legal rotation quats of a RubikSkewb

  private static final Static4D[] QUATS = new Static4D[]

         {

           new Static4D(  0.0f,  0.0f,  0.0f,  1.0f ),

           new Static4D(  1.0f,  0.0f,  0.0f,  0.0f ),

           new Static4D(  0.0f,  1.0f,  0.0f,  0.0f ),

           new Static4D(  0.0f,  0.0f,  1.0f,  0.0f ),

           new Static4D(  0.5f,  0.5f,  0.5f,  0.5f ),

           new Static4D(  0.5f,  0.5f,  0.5f, -0.5f ),

           new Static4D(  0.5f,  0.5f, -0.5f,  0.5f ),

           new Static4D(  0.5f,  0.5f, -0.5f, -0.5f ),

           new Static4D(  0.5f, -0.5f,  0.5f,  0.5f ),

           new Static4D(  0.5f, -0.5f,  0.5f, -0.5f ),

           new Static4D(  0.5f, -0.5f, -0.5f,  0.5f ),

           new Static4D(  0.5f, -0.5f, -0.5f, -0.5f )

         };

  private static final int[][] mCornerMap =

         {

           {  4, 2, 0, 18,18,18 },

           {  2, 5, 0, 18,18,18 },

           {  3, 4, 0, 18,18,18 },

           {  5, 3, 0, 18,18,18 },

           {  1, 2, 4, 18,18,18 },

           {  5, 2, 1, 18,18,18 },

           {  4, 3, 1, 18,18,18 },

           {  1, 3, 5, 18,18,18 },

         };

  private static final int[][] mEdgeMap =

         {

           { 10, 8, 18,18,18,18 },

           {  6,10, 18,18,18,18 },

           { 10, 9, 18,18,18,18 },

           {  7,10, 18,18,18,18 },

           {  8, 6, 18,18,18,18 },

           {  9, 6, 18,18,18,18 },

           {  9, 7, 18,18,18,18 },

           {  8, 7, 18,18,18,18 },

           { 11, 8, 18,18,18,18 },

           {  6,11, 18,18,18,18 },

           { 11, 9, 18,18,18,18 },

           {  7,11, 18,18,18,18 }

         };

  private static final int[][] mCenterMap =

         {

           { 12, 18,18,18,18,18 },

           { 13, 18,18,18,18,18 },

           { 14, 18,18,18,18,18 },

           { 15, 18,18,18,18,18 },

           { 16, 18,18,18,18,18 },

           { 17, 18,18,18,18,18 },

         };

  private static final double[][] VERTICES_CORNER = new double[][]

          {

             // TODO

          };

  private static final int[][] VERT_INDEXES_CORNER = new int[][]

          {

             // TODO

          };

  private static final double[][] VERTICES_EDGE = new double[][]

          {

             {-0.5, 0.0, 0.0},

             { 0.5, 0.0, 0.0},

             { 0.0,-0.5, 0.0},

             { 0.0, 0.0,-0.5}

          };

  private static final int[][] VERT_INDEXES_EDGE = new int[][]

          {

             {2,1,0},   // counterclockwise!

             {3,0,1},

             {2,3,1},

             {3,2,0},

          };

  private static final double[][] VERTICES_FACE = new double[][]

          {

             // TODO

          };

  private static final int[][] VERT_INDEXES_FACE = new int[][]

          {

             // TODO

          };

  private static MeshBase[] mMeshes;

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

  TwistySkewb(int size, Static4D quat, DistortedTexture texture,

              MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)

    {

    super(size, 2*size-2, quat, texture, mesh, effects, moves, ObjectList.SKEW, res, scrWidth);

    }

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

  double[][] getVertices(int cubitType)

    {

    if( cubitType==0 ) return VERTICES_CORNER;

    if( cubitType==1 ) return VERTICES_EDGE;

    if( cubitType==2 ) return VERTICES_FACE;

    return null;

    }

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

  int[][] getVertIndexes(int cubitType)

    {

    if( cubitType==0 ) return VERT_INDEXES_CORNER;

    if( cubitType==1 ) return VERT_INDEXES_EDGE;

    if( cubitType==2 ) return VERT_INDEXES_FACE;

    return null;

    }

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

  int getNumCubitTypes(int numLayers)

    {

    return numLayers==2 ? 2 : 3;

    }

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

  private int getNumCorners()

    {

    return 8;

    }

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

  private int getNumEdges(int layers)

    {

    return (layers-2)*12;

    }

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

  private int getNumCentersPerFace(int layers)

    {

    return ((layers-2)*(layers-2) + (layers-1)*(layers-1));

    }

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

  float getScreenRatio()

    {

    return 1.0f;

    }

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return 3;

    }

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

  float[] getCuts(int numLayers)

    {

    float[] cuts = new float[numLayers-1];

    switch(numLayers)

      {

      case 2: cuts[0] = 0;

              break;

      case 3: cuts[0] = -SQ3/12;

              cuts[1] = +SQ3/12;

              break;

      case 4: cuts[0] = -SQ3/9;

              cuts[1] = 0;

              cuts[2] = +SQ3/9;

              break;

      }

    return cuts;

    }

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

  int getNumCubitFaces()

    {

    return FACES_PER_CUBIT;

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    final float DIST_CORNER = (numLayers-1)*0.50f;

    final float DIST_EDGE   = (numLayers-1)*0.50f;

    final float DIST_CENTER = (numLayers-1)*0.50f;

    final int numCorners = getNumCorners();

    final int numEdges   = getNumEdges(numLayers);

    final int numCenters = 6*getNumCentersPerFace(numLayers);

    final float[][] CENTERS = new float[numCorners+numEdges+numCenters][];

    /// CORNERS //////////////////////////////////////////////

    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    CENTERS[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    /// EDGES ///////////////////////////////////////////////

    final float[][]  edgeTable =

        {

            {0,+DIST_EDGE,+DIST_EDGE},

            {+DIST_EDGE,0,+DIST_EDGE},

            {0,-DIST_EDGE,+DIST_EDGE},

            {-DIST_EDGE,0,+DIST_EDGE},

            {+DIST_EDGE,+DIST_EDGE,0},

            {+DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,+DIST_EDGE,0},

            {0,+DIST_EDGE,-DIST_EDGE},

            {+DIST_EDGE,0,-DIST_EDGE},

            {0,-DIST_EDGE,-DIST_EDGE},

            {-DIST_EDGE,0,-DIST_EDGE}

        };

    int index=8;

    for (float[] edges : edgeTable)

      {

      float c = (3-numLayers)*0.5f;

      for (int j=0; j<numLayers-2; j++, c+=1.0f, index++)

        {

        CENTERS[index] = new float[] { edges[0]==0 ? c : edges[0] ,

                                       edges[1]==0 ? c : edges[1] ,

                                       edges[2]==0 ? c : edges[2] };

        }

      }

    /// CENTERS //////////////////////////////////////////////

    final float X= -1000.0f;

    final float Y= -1001.0f;

    final float[][]  centerTable =

        {

            {+DIST_CENTER,X,Y},

            {-DIST_CENTER,X,Y},

            {X,+DIST_CENTER,Y},

            {X,-DIST_CENTER,Y},

            {X,Y,+DIST_CENTER},

            {X,Y,-DIST_CENTER}

        };

    float x,y, cen0, cen1, cen2;

    for( float[] centers : centerTable )

      {

      x = (2-numLayers)*0.5f;

      for(int i=0; i<numLayers-1; i++, x+=1.0f)

        {

        y = (2-numLayers)*0.5f;

        for(int j=0; j<numLayers-1; j++, y+=1.0f, index++)

          {

               if( centers[0]==Y ) cen0 = y;

          else if( centers[0]==X ) cen0 = x;

          else                     cen0 = centers[0];

               if( centers[1]==Y ) cen1 = y;

          else if( centers[1]==X ) cen1 = x;

          else                     cen1 = centers[1];

               if( centers[2]==Y ) cen2 = y;

          else if( centers[2]==X ) cen2 = x;

          else                     cen2 = centers[2];

          CENTERS[index] = new float[] {cen0,cen1,cen2};

          }

        }

      x = (3-numLayers)*0.5f;

      for(int i=0; i<numLayers-2; i++, x+=1.0f)

        {

        y = (3-numLayers)*0.5f;

        for(int j=0; j<numLayers-2; j++, y+=1.0f, index++)

          {

               if( centers[0]==Y ) cen0 = y;

          else if( centers[0]==X ) cen0 = x;

          else                     cen0 = centers[0];

               if( centers[1]==Y ) cen1 = y;

          else if( centers[1]==X ) cen1 = x;

          else                     cen1 = centers[1];

               if( centers[2]==Y ) cen2 = y;

          else if( centers[2]==X ) cen2 = x;

          else                     cen2 = centers[2];

          CENTERS[index] = new float[] {cen0,cen1,cen2};

          }

        }

      }

    return CENTERS;

    }

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

  private Static4D getQuat(int cubit, int numLayers)

    {

    int numCorners = getNumCorners();

    int numEdges   = getNumEdges(numLayers);

    if( cubit<numCorners )

      {

      switch(cubit)

        {

        case  0: return QUATS[0];                          //  unit quat

        case  1: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X

        case  2: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X

        case  3: return QUATS[1];                          // 180 along X

        case  4: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y

        case  5: return QUATS[2];                          // 180 along Y

        case  6: return QUATS[3];                          // 180 along Z

        case  7: return new Static4D(SQ2/2,0,-SQ2/2,0);    // 180 along (SQ2/2,0,-SQ2/2)

        }

      }

    else if( cubit<numCorners+numEdges )

      {

      int edge = (cubit-numCorners)/(numLayers-2);

      switch(edge)

        {

        case  0: return QUATS[ 0];

        case  1: return QUATS[ 5];

        case  2: return QUATS[ 3];

        case  3: return QUATS[11];

        case  4: return QUATS[ 4];

        case  5: return QUATS[ 7];

        case  6: return QUATS[ 9];

        case  7: return QUATS[10];

        case  8: return QUATS[ 2];

        case  9: return QUATS[ 8];

        case 10: return QUATS[ 1];

        case 11: return QUATS[ 6];

        }

      }

    else

      {

      int center = (cubit-numCorners-numEdges)/getNumCentersPerFace(numLayers);

      switch(center)

        {

        case 0: return new Static4D(0,-SQ2/2,0,SQ2/2);    // -90 along Y

        case 1: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y

        case 2: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X

        case 3: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X

        case 4: return QUATS[0];                          //  unit quaternion

        case 5: return QUATS[1];                          // 180 along X

        }

      }

    return null;

    }

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

  MeshBase createCubitMesh(int cubit, int numLayers)

    {

    if( mMeshes==null )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mMeshes = new MeshBase[3];

      }

    MeshBase mesh;

    int numCorners = getNumCorners();

    int numEdges   = getNumEdges(numLayers);

    if( cubit<numCorners )

      {

      if( mMeshes[0]==null )

        {

        mMeshes[0] = FactoryCubit.getInstance().createSkewbCornerMesh();

        }

      mesh = mMeshes[0].copy(true);

      }

    else if( cubit<numCorners+numEdges )

      {

      if( mMeshes[1]==null )

        {

        float[][] bands= new float[][]

          {

             {0.035f,30,0.16f,0.8f,7,2,5},

             {0.020f,45,0.16f,0.2f,3,1,2}

          };

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

        float[][] corners   = new float[][] { {0.07f,0.20f}, {0.02f,0.30f} };

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

        FactoryCubit factory = FactoryCubit.getInstance();

        factory.createNewFaceTransform(VERTICES_EDGE,VERT_INDEXES_EDGE);

        mMeshes[1] = factory.createRoundedSolid(VERTICES_EDGE, VERT_INDEXES_EDGE,

                                                bands, bandIndexes,

                                                corners, cornerIndexes,

                                                getNumCubitFaces() );

        }

      mesh = mMeshes[1].copy(true);

      }

    else

      {

      if( mMeshes[2]==null )

        {

        mMeshes[2] = FactoryCubit.getInstance().createSkewbFaceMesh();

        }

      mesh = mMeshes[2].copy(true);

      }

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );

    mesh.apply(quat,0xffffffff,0);

    return mesh;

    }

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

  int getFaceColor(int cubit, int cubitface, int numLayers)

    {

    int numCorners = getNumCorners();

    int numEdges   = getNumEdges(numLayers);

    if( cubit<numCorners )

      {

      return mCornerMap[cubit][cubitface];

      }

    else if( cubit<numCorners+numEdges )

      {

      int edge = (cubit-numCorners)/(numLayers-2);

      return mEdgeMap[edge][cubitface];

      }

    else

      {

      int center = (cubit-numCorners-numEdges)/getNumCentersPerFace(numLayers);

      return mCenterMap[center][cubitface];

      }

    }

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

  void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top)

    {

    int COLORS = FACE_COLORS.length;

    float R,S;

    float[] vertices;

    if( face<COLORS )

      {

      float E = 0.5f;

      R = 0.023f;

      S = 0.035f;

      vertices = new float[] { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};

      }

    else if( face<2*COLORS )

      {

      float E = 0.5f;

      R = 0.025f;

      S = 0.05f;

      vertices = new float[] { -E,E/3, 0,-2*E/3, +E,E/3 };

      }

    else

      {

      float E = SQ2/4;

      R = 0.055f;

      S = 0.035f;

      vertices = new float[] { -E,-E, +E,-E, +E,+E, -E,+E };

      }

    FactorySticker factory = FactorySticker.getInstance();

    factory.drawRoundedPolygon(canvas, paint, left, top, vertices, S, FACE_COLORS[face%COLORS], R);

    }

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

  float returnMultiplier()

    {

    return 2.0f;

    }

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

  float[] getRowChances(int numLayers)

    {

    float[] chances = new float[numLayers];

    switch(numLayers)

      {

      case 2: chances[0] = 0.5f;

              chances[1] = 1.0f;

              break;

      case 3: chances[0] = 0.5f;

              chances[1] = 0.5f;

              chances[2] = 1.0f;

              break;

      default:for(int i=0; i<numLayers; i++)

                {

                chances[i] = (float)(i+1)/numLayers;

                }

      }

    return chances;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int getBasicAngle()

    {

    return 3;

    }

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

  public void randomizeNewScramble(int[][] scramble, Random rnd, int num)

    {

    if( num==0 )

      {

      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);

      }

    else

      {

      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);

      scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);

      }

    float rowFloat = rnd.nextFloat();

    for(int row=0; row<mRowChances.length; row++)

      {

      if( rowFloat<=mRowChances[row] )

        {

        scramble[num][1] = row;

        break;

        }

      }

    switch( rnd.nextInt(2) )

      {

      case 0: scramble[num][2] = -1; break;

      case 1: scramble[num][2] =  1; break;

      }

    }

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

// remember about the double cover or unit quaternions!

  private int mulQuat(int q1, int q2)

    {

    Static4D result = RubikSurfaceView.quatMultiply(QUATS[q1],QUATS[q2]);

    float rX = result.get0();

    float rY = result.get1();

    float rZ = result.get2();

    float rW = result.get3();

    final float MAX_ERROR = 0.1f;

    float dX,dY,dZ,dW;

    for(int i=0; i<QUATS.length; i++)

      {

      dX = QUATS[i].get0() - rX;

      dY = QUATS[i].get1() - rY;

      dZ = QUATS[i].get2() - rZ;

      dW = QUATS[i].get3() - rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      dX = QUATS[i].get0() + rX;

      dY = QUATS[i].get1() + rY;

      dZ = QUATS[i].get2() + rZ;

      dW = QUATS[i].get3() + rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      }

    return -1;

    }

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

// The Skewb is solved if and only if:

//

// 1) all of its corner and edge cubits are rotated with the same quat

// 2) all its face cubits are rotated with the same quat like the corner ones,

//    and optionally they also might be upside down.

//

// i.e.

// cubits [ 8] and [ 9] - might be extra QUAT[1]

// cubits [10] and [11] - might be extra QUAT[2]

// cubits [12] and [13] - might be extra QUAT[3]

  public boolean isSolved()

    {

    int q = CUBITS[0].mQuatIndex;

    int numLayers      = getNumLayers();

    int numCorners     = getNumCorners();

    int numEdges       = getNumEdges(numLayers);

    int cornersAndEdges= numCorners + numEdges;

    int centersPerFace = getNumCentersPerFace(numLayers);

    int cubit, q1=q;

    for(cubit=0; cubit<cornersAndEdges; cubit++)

      {

      if( CUBITS[cubit].mQuatIndex != q ) return false;

      }

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

      {

      if( face%2==0 ) q1 = mulQuat(q, (face/2)+1);

      for(int center=0; center<centersPerFace; center++)

        {

        if( CUBITS[cubit].mQuatIndex != q && CUBITS[cubit].mQuatIndex != q1 ) return false;

        cubit++;

        }

      }

    return true;

    }

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

// only needed for solvers - there are no Skewb solvers ATM)

  public String retObjectString()

    {

    return "";

    }

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

  public int getObjectName(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.skew2;

      case 3: return R.string.skew3;

      }

    return R.string.skew2;

    }

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

  public int getInventor(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.skew2_inventor;

      case 3: return R.string.skew3_inventor;

      }

    return R.string.skew2_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return 5;

      case 3: return 9;

      }

    return 5;

    }

}