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

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyDiamond.java @ ecc01591

-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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.objectlib.objects;
-            c9c71c3f
+import static org.distorted.objectlib.touchcontrol.TouchControl.TC_OCTAHEDRON;
 import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_NOT_SPLIT;
-b82486
+            Leszek Koltunski
-eb152a
+import java.io.InputStream;
-b82486
+            Leszek Koltunski
 import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
-ee1d662
+import org.distorted.objectlib.helpers.ObjectFaceShape;
-            c9c71c3f
+import org.distorted.objectlib.touchcontrol.TouchControlOctahedron;
-e762
+import org.distorted.objectlib.main.ObjectType;
-c5bf0
+import org.distorted.objectlib.helpers.ObjectShape;
-b7e306
+import org.distorted.objectlib.scrambling.ScrambleState;
-af988
+import org.distorted.objectlib.main.ShapeOctahedron;
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-af988
+public class TwistyDiamond extends ShapeOctahedron
-b82486
+            Leszek Koltunski
   // the four rotation axis of a Diamond. Must be normalized.
   static final Static3D[] ROT_AXIS = new Static3D[]
+         {
            new Static3D(+SQ6/3,+SQ3/3,     0),
            new Static3D(-SQ6/3,+SQ3/3,     0),
            new Static3D(     0,-SQ3/3,-SQ6/3),
            new Static3D(     0,-SQ3/3,+SQ6/3)
          };
   private ScrambleState[] mStates;
   private int[] mBasicAngle;
   private float[][] mCuts;
   private int[] mTetraToFaceMap;
-ae98f0
+  private float[][] mPosition;
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-bf19410
+  public TwistyDiamond(int[] numL, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)
-b82486
+            Leszek Koltunski
-bf19410
+    super(numL, meshState, iconMode, numL[0], quat, move, scale, stream);
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            f9a81f52
+  public ScrambleState[] getScrambleStates()
-b82486
+            Leszek Koltunski
     if( mStates==null )
+      {
-            a57e6870
+      int[] numLayers = getNumLayers();
       int numL = numLayers[0];
       int[] tmp = new int[3*2*numL];
-b82486
+            Leszek Koltunski
-            a57e6870
+      for(int i=0; i<2*numL; i++)
-b82486
+            Leszek Koltunski
-            a57e6870
+        tmp[3*i  ] = (i<numL) ?  i:i-numL;
-b82486
+        tmp[3*i+1] = (i%2==0) ? -1:1;
         tmp[3*i+2] = 0;
+        }
       mStates = new ScrambleState[]
+        {
         new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} )
         };
+      }
     return mStates;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-bbfc84f
+  public float[][] getCuts(int[] numLayers)
-b82486
+            Leszek Koltunski
-            a57e6870
+    int numL = numLayers[0];
     if( numL<2 ) return null;
-b82486
+            Leszek Koltunski
     if( mCuts==null )
+      {
-            a57e6870
+      mCuts = new float[4][numL-1];
       float cut = (SQ6/6)*(2-numL);
-b82486
+            Leszek Koltunski
-            a57e6870
+      for(int i=0; i<numL-1; i++)
-b82486
+            Leszek Koltunski
         mCuts[0][i] = cut;
         mCuts[1][i] = cut;
         mCuts[2][i] = cut;
         mCuts[3][i] = cut;
         cut += SQ6/3;
+        }
+      }
     return mCuts;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-c20632
+  public boolean[][] getLayerRotatable(int[] numLayers)
-b82486
+            Leszek Koltunski
-c20632
+    int numAxis = ROT_AXIS.length;
     boolean[][] layerRotatable = new boolean[numAxis][];
-            a57e6870
+            Leszek Koltunski
-c20632
+    for(int i=0; i<numAxis; i++)
+      {
       layerRotatable[i] = new boolean[numLayers[i]];
       for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
-b82486
+            Leszek Koltunski
-c20632
+            Leszek Koltunski
     return layerRotatable;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-fa413d
+  public int getTouchControlType()
-c20632
+            Leszek Koltunski
-            c9c71c3f
+    return TC_OCTAHEDRON;
-c20632
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-fa413d
+  public int getTouchControlSplit()
-c20632
+            Leszek Koltunski
     return TYPE_NOT_SPLIT;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public int[][][] getEnabled()
+    {
     return new int[][][]
+      {
           {{1,2,3}},{{1,2,3}},{{0,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,3}},{{0,1,2}},{{0,1,2}}
       };
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public float[] getDist3D(int[] numLayers)
+    {
-c9ca251
+    return TouchControlOctahedron.D3D;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public Static3D[] getFaceAxis()
+    {
     return TouchControlOctahedron.FACE_AXIS;
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private int getNumOctahedrons(int layers)
+    {
     return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private int getNumTetrahedrons(int layers)
+    {
     return 4*layers*(layers-1);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private int createOctaPositions(float[][] centers, int index, int layers, float height)
+    {
     float x = (layers-1)*0.5f;
     float z = (layers+1)*0.5f;
     for(int i=0; i<layers; i++, index++)
+      {
       z -= 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     for(int i=0; i<layers-1; i++, index++)
+      {
       x -= 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     for(int i=0; i<layers-1; i++, index++)
+      {
       z += 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     for(int i=0; i<layers-2; i++, index++)
+      {
       x += 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     return index;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private int createTetraPositions(float[][] centers, int index, int layers, float height)
+    {
     float x = (layers-1)*0.5f;
     float z =  layers*0.5f;
     for(int i=0; i<layers-1; i++, index++)
+      {
       z -= 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     x += 0.5f;
     z -= 0.5f;
     for(int i=0; i<layers-1; i++, index++)
+      {
       x -= 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     x -= 0.5f;
     z -= 0.5f;
     for(int i=0; i<layers-1; i++, index++)
+      {
       z += 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     x -= 0.5f;
     z += 0.5f;
     for(int i=0; i<layers-1; i++, index++)
+      {
       x += 1;
       centers[index][0] = x;
       centers[index][1] = height;
       centers[index][2] = z;
+      }
     return index;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b832206
+  public float[][] getCubitPositions(int[] numLayers)
-b82486
+            Leszek Koltunski
-ae98f0
+    if( mPosition==null )
+      {
       int layers = numLayers[0];
       int numO = getNumOctahedrons(layers);
       int numT = getNumTetrahedrons(layers);
       int index = 0;
       float height = 0.0f;
-b82486
+            Leszek Koltunski
-ae98f0
+      mPosition = new float[numO+numT][3];
-b82486
+            Leszek Koltunski
-ae98f0
+      index = createOctaPositions(mPosition,index,layers,height);
-b82486
+            Leszek Koltunski
-ae98f0
+      for(int i=layers-1; i>0; i--)
+        {
         height += SQ2/2;
         index = createOctaPositions(mPosition,index,i,+height);
         index = createOctaPositions(mPosition,index,i,-height);
+        }
-b82486
+            Leszek Koltunski
-ae98f0
+      height = SQ2/4;
-b82486
+            Leszek Koltunski
-ae98f0
+      for(int i=layers; i>1; i--)
+        {
         index = createTetraPositions(mPosition,index,i,+height);
         index = createTetraPositions(mPosition,index,i,-height);
         height += SQ2/2;
+        }
-b82486
+            Leszek Koltunski
-ae98f0
+    return mPosition;
-b82486
+            Leszek Koltunski
-            d0e6cf7f
+///////////////////////////////////////////////////////////////////////////////////////////////////
   public Static4D getCubitQuats(int cubit, int[] numLayers)
+    {
     int numL = numLayers[0];
     int numO = getNumOctahedrons(numL);
-fe251
+    if( cubit<numO ) return mObjectQuats[0];
-            d0e6cf7f
+            Leszek Koltunski
     switch( retFaceTetraBelongsTo(cubit-numO, numL) )
+      {
-fe251
+      case 0: return mObjectQuats[0];                   // unit quat
-            d0e6cf7f
+      case 1: return new Static4D(0,-SQ2/2,0,SQ2/2);    //  90 along Y
-fe251
+      case 2: return mObjectQuats[10];                  // 180 along Y
-            d0e6cf7f
+      case 3: return new Static4D(0,+SQ2/2,0,SQ2/2);    //  90 along
       case 4: return new Static4D(0,     0,1,    0);    // 180 along Z
-ae98f0
+      case 5: return mObjectQuats[4];
-            d0e6cf7f
+      case 6: return new Static4D(     1,0,0,    0);    // 180 along X
-ae98f0
+      case 7: return mObjectQuats[3];
-            d0e6cf7f
+            Leszek Koltunski
     return null;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private int retFaceTetraBelongsTo(int tetra, int numLayers)
+    {
     if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4};
     for(int i=numLayers-1; i>0; i--)
+      {
       if( tetra < 8*i ) return mTetraToFaceMap[tetra/i];
       tetra -= 8*i;
+      }
     return -1;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            e30c522a
+  public ObjectShape getObjectShape(int variant)
-b82486
+            Leszek Koltunski
     if( variant==0 )
+      {
-e9f2df5
+      float[][] vertices =
-b82486
+            Leszek Koltunski
-ef6378
+             { 0.5f,  0.0f, 0.5f},
              { 0.5f,  0.0f,-0.5f},
              {-0.5f,  0.0f,-0.5f},
              {-0.5f,  0.0f, 0.5f},
              { 0.0f, SQ2/2, 0.0f},
              { 0.0f,-SQ2/2, 0.0f}
-b82486
+          };
-e9f2df5
+      int[][] indices =
-b82486
+            Leszek Koltunski
              {3,0,4},
              {0,1,4},
              {1,2,4},
              {2,3,4},
              {5,0,3},
              {5,1,0},
              {5,2,1},
              {5,3,2}
           };
-a971c1
+      return new ObjectShape(vertices, indices);
-ee1d662
+            Leszek Koltunski
     else
+      {
-e9f2df5
+      float[][] vertices= { {-0.5f, SQ2/4, 0.0f}, { 0.5f, SQ2/4, 0.0f}, { 0.0f,-SQ2/4, 0.5f}, { 0.0f,-SQ2/4,-0.5f} };
       int[][] indices   = { {2,1,0}, {2,3,1}, {3,2,0}, {3,0,1} };
-a971c1
+      return new ObjectShape(vertices, indices);
-ee1d662
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public ObjectFaceShape getObjectFaceShape(int variant)
+    {
     int numL = getNumLayers()[0];
     int N = numL>3 ? 5:6;
-e9f2df5
+    int E = numL>2 ? (numL>3 ? 0:1) : 2;
-bf19410
+    float height = isInIconMode() ? 0.001f : 0.05f;
-ee1d662
+            Leszek Koltunski
     if( variant==0 )
+      {
-bf19410
+      float[][] bands     = { {height,20,0.5f,0.8f,N,E,E} };
-e9f2df5
+      int[] bandIndices   = { 0,0,0,0,0,0,0,0 };
       float[][] corners   = { {0.04f,0.20f} };
       int[] cornerIndices = { 0,0,0,0,0,0 };
       float[][] centers   = { {0.0f, 0.0f, 0.0f} };
       int[] centerIndices = { 0,0,0,0,0,0 };
-ee1d662
+      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);
-b82486
+            Leszek Koltunski
     else
+      {
-bf19410
+      float[][] bands     = { {height,35,0.5f,0.8f,N,E,E} };
-e9f2df5
+      int[] bandIndices   = { 0,0,0,0 };
       float[][] corners   = { {0.08f,0.15f} };
       int[] cornerIndices = { 0,0,0,0 };
       float[][] centers   = { {0.0f, 0.0f, 0.0f} };
       int[] centerIndices = { 0,0,0,0 };
-ee1d662
+      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);
-b82486
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            e30c522a
+  public int getNumCubitVariants(int[] numLayers)
-b82486
+            Leszek Koltunski
     return 2;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            e30c522a
+  public int getCubitVariant(int cubit, int[] numLayers)
-b82486
+            Leszek Koltunski
-            a57e6870
+    return cubit<getNumOctahedrons(numLayers[0]) ? 0 : 1;
-b82486
+            Leszek Koltunski
-d766df3
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            d53fb890
+  public float getStickerRadius()
-d766df3
+            Leszek Koltunski
-f4980d
+    return 0.08f;
-d766df3
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            d53fb890
+  public float getStickerStroke()
-d766df3
+            Leszek Koltunski
     float stroke = 0.08f;
-bf19410
+    if( isInIconMode() )
-d766df3
+            Leszek Koltunski
       int[] numLayers = getNumLayers();
       switch(numLayers[0])
+        {
         case 2: stroke*=1.4f; break;
         case 3: stroke*=2.0f; break;
         case 4: stroke*=2.1f; break;
         default:stroke*=2.2f; break;
+        }
+      }
     return stroke;
+    }
-f4980d
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            d53fb890
+  public float[][] getStickerAngles()
-f4980d
+            Leszek Koltunski
     return null;
+    }
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
   public Static3D[] getRotationAxis()
+    {
     return ROT_AXIS;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-fe251
+  public int[] getBasicAngles()
-b82486
+            Leszek Koltunski
     if( mBasicAngle ==null ) mBasicAngle = new int[] { 3,3,3,3 };
     return mBasicAngle;
+    }
-aa85e4
+///////////////////////////////////////////////////////////////////////////////////////////////////
-f54927b
+  public String getShortName()
-aa85e4
+            Leszek Koltunski
-f54927b
+    switch(getNumLayers()[0])
+      {
       case 2: return ObjectType.DIAM_2.name();
       case 3: return ObjectType.DIAM_3.name();
       case 4: return ObjectType.DIAM_4.name();
+      }
     return ObjectType.DIAM_2.name();
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public long getSignature()
+    {
     switch(getNumLayers()[0])
-aa85e4
+            Leszek Koltunski
-f54927b
+      case 2: return ObjectType.DIAM_2.ordinal();
       case 3: return ObjectType.DIAM_3.ordinal();
       case 4: return ObjectType.DIAM_4.ordinal();
-aa85e4
+            Leszek Koltunski
-f54927b
+    return ObjectType.DIAM_2.ordinal();
-aa85e4
+            Leszek Koltunski
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            e26eb4e7
+  public String getObjectName()
-b82486
+            Leszek Koltunski
-            e26eb4e7
+    switch(getNumLayers()[0])
-b82486
+            Leszek Koltunski
-            e26eb4e7
+      case 2: return "Skewb Diamond";
       case 3: return "Face Turning Octahedron";
       case 4: return "Master Face Turning Octahedron";
-b82486
+            Leszek Koltunski
-            e26eb4e7
+    return "Skewb Diamond";
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            e26eb4e7
+  public String getInventor()
-b82486
+            Leszek Koltunski
-            e26eb4e7
+    switch(getNumLayers()[0])
-b82486
+            Leszek Koltunski
-            e26eb4e7
+      case 2: return "Uwe Meffert";
       case 3: return "David Pitcher";
       case 4: return "Timur Evbatyrov";
-b82486
+            Leszek Koltunski
-            e26eb4e7
+    return "Uwe Meffert";
-b82486
+            Leszek Koltunski
-c20632
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            e26eb4e7
+  public int getYearOfInvention()
-c20632
+            Leszek Koltunski
-            e26eb4e7
+    switch(getNumLayers()[0])
-c20632
+            Leszek Koltunski
       case 2: return 1984;
       case 3: return 2003;
       case 4: return 2011;
+      }
     return 1984;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            e26eb4e7
+  public int getComplexity()
-b82486
+            Leszek Koltunski
-            e26eb4e7
+    switch(getNumLayers()[0])
-b82486
+            Leszek Koltunski
-            b4223a92
+      case 2: return 1;
-fcf3d
+      case 3: return 3;
       case 4: return 4;
-b82486
+            Leszek Koltunski
     return 0;
+    }
-e0362
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public String[][] getTutorials()
+    {
     int[] numLayers = getNumLayers();
     switch(numLayers[0])
+      {
       case 2: return new String[][] {
                           {"gb","R2wrbJJ3izM","How to Solve a Skewb Diamond","Dr. Penguin^3"},
                           {"es","2RCusYQdYYE","Como resolver Skewb Diamond","Tutoriales Rubik"},
                           {"ru","k8B6RFcNoGw","Как собрать Skewb Diamond","Алексей Ярыгин"},
                           {"fr","tqbkgwNcZCE","Comment résoudre le Skewb Diamond","Valentino Cube"},
                           {"de","6ewzrCOnZfg","Octagon lösen","JamesKnopf"},
                           {"pl","61_Z4TpLMBc","Diamond Skewb TUTORIAL PL","MrUk"},
                           {"br","UapwpXMYtH4","Como resolver o Octaedro Diamond","Rafael Cinoto"},
                           {"kr","hVBSlfHVTME","공식 하나만 사용 - 다이아몬드 스큐브","Denzel Washington"},
                          };
       case 3: return new String[][] {
                           {"gb","n_mBSUDLUZw","Face Turning Octahedron Tutorial","SuperAntoniovivaldi"},
                           {"es","ogf0t6fGxZI","FTO - Tutorial en español","Gadi Rubik"},
                           {"ru","VXCjk0bVRoA","Как собрать Face Turning Octahedron","Алексей Ярыгин"},
                           {"de","6bO0AcwY5K8","Face Turning Octahedron - Tutorial","GerCubing"},
                           {"pl","huWg-ZfP-KY","Octahedron cube TUTORIAL PL","MrUk"},
                           {"br","WN3BoP4EbvM","Como resolver o octaedro 3x3 1/3","Rafael Cinoto"},
                           {"br","4zFlfANOliE","Como resolver o octaedro 3x3 2/3","Rafael Cinoto"},
                           {"br","6OvNzoHk7RU","Como resolver o octaedro 3x3 3/3","Rafael Cinoto"},
-            a399e91b
+                          {"vn","KzGQ-mVRsss","Tutorial N.43 - FTO","Duy Thích Rubik"},
-e0362
+                         };
       case 4: return new String[][] {
                           {"gb","3GJkySk5zeQ","Master Face Turning Octahedron","SuperAntoniovivaldi"},
                           {"gb","zW_1htxy52k","Master FTO Tutorial","Michele Regano"},
                           {"es","3K8XL9SBSvs","Tutorial Master FTO de Mf8","Robert Cubes"},
                           {"ru","0CRwhZ2JNJA","Как собрать Master FTO","Алексей Ярыгин"},
-            a399e91b
+                          {"vn","4XdeuGYDCJo","Tutorial N.141 - Master FTO","Duy Thích Rubik"},
-e0362
+                         };
+      }
     return null;
+    }
-b82486
+            Leszek Koltunski

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyDiamond.java @ ecc01591