/src/main/java/org/distorted/objectlib/objects/TwistyIcosamate.java - Annotate - TwistyPuzzleLib - Distorted Android

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyIcosamate.java @ 52375039

-            d54d1f8a
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // Copyright 2023 Leszek Koltunski                                                               //
 //                                                                                               //
 // This file is part of Magic Cube.                                                              //
 //                                                                                               //
 // Magic Cube is proprietary software licensed under an EULA which you should have received      //
 // along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 package org.distorted.objectlib.objects;
 import static org.distorted.objectlib.touchcontrol.TouchControl.TC_ICOSAHEDRON;
 import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_NOT_SPLIT;
-            eeabbae3
+import static org.distorted.objectlib.touchcontrol.TouchControlIcosahedron.*;
-            d54d1f8a
+            Leszek Koltunski
 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;
-            ae9d9227
+import org.distorted.objectlib.metadata.Metadata;
-            d54d1f8a
+import org.distorted.objectlib.helpers.ObjectVertexEffects;
 import org.distorted.objectlib.main.InitAssets;
-fd0de
+import org.distorted.objectlib.metadata.ListObjects;
-            d54d1f8a
+import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;
-cd919
+import org.distorted.objectlib.shape.ShapeIcosahedron;
-            d54d1f8a
+import org.distorted.objectlib.touchcontrol.TouchControlIcosahedron;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-cd919
+public class TwistyIcosamate extends ShapeIcosahedron
-            d54d1f8a
+            Leszek Koltunski
   static final Static3D[] ROT_AXIS = new Static3D[]
+         {
-            eeabbae3
+           new Static3D(                   0,                   1,                   0),
            new Static3D(                   0, VEC[1][1]/VEC[0][1], VEC[1][2]/VEC[0][1]),
            new Static3D( VEC[2][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[2][2]/VEC[0][1]),
            new Static3D( VEC[3][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[3][2]/VEC[0][1]),
            new Static3D(-VEC[3][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[3][2]/VEC[0][1]),
            new Static3D(-VEC[2][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[2][2]/VEC[0][1])
-            d54d1f8a
+         };
   private int[][] mEdges;
   private int[][] mBasicAngle;
   private float[][] mCuts;
   private float[][] mPosition;
-f5517
+  private int[] mQuatIndex;
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            ae9d9227
+  public TwistyIcosamate(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)
-            d54d1f8a
+            Leszek Koltunski
-            ae9d9227
+    super(iconMode, meta.getNumLayers()[0], quat, move, scale, meta, asset);
-            d54d1f8a
+            Leszek Koltunski
-            eeabbae3
+///////////////////////////////////////////////////////////////////////////////////////////////////
   @Override
   public int getInternalColor()
+    {
     return 0xff222222;
+    }
-            d54d1f8a
+///////////////////////////////////////////////////////////////////////////////////////////////////
   public int[][] getScrambleEdges()
+    {
     if( mEdges==null )
+      {
       int[][] basicAngle = getBasicAngles();
       mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(basicAngle);
+      }
     return mEdges;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public float[][] getCuts(int[] numLayers)
+    {
     if( mCuts==null )
+      {
-            eeabbae3
+      int nL = numLayers[0];
       float[] cut = new float[nL-1];
       for(int i=0; i<nL-1; i++) cut[i] = VEC[1][1]*(2*i+2-nL);
-            d54d1f8a
+      mCuts = new float[][] { cut,cut,cut,cut,cut,cut };
+      }
     return mCuts;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public boolean[][] getLayerRotatable(int[] numLayers)
+    {
-a2182df
+    int nL = numLayers[0];
     boolean[] tmp = new boolean[nL];
     for(int i=0; i<nL; i++) tmp[i] = true;
-            d54d1f8a
+    return new boolean[][] { tmp,tmp,tmp,tmp,tmp,tmp };
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int getTouchControlType()
+    {
     return TC_ICOSAHEDRON;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int getTouchControlSplit()
+    {
     return TYPE_NOT_SPLIT;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int[][][] getEnabled()
+    {
     return new int[][][]
+      {
           {{3,4,5}}, {{1,4,5}}, {{1,2,5}}, {{1,2,3}}, {{2,3,4}},
           {{0,2,5}}, {{0,1,3}}, {{0,2,4}}, {{0,3,5}}, {{0,1,4}},
           {{0,2,5}}, {{0,1,3}}, {{0,2,4}}, {{0,3,5}}, {{0,1,4}},
           {{3,4,5}}, {{1,4,5}}, {{1,2,5}}, {{1,2,3}}, {{2,3,4}},
       };
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public float[] getDist3D(int[] numLayers)
+    {
     return TouchControlIcosahedron.D3D;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public Static3D[] getFaceAxis()
+    {
     return TouchControlIcosahedron.FACE_AXIS;
+    }
-            eeabbae3
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private float[] computeOff(int index, int N)
+    {
     if( N==2 )
+      {
       return new float[] {0,0,0};
+      }
     else
+      {
       switch(index)
+        {
         case 0 : return new float[] {0,SQ3/9,0};
         case 1 : return new float[] {-1.0f/6,-SQ3/18,0};
         default: return new float[] { 1.0f/6,-SQ3/18,0};
+        }
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Rodrigues
   private void rotateVect(float vx, float vy, float vz, float sin, float cos, float[] vec)
+    {
     float cx = vy*vec[2] - vz*vec[1];
     float cy = vz*vec[0] - vx*vec[2];
     float cz = vx*vec[1] - vy*vec[0];
     float scalar = vx*vec[0] + vy*vec[1] + vz*vec[2];
     vec[0] = vec[0]*cos + cx*sin + vx*scalar*(1-cos);
     vec[1] = vec[1]*cos + cy*sin + vy*scalar*(1-cos);
     vec[2] = vec[2]*cos + cz*sin + vz*scalar*(1-cos);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void rotateFacePosition(float x, float y, float z, float[] off)
+    {
     float cosB = (float)Math.sqrt(x*x+z*z);
     float sinB = y;
     float sinA = x/cosB;
     float cosA = z/cosB;
     float vec1X = 0;
     float vec1Y = 1;
     float vec1Z = 0;
     float vec2X = -z/cosB;
     float vec2Y = 0;
     float vec2Z = x/cosB;
     rotateVect(vec1X,vec1Y,vec1Z,sinA,cosA,off);
     rotateVect(vec2X,vec2Y,vec2Z,sinB,cosB,off);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float[] createFacePosition(float vx, float vy, float vz, float scale, boolean inverted, float[] off)
+    {
     float[] tmp = new float[3];
     tmp[0] = off[0];
     tmp[1] = off[1];
     tmp[2] = off[2];
     rotateFacePosition(vx,vy,vz,tmp);
     if( inverted )
+      {
       tmp[0] = -tmp[0];
       tmp[1] = -tmp[1];
       tmp[2] = -tmp[2];
+      }
     float[] ret = new float[3];
     ret[0] = scale*(vx+tmp[0]);
     ret[1] = scale*(vy+tmp[1]);
     ret[2] = scale*(vz+tmp[2]);
     return ret;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float[] createEdgePosition(int edge, int index, int N)
+    {
     int[] edgeIndices = EDGE_INDICES[edge];
     int i0 = edgeIndices[0];
     int i1 = edgeIndices[1];
-a6303d
+    float x = N*(VEC[i0][0]+VEC[i1][0])/2;
     float y = N*(VEC[i0][1]+VEC[i1][1])/2;
     float z = N*(VEC[i0][2]+VEC[i1][2])/2;
-            eeabbae3
+            Leszek Koltunski
     return new float[] { x,y,z };
+    }
-            d54d1f8a
+///////////////////////////////////////////////////////////////////////////////////////////////////
   public float[][] getCubitPositions(int[] numLayers)
+    {
     if( mPosition==null )
+      {
-            eeabbae3
+      int N = numLayers[0];
       int numV = 12;
       int perF = N*(N-1)/2;
       int numF = 20*perF;
       int perE = N-2;
       int numE = 30*perE;
       mPosition = new float[numV+numF+numE][];
       for(int v=0; v<12; v++)
         mPosition[v] = new float[] { VEC[v][0]*N, VEC[v][1]*N, VEC[v][2]*N };
       float[][] off = new float[perF][];
       for(int i=0; i<perF; i++) off[i] = computeOff(i,N);
       for(int f=0; f<20; f++)
+        {
         Static3D vect = TouchControlIcosahedron.FACE_AXIS[f];
         float x = vect.get0();
         float y = vect.get1();
         float z = vect.get2();
         boolean inverted = f>=10;
         for(int i=0; i<perF; i++)
           mPosition[12+f*perF+i] = createFacePosition(x,y,z,DIST3D*N,inverted,off[i]);
+        }
       for(int e=0; e<30; e++)
         for(int i=0; i<perE; i++)
           mPosition[12+20*perF+e*perE+i] = createEdgePosition(e,i,N);
-            d54d1f8a
+            Leszek Koltunski
     return mPosition;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public Static4D getCubitQuats(int cubit, int[] numLayers)
+    {
-f5517
+    if( mQuatIndex==null )
+      {
-            eeabbae3
+      switch( numLayers[0] )
-f5517
+            Leszek Koltunski
-            eeabbae3
+        case 2: mQuatIndex = new int[]
+                  {
 ,12,5,9,13,8,14,18,7,6,10,55,
 ,4,3,2,1,
 ,11,32,14,26,
 ,27,7,5,10,
 ,18,45,33,15
                   };
                 break;
         case 3: mQuatIndex = new int[]
+                  {
 ,12,5,9,13,8,14,18,7,6,10,55,
 ,52,28,4,44,9,3,31,24,2,13,51,1,8,42,
 ,30,6,16,11,49,54,32,39,48,14,23,37,43,26,
 ,50,46,27,40,34,7,25,17,29,5,12,10,20,53,
 ,38,35,58,22,18,57,47,45,55,36,33,59,19,15,
 ,4,3,2,1,
 ,20,31,13,8,
 ,16,49,10,39,41,23,27,17,7,
 ,22,30,11,19,
 ,18,45,33,15
                   };
                 break;
+        }
-f5517
+            Leszek Koltunski
     return mObjectQuats[mQuatIndex[cubit]];
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float[][] getVertices(int variant)
+    {
-            eeabbae3
+    float N = getNumLayers()[0];
-            d54d1f8a
+    if( variant==0 )
+      {
-            eeabbae3
+      float[] pos = mPosition[0];
       float[][] ret = new float[7][];
       for(int i=0; i<6; i++) ret[i] = new float[] { VEC[i][0]-pos[0], VEC[i][1]+(N-1)*VEC[0][1]-pos[1], VEC[i][2]-pos[2] };
       ret[6] = new float[] { -pos[0], -pos[1], -pos[2] };
       return ret;
+      }
     else if( variant==1 )
+      {
       float CX = mPosition[12][0];
       float CY = mPosition[12][1];
       float CZ = mPosition[12][2];
       float v1x = VEC[0][0]*(N-1)+VEC[2][0]; float v1y = VEC[0][1]*(N-1)+          VEC[2][1]; float v1z = VEC[0][2]*(N-1)+VEC[2][2];
       float v2x = VEC[2][0];                 float v2y = VEC[0][1]*(N-2)+VEC[1][1]+VEC[2][1]; float v2z = VEC[1][2]+VEC[2][2];
       float v3x = VEC[0][0]*(N-1)+VEC[1][0]; float v3y = VEC[0][1]*(N-1)+VEC[1][1]          ; float v3z = VEC[0][2]*(N-1)+VEC[1][2];
       return new float[][] { { v1x-CX, v1y-CY, v1z-CZ },
                              { v2x-CX, v2y-CY, v2z-CZ },
                              { v3x-CX, v3y-CY, v3z-CZ },
                              {    -CX,    -CY,    -CZ }
                            };
-            d54d1f8a
+            Leszek Koltunski
     else
+      {
-            eeabbae3
+      float[] pos = mPosition[72];
       float v1x = N*(VEC[0][0] + VEC[0][0] + VEC[1][0])/3; float v1y = N*(VEC[0][1] + VEC[0][1] + VEC[1][1])/3; float v1z = N*(VEC[0][2] + VEC[0][2] + VEC[1][2])/3;
       float v2x = N*(VEC[0][0] + VEC[1][0] + VEC[1][0])/3; float v2y = N*(VEC[0][1] + VEC[1][1] + VEC[1][1])/3; float v2z = N*(VEC[0][2] + VEC[1][2] + VEC[1][2])/3;
       float v3x = N*(VEC[0][0] + VEC[1][0] + VEC[2][0])/3; float v3y = N*(VEC[0][1] + VEC[1][1] + VEC[2][1])/3; float v3z = N*(VEC[0][2] + VEC[1][2] + VEC[2][2])/3;
       float v4x =-N*(VEC[0][0] + VEC[1][0] + VEC[2][0])/3; float v4y = N*(VEC[0][1] + VEC[1][1] + VEC[2][1])/3; float v4z = N*(VEC[0][2] + VEC[1][2] + VEC[2][2])/3;
       return new float[][] { { v1x-pos[0], v1y-pos[1], v1z-pos[2] },
                              { v2x-pos[0], v2y-pos[1], v2z-pos[2] },
                              { v3x-pos[0], v3y-pos[1], v3z-pos[2] },
                              { v4x-pos[0], v4y-pos[1], v4z-pos[2] },
                              {    -pos[0],    -pos[1],    -pos[2] }
-f5517
+                           };
-            d54d1f8a
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public ObjectShape getObjectShape(int variant)
+    {
     if( variant==0 )
+      {
       int[][] indices =
+          {
               {1,2,0},{2,3,0},{3,4,0},{4,5,0},{5,1,0}, {6,2,1},{6,3,2},{6,4,3},{6,5,4},{6,1,5}
           };
       return new ObjectShape(getVertices(variant), indices);
+      }
-            eeabbae3
+    else if( variant==1 )
-            d54d1f8a
+            Leszek Koltunski
       int[][] indices =
+          {
               {0,2,1},{0,1,3},{2,0,3},{1,2,3}
           };
-            eeabbae3
+      return new ObjectShape(getVertices(variant), indices);
+      }
     else
+      {
       int[][] indices =
+          {
               {0,1,2},{0,3,1},{4,2,1},{4,0,2},{4,3,0},{4,1,3}
           };
-            d54d1f8a
+      return new ObjectShape(getVertices(variant), indices);
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public ObjectFaceShape getObjectFaceShape(int variant)
+    {
-a6303d
+    float N = getNumLayers()[0];
-f6cc1
+    int angle = 25;
     float R = 0.7f;
     float S = 0.5f;
-a6303d
+            Leszek Koltunski
-            d54d1f8a
+    if( variant==0 )
+      {
-a6303d
+      int N1 = N==2 ? 5:4;
       int N2 = N==2 ? 3:2;
-            d54d1f8a
+      float h1 = isInIconMode() ? 0.001f : 0.04f;
       float h2 = 0.001f;
-f6cc1
+      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };
-            d54d1f8a
+      int[] indices   = { 0,0,0,0,0, 1,1,1,1,1,1 };
       return new ObjectFaceShape(bands,indices,null);
+      }
-            eeabbae3
+    else if( variant==1 )
-            d54d1f8a
+            Leszek Koltunski
-a6303d
+      int N1 = N==2 ? 5:4;
       int N2 = N==2 ? 3:2;
-            d54d1f8a
+      float h1 = isInIconMode() ? 0.001f : 0.04f;
       float h2 = 0.001f;
-f6cc1
+      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };
-            d54d1f8a
+      int[] indices   = { 0,1,1,1 };
       return new ObjectFaceShape(bands,indices,null);
+      }
-            eeabbae3
+    else
+      {
-a6303d
+      int N1 = N==2 ? 5:4;
       int N2 = N==2 ? 3:2;
-            eeabbae3
+      float h1 = isInIconMode() ? 0.001f : 0.04f;
       float h2 = 0.001f;
-f6cc1
+      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };
-            eeabbae3
+      int[] indices   = { 0,0,1,1,1,1 };
       return new ObjectFaceShape(bands,indices,null);
+      }
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public ObjectVertexEffects getVertexEffects(int variant)
+    {
     if( variant==0 )
+      {
-            eeabbae3
+      float[] pos = mPosition[0];
-            d54d1f8a
+      float[][] corners  = { {0.04f,0.12f},{0.04f,0.10f} };
       int[] cornerIndices= { 0,1,1,1,1,1,-1 };
-            eeabbae3
+      float[][] centers = { { -pos[0]/2, -pos[1]/2, -pos[2]/2} };
-            d54d1f8a
+      int[] centerIndices= { 0,0,0,0,0,0,-1 };
       return FactoryCubit.generateVertexEffect(getVertices(variant),corners,cornerIndices,centers,centerIndices);
+      }
-            eeabbae3
+    else if( variant==1 )
-            d54d1f8a
+            Leszek Koltunski
-            eeabbae3
+      float[] pos = mPosition[12];
-            d54d1f8a
+      float[][] corners = { {0.04f,0.15f} };
       int[] indices     = { 0,0,0,-1 };
-            eeabbae3
+      float[][] centers = { { -pos[0]/2, -pos[1]/2, -pos[2]/2} };
       return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
+      }
     else
+      {
       float[] pos = mPosition[72];
       float[][] corners = { {0.04f,0.15f} };
       int[] indices     = { 0,0,0,0,-1 };
       float[][] centers = { { -pos[0]/2, -pos[1]/2, -pos[2]/2} };
-            d54d1f8a
+      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int getNumCubitVariants(int[] numLayers)
+    {
-a2182df
+    return getNumLayers()[0]==2 ? 2 : 3;
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int getCubitVariant(int cubit, int[] numLayers)
+    {
-a2182df
+    int N = getNumLayers()[0];
     return cubit<12 ? 0 : (cubit<10*N*(N-1)+12 ? 1 : 2);
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public float getStickerRadius()
+    {
     return 0.09f;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public float getStickerStroke()
+    {
-            eb4fe652
+    return isInIconMode() ? 0.14f : 0.09f;
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            ebe8c08e
+  public float[][][] getStickerAngles()
-            d54d1f8a
+            Leszek Koltunski
     return null;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
   public Static3D[] getRotationAxis()
+    {
     return ROT_AXIS;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int[][] getBasicAngles()
+    {
     if( mBasicAngle==null )
+      {
       int num = getNumLayers()[0];
       int[] tmp = new int[num];
       for(int i=0; i<num; i++) tmp[i] = 5;
       mBasicAngle = new int[][] { tmp,tmp,tmp,tmp,tmp,tmp };
+      }
     return mBasicAngle;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public String getShortName()
+    {
-a2182df
+    switch(getNumLayers()[0])
+      {
-fd0de
+      case 2: return ListObjects.ICOS_2.name();
       case 3: return ListObjects.ICOS_3.name();
-a2182df
+            Leszek Koltunski
     return null;
-            d54d1f8a
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public String[][] getTutorials()
+    {
-a2182df
+    int[] numLayers = getNumLayers();
     switch(numLayers[0])
+      {
       case 2: return new String[][] {
-            d54d1f8a
+                            {"gb","e7Es4Zx6Sl4","Icosamate introduction & algorithms","Superantoniovivaldi"},
                             {"gb","ZhkklbYfs98","Icosamate solve","Superantoniovivaldi"},
                             {"pl","eJTLTeoicWI","Icosamate TUTORIAL PL","MrUK"},
                             {"vn","RVjjxj9rPeg","BẠN PHẠM BẢO GIẢI ICOSAMATE","VĂN CÔNG TÙNG"},
                           };
-a2182df
+      case 3: return new String[][] {
                             {"gb","77aBjBdfA2Q","Master Icosamate Algorithms","Superantoniovivaldi"},
                             {"gb","j6AIwlIofFU","Master Icosamate Tutorial","Superantoniovivaldi"},
                             {"gb","5Z1B5r6-CxM","Astrominx Tutorial","Jabberwock Technologies"},
                             {"pl","","Icosamate TUTORIAL PL","MrUK"},
                             {"vn","C4YO0B4rgTc","Tutorial N.237- Master Icosamate 1/3","Duy Thích Rubik"},
                             {"vn","90m_0AoyOHU","Tutorial N.237- Master Icosamate 2/3","Duy Thích Rubik"},
                             {"vn","LOd5qBwoP_k","Tutorial N.237- Master Icosamate 3/3","Duy Thích Rubik"},
                           };
+      }
     return null;
-            d54d1f8a
+            Leszek Koltunski
+}

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyIcosamate.java @ 52375039