commit bdbbb4c574bc6a5457e98c7dc56f26ccc040629b Author: Leszek Koltunski Date: Tue Sep 28 23:47:32 2021 +0200 Refactoring: split the 'objects' package into two, 'objects' and 'objectlib'. The point: we're going to need to move the 'objectlib' stuff into its own library module, and that's because we're going to create a new app module which needs access to it. diff --git a/build.gradle b/build.gradle index ea31ffe0..acbc5977 100644 --- a/build.gradle +++ b/build.gradle @@ -37,7 +37,7 @@ dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation 'com.google.firebase:firebase-analytics:19.0.1' implementation 'com.google.firebase:firebase-crashlytics:18.2.1' - implementation 'com.google.android.play:core:1.10.1' + implementation 'com.google.android.play:core:1.10.2' api project(':distorted-library') implementation 'androidx.appcompat:appcompat:1.3.1' diff --git a/src/main/java/org/distorted/control/RubikControl.java b/src/main/java/org/distorted/control/RubikControl.java index 87ae6b5c..6e9b67c5 100644 --- a/src/main/java/org/distorted/control/RubikControl.java +++ b/src/main/java/org/distorted/control/RubikControl.java @@ -26,7 +26,7 @@ import org.distorted.library.message.EffectListener; import org.distorted.library.type.Static4D; import org.distorted.main.RubikActivity; import org.distorted.main.RubikSurfaceView; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import java.lang.ref.WeakReference; diff --git a/src/main/java/org/distorted/control/RubikControlRotate.java b/src/main/java/org/distorted/control/RubikControlRotate.java index 9638439c..b1d3a122 100644 --- a/src/main/java/org/distorted/control/RubikControlRotate.java +++ b/src/main/java/org/distorted/control/RubikControlRotate.java @@ -22,7 +22,7 @@ package org.distorted.control; import android.graphics.Bitmap; import android.graphics.BitmapFactory; -import org.distorted.helpers.QuatHelper; +import org.distorted.objectlb.QuatHelper; import org.distorted.library.effect.MatrixEffectQuaternion; import org.distorted.library.effect.MatrixEffectScale; import org.distorted.library.main.DistortedEffects; @@ -38,7 +38,7 @@ import org.distorted.library.type.Static3D; import org.distorted.library.type.Static4D; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import java.io.IOException; import java.io.InputStream; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java index 517867ef..4fb1f77f 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java @@ -37,7 +37,7 @@ import android.widget.TextView; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.network.RubikScores; import org.distorted.screens.ScreenList; import org.distorted.screens.RubikScreenPlay; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPattern.java b/src/main/java/org/distorted/dialogs/RubikDialogPattern.java index 2aeacd9a..c2a35ee9 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPattern.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPattern.java @@ -41,7 +41,7 @@ import android.widget.TextView; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.patterns.RubikPatternList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java index 3cfe697a..91accccd 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java @@ -28,7 +28,7 @@ import android.widget.FrameLayout; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.patterns.RubikPattern; import org.distorted.patterns.RubikPatternList; import org.distorted.screens.ScreenList; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScores.java b/src/main/java/org/distorted/dialogs/RubikDialogScores.java index 19969863..28390de8 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScores.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScores.java @@ -34,14 +34,13 @@ import android.util.TypedValue; import android.view.LayoutInflater; import android.view.View; import android.view.Window; -import android.view.WindowManager; import android.widget.Button; import android.widget.ImageView; import android.widget.TextView; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java index ccb599bc..a01f4537 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java @@ -33,7 +33,7 @@ import android.widget.LinearLayout; import org.distorted.main.R; import org.distorted.network.RubikScores; import org.distorted.network.RubikNetwork; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.screens.RubikScreenPlay; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java b/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java index ff6f326a..b8aaa36a 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java @@ -33,7 +33,7 @@ import android.widget.TextView; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.network.RubikScores; import static org.distorted.network.RubikNetwork.MAX_PLACES; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogSetName.java b/src/main/java/org/distorted/dialogs/RubikDialogSetName.java index 6b0b1e77..0c5c9536 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogSetName.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogSetName.java @@ -40,7 +40,7 @@ import android.widget.TextView; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.network.RubikScores; import org.distorted.screens.ScreenList; import org.distorted.screens.RubikScreenPlay; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java index b0d544ab..379a57be 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java @@ -38,7 +38,7 @@ import com.google.firebase.analytics.FirebaseAnalytics; import org.distorted.main.BuildConfig; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.tutorials.TutorialList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/EffectController.java b/src/main/java/org/distorted/effects/EffectController.java index 856dc46b..85639f07 100644 --- a/src/main/java/org/distorted/effects/EffectController.java +++ b/src/main/java/org/distorted/effects/EffectController.java @@ -21,7 +21,7 @@ package org.distorted.effects; import org.distorted.helpers.MovesFinished; import org.distorted.library.message.EffectListener; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java b/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java index bb3dfacf..9041decf 100644 --- a/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java +++ b/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java @@ -25,7 +25,7 @@ import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedScreen; import org.distorted.library.message.EffectListener; import org.distorted.effects.EffectController; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import java.lang.reflect.Method; diff --git a/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java b/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java index 909da589..155853fd 100644 --- a/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java +++ b/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java @@ -26,8 +26,8 @@ import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedScreen; import org.distorted.library.message.EffectListener; import org.distorted.effects.EffectController; -import org.distorted.objects.ObjectList; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.ObjectList; +import org.distorted.objectlb.TwistyObject; import java.lang.reflect.Method; import java.util.Random; diff --git a/src/main/java/org/distorted/effects/solve/SolveEffect.java b/src/main/java/org/distorted/effects/solve/SolveEffect.java index ed2f1d4e..14752d48 100644 --- a/src/main/java/org/distorted/effects/solve/SolveEffect.java +++ b/src/main/java/org/distorted/effects/solve/SolveEffect.java @@ -25,7 +25,7 @@ import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedScreen; import org.distorted.library.message.EffectListener; import org.distorted.effects.EffectController; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import java.lang.reflect.Method; diff --git a/src/main/java/org/distorted/effects/win/WinEffect.java b/src/main/java/org/distorted/effects/win/WinEffect.java index b65565e3..6f06e5d7 100644 --- a/src/main/java/org/distorted/effects/win/WinEffect.java +++ b/src/main/java/org/distorted/effects/win/WinEffect.java @@ -25,7 +25,7 @@ import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedScreen; import org.distorted.library.message.EffectListener; import org.distorted.effects.EffectController; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import java.lang.reflect.Method; diff --git a/src/main/java/org/distorted/helpers/FactoryCubit.java b/src/main/java/org/distorted/helpers/FactoryCubit.java deleted file mode 100644 index 2a1ae53a..00000000 --- a/src/main/java/org/distorted/helpers/FactoryCubit.java +++ /dev/null @@ -1,940 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -import org.distorted.library.effect.MatrixEffectMove; -import org.distorted.library.effect.MatrixEffectQuaternion; -import org.distorted.library.effect.MatrixEffectScale; -import org.distorted.library.effect.VertexEffect; -import org.distorted.library.effect.VertexEffectDeform; -import org.distorted.library.mesh.MeshBase; -import org.distorted.library.mesh.MeshJoined; -import org.distorted.library.mesh.MeshPolygon; -import org.distorted.library.type.Static1D; -import org.distorted.library.type.Static3D; -import org.distorted.library.type.Static4D; - -import java.util.ArrayList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class FactoryCubit - { - private static final Static1D RADIUS = new Static1D(1); - private static FactoryCubit mThis; - - private static final double[] mBuffer = new double[3]; - private static final double[] mQuat1 = new double[4]; - private static final double[] mQuat2 = new double[4]; - private static final double[] mQuat3 = new double[4]; - private static final double[] mQuat4 = new double[4]; - - private static class StickerCoords - { - double[] vertices; - } - - private static class FaceTransform - { - int sticker; - double vx,vy,vz; - double scale; - double qx,qy,qz,qw; - boolean flip; - } - - private static final ArrayList mNewFaceTransf = new ArrayList<>(); - private static final ArrayList mOldFaceTransf = new ArrayList<>(); - private static final ArrayList mStickerCoords = new ArrayList<>(); - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private FactoryCubit() - { - - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static FactoryCubit getInstance() - { - if( mThis==null ) mThis = new FactoryCubit(); - - return mThis; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// H - height of the band in the middle -// alpha - angle of the edge [0,90] -// dist - often in a polygon the distance from edge to center is not 1, but something else. -// This is the distance. -// K - where to begin the second, much more flat part of the band. [0,1] -// N - number of bands. N>=3 -// -// theory: two distinct parts to the band: -// 1) (0,B) - steep -// 2) (B,1) - flat -// -// In first part, we have y = g(x) ; in second - y = g(f(x)) where -// -// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha) -// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B) -// h(x) = R*(sin(alpha) - sin(x)) -// R = H/(1-cos(alpha)) -// D = H*sin(alpha) -// B = h(K*alpha) -// -// The N points are taken at: -// -// 1) in the second part, there are K2 = (N-3)/3 such points -// 2) in the first - K1 = (N-3) - K2 -// 3) also, the 3 points 0,B,1 -// -// so we have the sequence A[i] of N points -// -// 0 -// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1) -// B -// (1-B)*(i+1)/(K2+1) + B (i=0,i,...,K2-1) -// 1 - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float f(float D, float B, float x) - { - return ((D-B)*x + B*(1-D))/(1-B); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float g(float R, float D, float x, float cosAlpha) - { - float d = x-D; - return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float h(float R, float sinAlpha, float x) - { - return R*(sinAlpha-(float)Math.sin(x)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean areColinear(double[][] vertices, int index1, int index2, int index3) - { - double x1 = vertices[index1][0]; - double y1 = vertices[index1][1]; - double z1 = vertices[index1][2]; - double x2 = vertices[index2][0]; - double y2 = vertices[index2][1]; - double z2 = vertices[index2][2]; - double x3 = vertices[index3][0]; - double y3 = vertices[index3][1]; - double z3 = vertices[index3][2]; - - double v1x = x2-x1; - double v1y = y2-y1; - double v1z = z2-z1; - double v2x = x3-x1; - double v2y = y3-y1; - double v2z = z3-z1; - - double A = Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) ); - - return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void computeNormalVector(double[][] vertices, int index1, int index2, int index3) - { - double x1 = vertices[index1][0]; - double y1 = vertices[index1][1]; - double z1 = vertices[index1][2]; - double x2 = vertices[index2][0]; - double y2 = vertices[index2][1]; - double z2 = vertices[index2][2]; - double x3 = vertices[index3][0]; - double y3 = vertices[index3][1]; - double z3 = vertices[index3][2]; - - double v1x = x2-x1; - double v1y = y2-y1; - double v1z = z2-z1; - double v2x = x3-x1; - double v2y = y3-y1; - double v2z = z3-z1; - - mBuffer[0] = v1y*v2z - v2y*v1z; - mBuffer[1] = v1z*v2x - v2z*v1x; - mBuffer[2] = v1x*v2y - v2x*v1y; - - double len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2]; - len = Math.sqrt(len); - mBuffer[0] /= len; - mBuffer[1] /= len; - mBuffer[2] /= len; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// return quat1*quat2 - - private static void quatMultiply( double[] quat1, double[] quat2, double[] result ) - { - double qx = quat1[0]; - double qy = quat1[1]; - double qz = quat1[2]; - double qw = quat1[3]; - - double rx = quat2[0]; - double ry = quat2[1]; - double rz = quat2[2]; - double rw = quat2[3]; - - result[0] = rw*qx - rz*qy + ry*qz + rx*qw; - result[1] = rw*qy + rz*qx + ry*qw - rx*qz; - result[2] = rw*qz + rz*qw - ry*qx + rx*qy; - result[3] = rw*qw - rz*qz - ry*qy - rx*qx; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void fitInSquare(FaceTransform info, double[][] vert3D) - { - double minX = Double.MAX_VALUE; - double maxX =-Double.MAX_VALUE; - double minY = Double.MAX_VALUE; - double maxY =-Double.MAX_VALUE; - - for (double[] vert : vert3D) - { - double x = vert[0]; - double y = vert[1]; - - if (x > maxX) maxX = x; - if (x < minX) minX = x; - if (y > maxY) maxY = y; - if (y < minY) minY = y; - } - - minX = minX<0 ? -minX:minX; - maxX = maxX<0 ? -maxX:maxX; - minY = minY<0 ? -minY:minY; - maxY = maxY<0 ? -maxY:maxY; - - double max1 = Math.max(minX,minY); - double max2 = Math.max(maxX,maxY); - double max3 = Math.max(max1,max2); - - info.scale = max3/0.5; - - int len = vert3D.length; - StickerCoords sInfo = new StickerCoords(); - sInfo.vertices = new double[2*len]; - - for( int vertex=0; vertex=len ) v-=len; - if( v< 0 ) v+=len; - - return v; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted) - { - int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted); - double EPSILON = 0.001; - double scale = computeScale(newVert,oldVert,newZeroIndex,0); - - for(int i=1; iEPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false; - } - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void mirrorAllVertices(double[] output, int len, double[] input) - { - for(int vertex=0; vertex=0 ) - { - center.set( centers[cent][0], centers[cent][1], centers[cent][2]); - - int corn = cornerIndexes[v]; - - if( corn>=0 ) - { - float strength = corners[corn][0]; - float radius = corners[corn][1]; - roundCorners(mesh, center, staticVert, strength, radius); - } - } - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void correctComponents(MeshBase mesh, int numComponents) - { - int numTexToBeAdded = numComponents-mesh.getNumTexComponents(); - - mesh.mergeEffComponents(); - - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -import android.graphics.Canvas; -import android.graphics.Paint; - -import static org.distorted.objects.TwistyObject.TEXTURE_HEIGHT; -import static org.distorted.objects.TwistyObject.COLOR_BLACK; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class FactorySticker - { - private static FactorySticker mThis; - private float mOX, mOY, mR; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private FactorySticker() - { - - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static FactorySticker getInstance() - { - if( mThis==null ) mThis = new FactorySticker(); - - return mThis; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float computeAngle(float dx, float dy) - { - float PI = (float)Math.PI; - double angle = Math.atan2(dy,dx); - float ret = (float)(3*PI/2-angle); - - if( ret>2*PI ) ret-= 2*PI; - - return ret; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float getAngle(float[] angles, int index) - { - return angles==null ? 0 : angles[index]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void computeCircleCoords(float lX,float lY, float rX, float rY, float alpha) - { - float ctg= 1.0f/((float)Math.tan(alpha)); - mOX = 0.5f*(lX+rX) + ctg*0.5f*(lY-rY); - mOY = 0.5f*(lY+rY) - ctg*0.5f*(lX-rX); - float dx = mOX-lX; - float dy = mOY-lY; - mR = (float)Math.sqrt(dx*dx+dy*dy); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// circle1: center (x1,y1) radius r1; circle2: center (x2,y2) radius r2. -// Guaranteed to intersect in two points. Find the intersection. Which one? the one that's closer -// to (nearx,neary). - - private void findCircleIntersection(float x1,float y1, float r1, float x2, float y2, float r2, float nearx, float neary ) - { - float dx = x2-x1; - float dy = y2-y1; - float d = (float)Math.sqrt(dx*dx+dy*dy); - - if( d>0 ) - { - float Dx = dx/d; - float Dy = dy/d; - float cos = (r1*r1+d*d-r2*r2)/(2*r1*d); - float sin = (float)Math.sqrt(1-cos*cos); - - float ox1 = x1 + r1*cos*Dx + r1*sin*Dy; - float oy1 = y1 + r1*cos*Dy - r1*sin*Dx; - float ox2 = x1 + r1*cos*Dx - r1*sin*Dy; - float oy2 = y1 + r1*cos*Dy + r1*sin*Dx; - - dx = nearx-ox1; - dy = neary-oy1; - float d1 = dx*dx+dy*dy; - dx = nearx-ox2; - dy = neary-oy2; - float d2 = dx*dx+dy*dy; - - if( d1. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class ObjectShape - { - private final double[][] mVertices; - private final int[][] mVertIndices; - private final float[][] mBands; - private final int[] mBandIndices; - private final float[][] mCorners; - private final int[] mCornerIndices; - private final float[][] mCenters; - private final int[] mCenterIndices; - private final int mNumComponents; - private final float[] mConvexityCenter; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ObjectShape(double[][] vertices, int[][] vertIndices, float[][] bands, int[] bandIndices, - float[][] corners, int[] cornIndices, float[][] centers, int[] centIndices, - int numComponents, float[] convexityCenter) - { - mVertices = vertices; - mVertIndices = vertIndices; - mBands = bands; - mBandIndices = bandIndices; - mCorners = corners; - mCornerIndices = cornIndices; - mCenters = centers; - mCenterIndices = centIndices; - mNumComponents = numComponents; - mConvexityCenter = convexityCenter; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public double[][] getVertices() - { - return mVertices; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[][] getVertIndices() - { - return mVertIndices; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[][] getBands() - { - return mBands; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getBandIndices() - { - return mBandIndices; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[][] getCorners() - { - return mCorners; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getCornerIndices() - { - return mCornerIndices; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[][] getCenters() - { - return mCenters; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getCenterIndices() - { - return mCenterIndices; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getNumComponents() - { - return mNumComponents; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[] getConvexityCenter() - { - return mConvexityCenter; - } - } diff --git a/src/main/java/org/distorted/helpers/ObjectSticker.java b/src/main/java/org/distorted/helpers/ObjectSticker.java deleted file mode 100644 index 8ca437dc..00000000 --- a/src/main/java/org/distorted/helpers/ObjectSticker.java +++ /dev/null @@ -1,68 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class ObjectSticker - { - private final float[] mCoords; - private final float[] mCurvature; - private final float[] mRadii; - private final float mStroke; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ObjectSticker(float[] coords, float[] curvature, float[] radii, float stroke) - { - mCoords = coords; - mCurvature = curvature; - mRadii = radii; - mStroke = stroke; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[] getCoords() - { - return mCoords; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[] getCurvature() - { - return mCurvature; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float[] getRadii() - { - return mRadii; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float getStroke() - { - return mStroke; - } - } diff --git a/src/main/java/org/distorted/helpers/QuatHelper.java b/src/main/java/org/distorted/helpers/QuatHelper.java deleted file mode 100644 index 45a76f84..00000000 --- a/src/main/java/org/distorted/helpers/QuatHelper.java +++ /dev/null @@ -1,163 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class QuatHelper - { -/////////////////////////////////////////////////////////////////////////////////////////////////// -// return quat1*quat2 - - public static Static4D quatMultiply( Static4D quat1, Static4D quat2 ) - { - float qx = quat1.get0(); - float qy = quat1.get1(); - float qz = quat1.get2(); - float qw = quat1.get3(); - - float rx = quat2.get0(); - float ry = quat2.get1(); - float rz = quat2.get2(); - float rw = quat2.get3(); - - float tx = rw*qx - rz*qy + ry*qz + rx*qw; - float ty = rw*qy + rz*qx + ry*qw - rx*qz; - float tz = rw*qz + rz*qw - ry*qx + rx*qy; - float tw = rw*qw - rz*qz - ry*qy - rx*qx; - - return new Static4D(tx,ty,tz,tw); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// rotate 'vector' by quat ( i.e. return quat*vector*(quat^-1) ) - - public static Static4D rotateVectorByQuat(Static4D vector, Static4D quat) - { - float qx = quat.get0(); - float qy = quat.get1(); - float qz = quat.get2(); - float qw = quat.get3(); - - Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); - Static4D tmp = quatMultiply(quat,vector); - - return quatMultiply(tmp,quatInverted); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// rotate 'vector' by quat^(-1) ( i.e. return (quat^-1)*vector*quat ) - - public static Static4D rotateVectorByInvertedQuat(Static4D vector, Static4D quat) - { - float qx = quat.get0(); - float qy = quat.get1(); - float qz = quat.get2(); - float qw = quat.get3(); - - Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); - Static4D tmp = quatMultiply(quatInverted,vector); - - return quatMultiply(tmp,quat); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static Static4D quatFromDrag(float dragX, float dragY) - { - float axisX = dragY; // inverted X and Y - rotation axis is perpendicular to (dragX,dragY) - float axisY = dragX; // Why not (-dragY, dragX) ? because Y axis is also inverted! - float axisZ = 0; - float axisL = (float)Math.sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ); - - if( axisL>0 ) - { - axisX /= axisL; - axisY /= axisL; - axisZ /= axisL; - - float ratio = axisL; - ratio = ratio - (int)ratio; // the cos() is only valid in (0,Pi) - - float cosA = (float)Math.cos(Math.PI*ratio); - float sinA = (float)Math.sqrt(1-cosA*cosA); - - return new Static4D(axisX*sinA, axisY*sinA, axisZ*sinA, cosA); - } - - return new Static4D(0f, 0f, 0f, 1f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static double computeCos(double oldX, double oldY, double newX, double newY, double len1, double len2) - { - double ret= (oldX*newX+oldY*newY) / (len1*len2); - if( ret<-1.0 ) return -1.0; - if( ret> 1.0 ) return 1.0; - - return ret; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// sin of (signed!) angle between vectors 'old' and 'new', counterclockwise! - - public static double computeSin(double oldX, double oldY, double newX, double newY, double len1, double len2) - { - double ret= (newX*oldY-oldX*newY) / (len1*len2); - if( ret<-1.0 ) return -1.0; - if( ret> 1.0 ) return 1.0; - - return ret; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// return quat Q that turns 3D vector A=(ax,ay,az) to another 3D vector B=(bx,by,bz) -// take care of double-cover by ensuring that always Q.get3() >=0 - - public static Static4D retRotationQuat(float ax, float ay, float az, float bx, float by, float bz) - { - float nx = ay*bz - az*by; - float ny = az*bx - ax*bz; - float nz = ax*by - ay*bx; - - float sin = (float)Math.sqrt(nx*nx + ny*ny + nz*nz); - float cos = ax*bx + ay*by + az*bz; - - if( sin!=0 ) - { - nx /= sin; - ny /= sin; - nz /= sin; - } - - // Why sin<=0 and cos>=0 ? - // 0 0 both sin and cos are positive. - // But1: quats work counterclockwise -> negate cos. - // But2: double-cover, we prefer to have the cos positive (so that unit=(0,0,0,1)) - // so negate again both cos and sin. - float sinHalf =-(float)Math.sqrt((1-cos)/2); - float cosHalf = (float)Math.sqrt((1+cos)/2); - - return new Static4D(nx*sinHalf,ny*sinHalf,nz*sinHalf,cosHalf); - } - } diff --git a/src/main/java/org/distorted/helpers/ScrambleState.java b/src/main/java/org/distorted/helpers/ScrambleState.java deleted file mode 100644 index 6a9da810..00000000 --- a/src/main/java/org/distorted/helpers/ScrambleState.java +++ /dev/null @@ -1,141 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -import java.util.Random; - -public class ScrambleState -{ - private final int mTotal, mNumAxis; - private final int[] mNum; - private final int[] mInfo; - private final int[] mTmp; - private final int LEN = 4; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ScrambleState(int[][] axis) - { - mTmp = new int[LEN]; - - mNumAxis = axis.length; - mNum = new int[mNumAxis]; - int total =0; - - for(int i=0; imax ) max=value; - } - } - - for(int i=0; i=0 && indexExcluded. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// producer of the ScrambleStateGraph - but only for a single Twisty Puzzle, the 'BandagedEvil'. - -import java.util.ArrayList; - -public class ScrambleStateBandagedEvil -{ - private static final int INVALID_MOVE = -1; - - private static final int CORNER_S = 0; - private static final int CORNER_X = 1; - private static final int CORNER_Y = 2; - private static final int CORNER_Z = 3; - - private static final int CENTER_0 = 0; - private static final int CENTER_1 = 1; - private static final int CENTER_2 = 2; - private static final int CENTER_3 = 3; - - private int mID; - private final int[] mMoves; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ScrambleStateBandagedEvil(int id) - { - mID = id; - mMoves = createMoves(mID); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static void computeGraph() - { - ArrayList graph; - - int id = 0; - int id1 = setCenter(id , CENTER_2, 0); - int id2 = setCenter(id1 , CENTER_2, 1); - int id3 = setCenter(id2 , CENTER_3, 2); - int id4 = setCenter(id3 , CENTER_2, 3); - - int id5 = setCorner(id4 , CORNER_X, 0); - int id6 = setCorner(id5 , CORNER_Y, 1); - int id7 = setCorner(id6 , CORNER_X, 2); - int id8 = setCorner(id7 , CORNER_Z, 3); - int id9 = setCorner(id8 , CORNER_Y, 4); - int id10= setCorner(id9 , CORNER_Y, 5); - int id11= setCorner(id10, CORNER_S, 6); - int id12= setCorner(id11, CORNER_Z, 7); - - ScrambleStateBandagedEvil bsg = new ScrambleStateBandagedEvil(id12); - graph = new ArrayList<>(); - graph.add(bsg); - - insertChildren(graph,id12); - pruneGraph(graph); - remapGraph(graph); - - int num = graph.size(); - android.util.Log.e("D", "\n"+num+" states\n"); - - for(int i=0; i list, int id) - { - ScrambleStateBandagedEvil bsg = findState(list,id); - - if( bsg==null ) - { - android.util.Log.e("D", "error: "+id+" doesn't exist"); - return; - } - - for(int i=0; i<12; i++) - { - int move = bsg.getMove(i); - - if( move!=INVALID_MOVE ) - { - ScrambleStateBandagedEvil tmp = findState(list,move); - - if( tmp==null ) - { - tmp = new ScrambleStateBandagedEvil(move); - list.add(tmp); - insertChildren(list,move); - } - } - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void pruneGraph(ArrayList list) - { - int num = list.size(), numAxis; - boolean pruned = false; - ScrambleStateBandagedEvil bsg; - - for(int i=0; i list) - { - int id, num = list.size(); - ScrambleStateBandagedEvil bsg; - - for(int i=0; i list, int id, int newId) - { - ScrambleStateBandagedEvil bsg; - int size = list.size(); - - for(int i=0; i list, int id) - { - ScrambleStateBandagedEvil bsg; - int num = list.size(); - - for(int i=0; i=0 && index<12) ? mMoves[index] : -1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int numAxis() - { - int num = 0; - - if( mMoves[ 0]!=INVALID_MOVE || mMoves[ 1]!=INVALID_MOVE || mMoves[ 2]!=INVALID_MOVE ) num++; - if( mMoves[ 3]!=INVALID_MOVE || mMoves[ 4]!=INVALID_MOVE || mMoves[ 5]!=INVALID_MOVE ) num++; - if( mMoves[ 6]!=INVALID_MOVE || mMoves[ 7]!=INVALID_MOVE || mMoves[ 8]!=INVALID_MOVE ) num++; - if( mMoves[ 9]!=INVALID_MOVE || mMoves[10]!=INVALID_MOVE || mMoves[11]!=INVALID_MOVE ) num++; - - return num; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void setMove(int index, int newMove) - { - if( index>=0 && index<12 ) mMoves[index] = newMove; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static String debug(int id) - { - int ce0 = getCenter(id,0); - int ce1 = getCenter(id,1); - int ce2 = getCenter(id,2); - int ce3 = getCenter(id,3); - - int co0 = getCorner(id,0); - int co1 = getCorner(id,1); - int co2 = getCorner(id,2); - int co3 = getCorner(id,3); - int co4 = getCorner(id,4); - int co5 = getCorner(id,5); - int co6 = getCorner(id,6); - int co7 = getCorner(id,7); - - String center = centerString(ce0) + centerString(ce1) + centerString(ce2) + centerString(ce3); - String corner = cornerString(co0) + cornerString(co1) + cornerString(co2) + cornerString(co3) + - cornerString(co4) + cornerString(co5) + cornerString(co6) + cornerString(co7); - - return center + " -" + corner; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static String centerString(int center) - { - return " "+center; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static String cornerString(int corner) - { - switch(corner) - { - case CORNER_S: return " S"; - case CORNER_X: return " X"; - case CORNER_Y: return " Y"; - case CORNER_Z: return " Z"; - } - - return "?"; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int[] createMoves(int id) - { - int[] ret = new int[12]; - - boolean moveX = xPossible(id); - boolean moveY = yPossible(id); - boolean moveZ0 = z0Possible(id); - boolean moveZ2 = z2Possible(id); - - if( moveX ) createXmoves(id,ret); - else { ret[ 0] = INVALID_MOVE; ret[ 1] = INVALID_MOVE; ret[ 2] = INVALID_MOVE; } - if( moveY ) createYmoves(id,ret); - else { ret[ 3] = INVALID_MOVE; ret[ 4] = INVALID_MOVE; ret[ 5] = INVALID_MOVE; } - if( moveZ0) createZ0moves(id,ret); - else { ret[ 6] = INVALID_MOVE; ret[ 7] = INVALID_MOVE; ret[ 8] = INVALID_MOVE; } - if( moveZ2) createZ2moves(id,ret); - else { ret[ 9] = INVALID_MOVE; ret[10] = INVALID_MOVE; ret[11] = INVALID_MOVE; } - - return ret; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static boolean xPossible(int id) - { - if( getCorner(id,4)==CORNER_X ) return false; - if( getCorner(id,5)==CORNER_X ) return false; - if( getCorner(id,6)==CORNER_X ) return false; - if( getCorner(id,7)==CORNER_X ) return false; - - if( getCenter(id,1)==CENTER_1 ) return false; - if( getCenter(id,2)==CENTER_1 ) return false; - if( getCenter(id,3)==CENTER_1 ) return false; - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static boolean yPossible(int id) - { - if( getCorner(id,2)==CORNER_Y ) return false; - if( getCorner(id,3)==CORNER_Y ) return false; - if( getCorner(id,6)==CORNER_Y ) return false; - if( getCorner(id,7)==CORNER_Y ) return false; - - if( getCenter(id,0)==CENTER_0 ) return false; - if( getCenter(id,2)==CENTER_0 ) return false; - if( getCenter(id,3)==CENTER_0 ) return false; - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static boolean z0Possible(int id) - { - if( getCorner(id,0)==CORNER_Z ) return false; - if( getCorner(id,2)==CORNER_Z ) return false; - if( getCorner(id,4)==CORNER_Z ) return false; - if( getCorner(id,6)==CORNER_Z ) return false; - - if( getCenter(id,0)==CENTER_1 ) return false; - if( getCenter(id,1)==CENTER_0 ) return false; - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static boolean z2Possible(int id) - { - if( getCorner(id,1)==CORNER_Z ) return false; - if( getCorner(id,3)==CORNER_Z ) return false; - if( getCorner(id,5)==CORNER_Z ) return false; - if( getCorner(id,7)==CORNER_Z ) return false; - - if( getCenter(id,0)==CENTER_3 ) return false; - if( getCenter(id,1)==CENTER_2 ) return false; - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int getCorner(int id, int index) - { - return (id>>(14-2*index))&3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int getCenter(int id, int index) - { - return (id>>(22-2*index))&3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int setCorner(int id, int corner, int index) - { - return id + ((corner-getCorner(id,index))<<(14-2*index)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int setCenter(int id, int center, int index) - { - return id + ((center-getCenter(id,index))<<(22-2*index)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void createXmoves(int id, int[] moves) - { - int id1 = rotateX(id); - moves[0] = id1; - int id2 = rotateX(id1); - moves[1] = id2; - int id3 = rotateX(id2); - moves[2] = id3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void createYmoves(int id, int[] moves) - { - int id1 = rotateY(id); - moves[3] = id1; - int id2 = rotateY(id1); - moves[4] = id2; - int id3 = rotateY(id2); - moves[5] = id3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void createZ0moves(int id, int[] moves) - { - int id1 = rotateZ0(id); - moves[6] = id1; - int id2 = rotateZ0(id1); - moves[7] = id2; - int id3 = rotateZ0(id2); - moves[8] = id3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void createZ2moves(int id, int[] moves) - { - int id1 = rotateZ2(id); - moves[ 9] = id1; - int id2 = rotateZ2(id1); - moves[10] = id2; - int id3 = rotateZ2(id2); - moves[11] = id3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotateX(int id) - { - int newCorner4 = rotCornerX(getCorner(id,5)); - int newCorner5 = rotCornerX(getCorner(id,7)); - int newCorner6 = rotCornerX(getCorner(id,4)); - int newCorner7 = rotCornerX(getCorner(id,6)); - int newCenter = rotCenter (getCenter(id,0)); - - int id1 = setCorner(id ,newCorner4,4); - int id2 = setCorner(id1,newCorner5,5); - int id3 = setCorner(id2,newCorner6,6); - int id4 = setCorner(id3,newCorner7,7); - int id5 = setCenter(id4,newCenter ,0); - - return id5; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotateY(int id) - { - int newCorner2 = rotCornerY(getCorner(id,6)); - int newCorner3 = rotCornerY(getCorner(id,2)); - int newCorner6 = rotCornerY(getCorner(id,7)); - int newCorner7 = rotCornerY(getCorner(id,3)); - int newCenter = rotCenter (getCenter(id,1)); - - int id1 = setCorner(id ,newCorner2,2); - int id2 = setCorner(id1,newCorner3,3); - int id3 = setCorner(id2,newCorner6,6); - int id4 = setCorner(id3,newCorner7,7); - int id5 = setCenter(id4,newCenter ,1); - - return id5; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotateZ0(int id) - { - int newCorner0 = rotCornerZ(getCorner(id,2)); - int newCorner2 = rotCornerZ(getCorner(id,6)); - int newCorner4 = rotCornerZ(getCorner(id,0)); - int newCorner6 = rotCornerZ(getCorner(id,4)); - int newCenter = rotCenter (getCenter(id,2)); - - int id1 = setCorner(id ,newCorner0,0); - int id2 = setCorner(id1,newCorner2,2); - int id3 = setCorner(id2,newCorner4,4); - int id4 = setCorner(id3,newCorner6,6); - int id5 = setCenter(id4,newCenter ,2); - - return id5; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotateZ2(int id) - { - int newCorner1 = rotCornerZ(getCorner(id,3)); - int newCorner3 = rotCornerZ(getCorner(id,7)); - int newCorner5 = rotCornerZ(getCorner(id,1)); - int newCorner7 = rotCornerZ(getCorner(id,5)); - int newCenter = rotCenter (getCenter(id,3)); - - int id1 = setCorner(id ,newCorner1,1); - int id2 = setCorner(id1,newCorner3,3); - int id3 = setCorner(id2,newCorner5,5); - int id4 = setCorner(id3,newCorner7,7); - int id5 = setCenter(id4,newCenter ,3); - - return id5; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotCornerX(int corner) - { - switch(corner) - { - case CORNER_S: return CORNER_S; - case CORNER_X: android.util.Log.e("DIST", "rotateX: ERROR"); - return CORNER_S; - case CORNER_Y: return CORNER_Z; - case CORNER_Z: return CORNER_Y; - } - - return CORNER_S; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotCornerY(int corner) - { - switch(corner) - { - case CORNER_S: return CORNER_S; - case CORNER_X: return CORNER_Z; - case CORNER_Y: android.util.Log.e("DIST", "rotateY: ERROR"); - return CORNER_S; - case CORNER_Z: return CORNER_X; - } - - return CORNER_S; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotCornerZ(int corner) - { - switch(corner) - { - case CORNER_S: return CORNER_S; - case CORNER_X: return CORNER_Y; - case CORNER_Y: return CORNER_X; - case CORNER_Z: android.util.Log.e("DIST", "rotateZ: ERROR"); - return CORNER_S; - } - - return CORNER_S; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int rotCenter(int center) - { - switch(center) - { - case CENTER_0: return CENTER_3; - case CENTER_1: return CENTER_0; - case CENTER_2: return CENTER_1; - case CENTER_3: return CENTER_2; - } - - return CENTER_0; - } -} diff --git a/src/main/java/org/distorted/helpers/ScrambleStateSquare1.java b/src/main/java/org/distorted/helpers/ScrambleStateSquare1.java deleted file mode 100644 index 3fb87092..00000000 --- a/src/main/java/org/distorted/helpers/ScrambleStateSquare1.java +++ /dev/null @@ -1,594 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.helpers; - -import java.util.ArrayList; -import java.util.Random; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// producer of the ScrambleStateGraph - but only for a single Twisty Puzzle, the 'Square-1'. - -public class ScrambleStateSquare1 -{ - private static final int INVALID_MOVE = -1; - private static final int NUM_MOVES = 23; - - private int mDist; - private boolean mFresh; - private long mID; - private final long[] mMoves; - - private final int[][] mPermittedAngles; - private final int[] mCornerQuat, mTmp; - - // QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]] - static final int[][] QUAT_MULT = new int[][] - { - { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,}, - { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,}, - { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,}, - { 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,}, - { 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,}, - { 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,}, - { 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,}, - { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,}, - { 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,}, - { 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,}, - { 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,}, - { 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,}, - { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,}, - { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,}, - { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3,}, - { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4,}, - { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5,}, - { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6,}, - { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7,}, - { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8,}, - { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9,}, - { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10,}, - { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11,}, - { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,} - }; - - // quat indices that make corner cubits bandage the puzzle. - private static final int[][] BAD_CORNER_QUATS = new int[][] - { - { 2, 8,17,23}, - { 5,11,14,20}, - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ScrambleStateSquare1(long id, int dist) - { - mCornerQuat = new int[8]; - mTmp = new int[8]; - mPermittedAngles = new int[2][12]; - - mDist = dist; - mFresh = true; - mID = id; - mMoves = createMoves(mID); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void setNotFresh() - { - mFresh = false; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean isFresh() - { - return mFresh; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static void computeGraph() - { - ArrayList graph; - - ScrambleStateSquare1 bsg = new ScrambleStateSquare1(0,0); - graph = new ArrayList<>(); - graph.add(bsg); - -android.util.Log.e("D", "INSERTING"); - - insertChildren(graph,0); - -//android.util.Log.e("D", "PRUNING "+graph.size()); - -// pruneGraph(graph); - -android.util.Log.e("D", "REMAPPING "+graph.size()); - - remapGraph(graph); - - int num = graph.size(); - android.util.Log.e("D", "\n"+num+" states\n"); - - for(int i=0; i list, long id) - { - ScrambleStateSquare1 bsg = findState(list,id); - - if( bsg==null ) - { - android.util.Log.e("D", "error: "+id+" doesn't exist"); - return; - } - - int dist = bsg.mDist; - if( dist>6 ) return; - - for(int i=0; i list) - { - int num = list.size(), numAxis; - boolean pruned = false; - ScrambleStateSquare1 bsg; - - for(int i=0; i list) - { - long id; - int num = list.size(); - ScrambleStateSquare1 bsg; - - for(int i=0; i list, long id, long newId) - { - ScrambleStateSquare1 bsg; - int size = list.size(); - - for(int i=0; i list, long id) - { - ScrambleStateSquare1 bsg; - int num = list.size(); - - for(int i=0; i=0 && index=0 && index=12)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean cornerIsLeft(int index) - { - int q = mCornerQuat[index]; - - switch(index) - { - case 0: - case 4: return ((q>=3 && q<= 7) || (q>=18 && q<=22)); - case 1: - case 5: return ((q>=6 && q<=10) || (q>=15 && q<=19)); - case 2: - case 6: return ((q==0 || q==1 || (q>=9 && q<=11)) || (q>=12 && q<=16)); - case 3: - case 7: return ((q>=0 && q<=4) || (q==12 || q==13 || (q>=21 && q<=23))); - } - - return false; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int makeQuat(int axis,int index) - { - if( axis==1 ) return 13; - if( index<0 ) index+=12; - return index; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean cornerBelongs(int index, int axis, int layer) - { - if( axis==0 ) - { - boolean up = cornerIsUp(index); - return ((up && layer==2) || (!up && layer==0)); - } - else - { - boolean le = cornerIsLeft(index); - return ((le && layer==0) || (!le && layer==1)); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private long updateCornerQuats(int axis, int layer, int index) - { - int quat = makeQuat(axis,index); - - for(int corner=0; corner<8; corner++) - { - if( cornerBelongs(corner,axis,layer) ) - { - int curr = mCornerQuat[corner]; - mTmp[corner] = QUAT_MULT[quat][curr]; - } - else - { - mTmp[corner] = mCornerQuat[corner]; - } - } - - return returnID(mTmp); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean quatIsBad(int quatIndex, int corner) - { - int index = (corner%2); - - return ( quatIndex==BAD_CORNER_QUATS[index][0] || - quatIndex==BAD_CORNER_QUATS[index][1] || - quatIndex==BAD_CORNER_QUATS[index][2] || - quatIndex==BAD_CORNER_QUATS[index][3] ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int isPermittedDo(int angle) - { - for(int corner=0; corner<8; corner++) - { - if( !cornerIsUp(corner) ) - { - int currQuat = mCornerQuat[corner]; - int finalQuat= QUAT_MULT[angle][currQuat]; - if( quatIsBad(finalQuat,corner) ) return 0; - } - } - - return 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int isPermittedUp(int angle) - { - for(int corner=0; corner<8; corner++) - { - if( cornerIsUp(corner) ) - { - int currQuat = mCornerQuat[corner]; - int finalQuat= QUAT_MULT[angle][currQuat]; - if( quatIsBad(finalQuat,corner) ) return 0; - } - } - - return 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void computePermittedAngles() - { - for(int angle=0; angle<12; angle++) - { - mPermittedAngles[0][angle] = isPermittedDo(angle); - mPermittedAngles[1][angle] = isPermittedUp(angle); - } - } -} diff --git a/src/main/java/org/distorted/main/RubikActivity.java b/src/main/java/org/distorted/main/RubikActivity.java index 12737af3..c52af4fb 100644 --- a/src/main/java/org/distorted/main/RubikActivity.java +++ b/src/main/java/org/distorted/main/RubikActivity.java @@ -45,10 +45,10 @@ import org.distorted.library.main.DistortedLibrary; import org.distorted.library.main.DistortedScreen; import org.distorted.library.type.Static4D; -import org.distorted.objects.TwistyObject; +import org.distorted.objectlb.TwistyObject; import org.distorted.network.RubikScores; import org.distorted.network.RubikNetwork; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import org.distorted.screens.ScreenList; import org.distorted.screens.RubikScreenPlay; import org.distorted.tutorials.TutorialActivity; diff --git a/src/main/java/org/distorted/main/RubikPreRender.java b/src/main/java/org/distorted/main/RubikPreRender.java index 2b33d308..f4145399 100644 --- a/src/main/java/org/distorted/main/RubikPreRender.java +++ b/src/main/java/org/distorted/main/RubikPreRender.java @@ -42,8 +42,8 @@ import org.distorted.effects.scramble.ScrambleEffect; import org.distorted.helpers.BlockController; import org.distorted.helpers.MovesFinished; import org.distorted.helpers.TwistyPreRender; -import org.distorted.objects.TwistyObject; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.TwistyObject; +import org.distorted.objectlb.ObjectList; import org.distorted.network.RubikScores; import org.distorted.screens.RubikScreenPlay; import org.distorted.screens.ScreenList; diff --git a/src/main/java/org/distorted/main/RubikSurfaceView.java b/src/main/java/org/distorted/main/RubikSurfaceView.java index ca471e5f..abc90a05 100644 --- a/src/main/java/org/distorted/main/RubikSurfaceView.java +++ b/src/main/java/org/distorted/main/RubikSurfaceView.java @@ -30,11 +30,11 @@ import android.view.MotionEvent; import com.google.firebase.crashlytics.FirebaseCrashlytics; -import org.distorted.helpers.QuatHelper; +import org.distorted.objectlb.QuatHelper; import org.distorted.library.type.Static2D; import org.distorted.library.type.Static4D; -import org.distorted.objects.TwistyObject; -import org.distorted.objects.Movement; +import org.distorted.objectlb.TwistyObject; +import org.distorted.objectlb.Movement; import org.distorted.screens.RubikScreenReady; import org.distorted.solvers.SolverMain; import org.distorted.screens.ScreenList; diff --git a/src/main/java/org/distorted/network/RubikNetwork.java b/src/main/java/org/distorted/network/RubikNetwork.java index 855d1a26..a46d7544 100644 --- a/src/main/java/org/distorted/network/RubikNetwork.java +++ b/src/main/java/org/distorted/network/RubikNetwork.java @@ -27,7 +27,7 @@ import androidx.appcompat.app.AppCompatActivity; import androidx.fragment.app.FragmentActivity; import org.distorted.library.main.DistortedLibrary; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import java.io.InputStream; import java.net.HttpURLConnection; @@ -36,7 +36,7 @@ import java.net.UnknownHostException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; -import static org.distorted.objects.ObjectList.MAX_LEVEL; +import static org.distorted.objectlb.ObjectList.MAX_LEVEL; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/network/RubikScores.java b/src/main/java/org/distorted/network/RubikScores.java index a0e951b3..151230ec 100644 --- a/src/main/java/org/distorted/network/RubikScores.java +++ b/src/main/java/org/distorted/network/RubikScores.java @@ -26,13 +26,13 @@ import android.telephony.TelephonyManager; import com.google.firebase.crashlytics.FirebaseCrashlytics; import org.distorted.main.BuildConfig; -import org.distorted.objects.ObjectList; +import org.distorted.objectlb.ObjectList; import java.util.UUID; -import static org.distorted.objects.ObjectList.MAX_NUM_OBJECTS; -import static org.distorted.objects.ObjectList.NUM_OBJECTS; -import static org.distorted.objects.ObjectList.MAX_LEVEL; +import static org.distorted.objectlb.ObjectList.MAX_NUM_OBJECTS; +import static org.distorted.objectlb.ObjectList.NUM_OBJECTS; +import static org.distorted.objectlb.ObjectList.MAX_LEVEL; /////////////////////////////////////////////////////////////////////////////////////////////////// // hold my own scores, and some other statistics. diff --git a/src/main/java/org/distorted/objectlb/Cubit.java b/src/main/java/org/distorted/objectlb/Cubit.java new file mode 100644 index 00000000..c76bbb95 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Cubit.java @@ -0,0 +1,227 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.SharedPreferences; + +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class Cubit + { + private final float[] mOrigPosition; + private final float[] mCurrentPosition; + private final int mNumAxis; + private final int mLen; + private final int[] mRotationRow; + private TwistyObject mParent; + + int mQuatIndex; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + Cubit(TwistyObject parent, float[] position, int numAxis) + { + mQuatIndex= 0; + mParent = parent; + mLen = position.length; + + mOrigPosition = new float[mLen]; + mCurrentPosition = new float[mLen]; + + for(int i=0; i. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.effect.MatrixEffectMove; +import org.distorted.library.effect.MatrixEffectQuaternion; +import org.distorted.library.effect.MatrixEffectScale; +import org.distorted.library.effect.VertexEffect; +import org.distorted.library.effect.VertexEffectDeform; +import org.distorted.library.mesh.MeshBase; +import org.distorted.library.mesh.MeshJoined; +import org.distorted.library.mesh.MeshPolygon; +import org.distorted.library.type.Static1D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +import java.util.ArrayList; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class FactoryCubit + { + private static final Static1D RADIUS = new Static1D(1); + private static FactoryCubit mThis; + + private static final double[] mBuffer = new double[3]; + private static final double[] mQuat1 = new double[4]; + private static final double[] mQuat2 = new double[4]; + private static final double[] mQuat3 = new double[4]; + private static final double[] mQuat4 = new double[4]; + + private static class StickerCoords + { + double[] vertices; + } + + private static class FaceTransform + { + int sticker; + double vx,vy,vz; + double scale; + double qx,qy,qz,qw; + boolean flip; + } + + private static final ArrayList mNewFaceTransf = new ArrayList<>(); + private static final ArrayList mOldFaceTransf = new ArrayList<>(); + private static final ArrayList mStickerCoords = new ArrayList<>(); + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private FactoryCubit() + { + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static FactoryCubit getInstance() + { + if( mThis==null ) mThis = new FactoryCubit(); + + return mThis; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// H - height of the band in the middle +// alpha - angle of the edge [0,90] +// dist - often in a polygon the distance from edge to center is not 1, but something else. +// This is the distance. +// K - where to begin the second, much more flat part of the band. [0,1] +// N - number of bands. N>=3 +// +// theory: two distinct parts to the band: +// 1) (0,B) - steep +// 2) (B,1) - flat +// +// In first part, we have y = g(x) ; in second - y = g(f(x)) where +// +// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha) +// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B) +// h(x) = R*(sin(alpha) - sin(x)) +// R = H/(1-cos(alpha)) +// D = H*sin(alpha) +// B = h(K*alpha) +// +// The N points are taken at: +// +// 1) in the second part, there are K2 = (N-3)/3 such points +// 2) in the first - K1 = (N-3) - K2 +// 3) also, the 3 points 0,B,1 +// +// so we have the sequence A[i] of N points +// +// 0 +// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1) +// B +// (1-B)*(i+1)/(K2+1) + B (i=0,i,...,K2-1) +// 1 + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float f(float D, float B, float x) + { + return ((D-B)*x + B*(1-D))/(1-B); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float g(float R, float D, float x, float cosAlpha) + { + float d = x-D; + return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float h(float R, float sinAlpha, float x) + { + return R*(sinAlpha-(float)Math.sin(x)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean areColinear(double[][] vertices, int index1, int index2, int index3) + { + double x1 = vertices[index1][0]; + double y1 = vertices[index1][1]; + double z1 = vertices[index1][2]; + double x2 = vertices[index2][0]; + double y2 = vertices[index2][1]; + double z2 = vertices[index2][2]; + double x3 = vertices[index3][0]; + double y3 = vertices[index3][1]; + double z3 = vertices[index3][2]; + + double v1x = x2-x1; + double v1y = y2-y1; + double v1z = z2-z1; + double v2x = x3-x1; + double v2y = y3-y1; + double v2z = z3-z1; + + double A = Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) ); + + return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void computeNormalVector(double[][] vertices, int index1, int index2, int index3) + { + double x1 = vertices[index1][0]; + double y1 = vertices[index1][1]; + double z1 = vertices[index1][2]; + double x2 = vertices[index2][0]; + double y2 = vertices[index2][1]; + double z2 = vertices[index2][2]; + double x3 = vertices[index3][0]; + double y3 = vertices[index3][1]; + double z3 = vertices[index3][2]; + + double v1x = x2-x1; + double v1y = y2-y1; + double v1z = z2-z1; + double v2x = x3-x1; + double v2y = y3-y1; + double v2z = z3-z1; + + mBuffer[0] = v1y*v2z - v2y*v1z; + mBuffer[1] = v1z*v2x - v2z*v1x; + mBuffer[2] = v1x*v2y - v2x*v1y; + + double len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2]; + len = Math.sqrt(len); + mBuffer[0] /= len; + mBuffer[1] /= len; + mBuffer[2] /= len; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// return quat1*quat2 + + private static void quatMultiply( double[] quat1, double[] quat2, double[] result ) + { + double qx = quat1[0]; + double qy = quat1[1]; + double qz = quat1[2]; + double qw = quat1[3]; + + double rx = quat2[0]; + double ry = quat2[1]; + double rz = quat2[2]; + double rw = quat2[3]; + + result[0] = rw*qx - rz*qy + ry*qz + rx*qw; + result[1] = rw*qy + rz*qx + ry*qw - rx*qz; + result[2] = rw*qz + rz*qw - ry*qx + rx*qy; + result[3] = rw*qw - rz*qz - ry*qy - rx*qx; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void fitInSquare(FaceTransform info, double[][] vert3D) + { + double minX = Double.MAX_VALUE; + double maxX =-Double.MAX_VALUE; + double minY = Double.MAX_VALUE; + double maxY =-Double.MAX_VALUE; + + for (double[] vert : vert3D) + { + double x = vert[0]; + double y = vert[1]; + + if (x > maxX) maxX = x; + if (x < minX) minX = x; + if (y > maxY) maxY = y; + if (y < minY) minY = y; + } + + minX = minX<0 ? -minX:minX; + maxX = maxX<0 ? -maxX:maxX; + minY = minY<0 ? -minY:minY; + maxY = maxY<0 ? -maxY:maxY; + + double max1 = Math.max(minX,minY); + double max2 = Math.max(maxX,maxY); + double max3 = Math.max(max1,max2); + + info.scale = max3/0.5; + + int len = vert3D.length; + StickerCoords sInfo = new StickerCoords(); + sInfo.vertices = new double[2*len]; + + for( int vertex=0; vertex=len ) v-=len; + if( v< 0 ) v+=len; + + return v; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted) + { + int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted); + double EPSILON = 0.001; + double scale = computeScale(newVert,oldVert,newZeroIndex,0); + + for(int i=1; iEPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false; + } + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void mirrorAllVertices(double[] output, int len, double[] input) + { + for(int vertex=0; vertex=0 ) + { + center.set( centers[cent][0], centers[cent][1], centers[cent][2]); + + int corn = cornerIndexes[v]; + + if( corn>=0 ) + { + float strength = corners[corn][0]; + float radius = corners[corn][1]; + roundCorners(mesh, center, staticVert, strength, radius); + } + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void correctComponents(MeshBase mesh, int numComponents) + { + int numTexToBeAdded = numComponents-mesh.getNumTexComponents(); + + mesh.mergeEffComponents(); + + for(int i=0; i. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import static org.distorted.objectlb.TwistyObject.COLOR_BLACK; +import static org.distorted.objectlb.TwistyObject.TEXTURE_HEIGHT; + +import android.graphics.Canvas; +import android.graphics.Paint; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class FactorySticker + { + private static FactorySticker mThis; + private float mOX, mOY, mR; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private FactorySticker() + { + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static FactorySticker getInstance() + { + if( mThis==null ) mThis = new FactorySticker(); + + return mThis; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float computeAngle(float dx, float dy) + { + float PI = (float)Math.PI; + double angle = Math.atan2(dy,dx); + float ret = (float)(3*PI/2-angle); + + if( ret>2*PI ) ret-= 2*PI; + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float getAngle(float[] angles, int index) + { + return angles==null ? 0 : angles[index]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void computeCircleCoords(float lX,float lY, float rX, float rY, float alpha) + { + float ctg= 1.0f/((float)Math.tan(alpha)); + mOX = 0.5f*(lX+rX) + ctg*0.5f*(lY-rY); + mOY = 0.5f*(lY+rY) - ctg*0.5f*(lX-rX); + float dx = mOX-lX; + float dy = mOY-lY; + mR = (float)Math.sqrt(dx*dx+dy*dy); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// circle1: center (x1,y1) radius r1; circle2: center (x2,y2) radius r2. +// Guaranteed to intersect in two points. Find the intersection. Which one? the one that's closer +// to (nearx,neary). + + private void findCircleIntersection(float x1,float y1, float r1, float x2, float y2, float r2, float nearx, float neary ) + { + float dx = x2-x1; + float dy = y2-y1; + float d = (float)Math.sqrt(dx*dx+dy*dy); + + if( d>0 ) + { + float Dx = dx/d; + float Dy = dy/d; + float cos = (r1*r1+d*d-r2*r2)/(2*r1*d); + float sin = (float)Math.sqrt(1-cos*cos); + + float ox1 = x1 + r1*cos*Dx + r1*sin*Dy; + float oy1 = y1 + r1*cos*Dy - r1*sin*Dx; + float ox2 = x1 + r1*cos*Dx - r1*sin*Dy; + float oy2 = y1 + r1*cos*Dy + r1*sin*Dx; + + dx = nearx-ox1; + dy = neary-oy1; + float d1 = dx*dx+dy*dy; + dx = nearx-ox2; + dy = neary-oy2; + float d2 = dx*dx+dy*dy; + + if( d1. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.type.Static2D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Movement + { + // it doesn't matter where we touch a face - the list of enabled rotAxis will always be the same + public static final int TYPE_NOT_SPLIT = 0; + // each face is split into several parts by lines coming from its center to the midpoints of each edge + public static final int TYPE_SPLIT_EDGE = 1; + // each face is split into several parts by lines coming from its center to the vertices + public static final int TYPE_SPLIT_CORNER = 2; + + static final float SQ3 = (float)Math.sqrt(3); + static final float SQ6 = (float)Math.sqrt(6); + + private final int mNumFaceAxis; + private final float[] mPoint, mCamera, mTouch; + private final float[] mPoint2D, mMove2D; + private final int[] mEnabledRotAxis; + private final float mDistanceCenterFace3D; + private final Static3D[] mFaceAxis; + + private int mLastTouchedFace; + private float[][][] mCastedRotAxis; + private Static4D[][] mCastedRotAxis4D; + private float[][] mTouchBorders, mA, mB; + + private final int mType; + private final int[][][] mEnabled; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + abstract int returnPart(int type, int face, float[] touchPoint); + abstract boolean isInsideFace(int face, float[] point); + public abstract float returnRotationFactor(int numLayers, int row); + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + Movement(Static3D[] rotAxis, Static3D[] faceAxis, float[][] cuts, boolean[][] rotatable, + float distance3D, int size, int type, int[][][] enabled) + { + mPoint = new float[3]; + mCamera= new float[3]; + mTouch = new float[3]; + + mPoint2D = new float[2]; + mMove2D = new float[2]; + + mType = type; + mEnabled = enabled; + + mFaceAxis = faceAxis; + mNumFaceAxis= mFaceAxis.length; + + mEnabledRotAxis = new int[rotAxis.length+1]; + + mDistanceCenterFace3D = distance3D; // distance from the center of the object to each of its faces + + computeCastedAxis(rotAxis); + computeBorders(cuts,rotatable,size); + computeLinear(distance3D,rotAxis,faceAxis); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// mCastedRotAxis[1][2]{0,1} are the 2D coords of the 2nd rotAxis cast onto the face defined by the +// 1st faceAxis. + + private void computeCastedAxis(Static3D[] rotAxis) + { + mCastedRotAxis = new float[mNumFaceAxis][rotAxis.length][2]; + mCastedRotAxis4D = new Static4D[mNumFaceAxis][rotAxis.length]; + + float fx,fy,fz,f; + + for( int casted=0; casted mDistanceCenterFace3D; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace, +// compute point 'output[]' which: +// 1) lies on a face of the Object, i.e. surface defined by (axis, distance from (0,0,0)) +// 2) is co-linear with mCamera and mPoint +// +// output = camera + alpha*(point-camera), where alpha = [dist-axis*camera] / [axis*(point-camera)] + + private void castTouchPointOntoFace(Static3D faceAxis, float[] output) + { + float d0 = mPoint[0]-mCamera[0]; + float d1 = mPoint[1]-mCamera[1]; + float d2 = mPoint[2]-mCamera[2]; + float a0 = faceAxis.get0(); + float a1 = faceAxis.get1(); + float a2 = faceAxis.get2(); + + float denom = a0*d0 + a1*d1 + a2*d2; + + if( denom != 0.0f ) + { + float axisCam = a0*mCamera[0] + a1*mCamera[1] + a2*mCamera[2]; + float alpha = (mDistanceCenterFace3D-axisCam)/denom; + + output[0] = mCamera[0] + d0*alpha; + output[1] = mCamera[1] + d1*alpha; + output[2] = mCamera[2] + d2*alpha; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Convert the 3D point3D into a 2D point on the same face surface, but in a different +// coordinate system: a in-plane 2D coord where the origin is in the point where the axis intersects +// the surface, and whose Y axis points 'north' i.e. is in the plane given by the 3D origin, the +// original 3D Y axis and our 2D in-plane origin. +// If those 3 points constitute a degenerate triangle which does not define a plane - which can only +// happen if axis is vertical (or in theory when 2D origin and 3D origin meet, but that would have to +// mean that the distance between the center of the Object and its faces is 0) - then we arbitrarily +// decide that 2D Y = (0,0,-1) in the North Pole and (0,0,1) in the South Pole) + + private void convertTo2Dcoords(float[] point3D, Static3D faceAxis, float[] output) + { + float y0,y1,y2; // base Y vector of the 2D coord system + float a0 = faceAxis.get0(); + float a1 = faceAxis.get1(); + float a2 = faceAxis.get2(); + + if( a0==0.0f && a2==0.0f ) + { + y0=0; y1=0; y2=-a1; + } + else if( a1==0.0f ) + { + y0=0; y1=1; y2=0; + } + else + { + float norm = (float)(-a1/Math.sqrt(1-a1*a1)); + y0 = norm*a0; y1= norm*(a1-1/a1); y2=norm*a2; + } + + float x0 = y1*a2 - y2*a1; // + float x1 = y2*a0 - y0*a2; // (2D coord baseY) x (axis) = 2D coord baseX + float x2 = y0*a1 - y1*a0; // + + float originAlpha = point3D[0]*a0 + point3D[1]*a1 + point3D[2]*a2; + + float origin0 = originAlpha*a0; // coords of the point where axis + float origin1 = originAlpha*a1; // intersects surface plane i.e. + float origin2 = originAlpha*a2; // the origin of our 2D coord system + + float v0 = point3D[0] - origin0; + float v1 = point3D[1] - origin1; + float v2 = point3D[2] - origin2; + + output[0] = v0*x0 + v1*x1 + v2*x2; + output[1] = v0*y0 + v1*y1 + v2*y2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float[] computeBorder(float[] cuts, boolean[] rotatable, int size) + { + int len = cuts.length; + float[] border = new float[len]; + + for(int i=0; i0 ? border[i-1] : -Float.MAX_VALUE; + } + else + { + if( rotatable[i+1] ) border[i] = cuts[i]/size; + else + { + int found = -1; + + for(int j=i+2; j<=len; j++) + { + if( rotatable[j] ) + { + found=j; + break; + } + } + + border[i] = found>0 ? (cuts[i]+cuts[found-1])/(2*size) : Float.MAX_VALUE; + } + } + } + + return border; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// size, not numLayers (see Master Skewb where size!=numLayers) + + void computeBorders(float[][] cuts, boolean[][] rotatable, int size) + { + int numCuts = cuts.length; + mTouchBorders = new float[numCuts][]; + + for(int i=0; i. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import static org.distorted.objectlb.TwistyObject.SQ5; + +import org.distorted.library.type.Static3D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Dodecahedral objects: map the 2D swipes of user's fingers to 3D rotations + +public class Movement12 extends Movement +{ + public static final float C2 = (SQ5+3)/4; + public static final float LEN = (float)(Math.sqrt(1.25f+0.5f*SQ5)); + public static final float SIN54 = (SQ5+1)/4; + public static final float COS54 = (float)(Math.sqrt(10-2*SQ5)/4); + + public static final float DIST3D = (float)Math.sqrt(0.625f+0.275f*SQ5); + public static final float DIST2D = (SIN54/COS54)/2; + + public static final Static3D[] FACE_AXIS = new Static3D[] + { + new Static3D( C2/LEN, SIN54/LEN, 0 ), + new Static3D( C2/LEN,-SIN54/LEN, 0 ), + new Static3D( -C2/LEN, SIN54/LEN, 0 ), + new Static3D( -C2/LEN,-SIN54/LEN, 0 ), + new Static3D( 0 , C2/LEN, SIN54/LEN ), + new Static3D( 0 , C2/LEN,-SIN54/LEN ), + new Static3D( 0 , -C2/LEN, SIN54/LEN ), + new Static3D( 0 , -C2/LEN,-SIN54/LEN ), + new Static3D( SIN54/LEN, 0 , C2/LEN ), + new Static3D( SIN54/LEN, 0 , -C2/LEN ), + new Static3D(-SIN54/LEN, 0 , C2/LEN ), + new Static3D(-SIN54/LEN, 0 , -C2/LEN ) + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Movement12(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) + { + super(rotAxis, FACE_AXIS, cuts,rotatable,DIST3D, size, type, enabled); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float returnRotationFactor(int numLayers, int row) + { + return 1.0f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// return angle (in radians) that the line connecting the center C of the pentagonal face and the +// first vertex of the pentagon makes with a vertical line coming upwards from the center C. + + private float returnAngle(int face) + { + switch(face) + { + case 0: + case 2: + case 6: + case 7: return 0.0f; + case 1: + case 3: + case 4: + case 5: return (float)(36*Math.PI/180); + case 9: + case 10: return (float)(54*Math.PI/180); + case 8: + case 11: return (float)(18*Math.PI/180); + } + + return 0.0f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// The pair (distance,angle) defines a point P in R^2 in polar coordinate system. Let V be the vector +// from the center of the coordinate system to P. +// Let P' be the point defined by polar (distance,angle+PI/2). Let Lh be the half-line starting at +// P' and going in the direction of V. +// Return true iff point 'point' lies on the left of Lh, i.e. when we rotate (using the center of +// the coordinate system as the center of rotation) 'point' and Lh in such a way that Lh points +// directly upwards, is 'point' on the left or the right of it? + + private boolean isOnTheLeft(float[] point, float distance, float angle) + { + float sin = (float)Math.sin(angle); + float cos = (float)Math.cos(angle); + + float vx = point[0] + sin*distance; + float vy = point[1] - cos*distance; + + return vx*sin < vy*cos; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int returnPart(int type, int face, float[] point) + { + switch(type) + { + case TYPE_SPLIT_EDGE : return partEdge(point,face); + case TYPE_SPLIT_CORNER: return partCorner(point,face); + default : return 0; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Return 0,1,2,3,4 - the vertex of the pentagon to which point 'point' is the closest, if the +// 'point' is inside the pentagon - or -1 otherwise. +// The 'first' vertex is the one we meet the first when we rotate clockwise starting from 12:00. +// This vertex makes angle 'returnAngle()' with the line coming out upwards from the center of the +// pentagon. +// Distance from the center to a vertex of the pentagon = 1/(6*COS54) + + int partEdge(float[] point, int face) + { + float angle = returnAngle(face); + float A = (float)(Math.PI/5); + + for(int i=0; i<5; i++) + { + if( isOnTheLeft(point, DIST2D, (9-2*i)*A-angle) ) return -1; + } + + if( isOnTheLeft(point, 0, 2.5f*A-angle) ) + { + if( isOnTheLeft(point, 0, 3.5f*A-angle) ) + { + return isOnTheLeft(point, 0, 5.5f*A-angle) ? 3 : 4; + } + else return 0; + } + else + { + if( isOnTheLeft(point, 0, 4.5f*A-angle) ) + { + return 2; + } + else + { + return isOnTheLeft(point, 0, 6.5f*A-angle) ? 1 : 0; + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// TODO - no such object yet + + int partCorner(float[] point, int face) + { + return 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(int face, float[] p) + { + float angle = returnAngle(face); + float A = (float)(Math.PI/5); + + for(int i=0; i<5; i++) + { + if( isOnTheLeft(p, DIST2D, (9-2*i)*A-angle) ) return false; + } + + return true; + } +} diff --git a/src/main/java/org/distorted/objectlb/Movement4.java b/src/main/java/org/distorted/objectlb/Movement4.java new file mode 100644 index 00000000..06f07016 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Movement4.java @@ -0,0 +1,102 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.type.Static3D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Tetrahedral objects: map the 2D swipes of user's fingers to 3D rotations + +public class Movement4 extends Movement +{ + public static final float DIST3D = SQ6/12; + public static final float DIST2D = SQ3/6; + + public static final Static3D[] FACE_AXIS = new Static3D[] + { + new Static3D( 0,+SQ3/3,+SQ6/3), + new Static3D( 0,+SQ3/3,-SQ6/3), + new Static3D(-SQ6/3,-SQ3/3, 0), + new Static3D(+SQ6/3,-SQ3/3, 0), + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Movement4(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) + { + super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// corner edge +// | \ 0 / +// 2 | 0 \ / +// / \ 2 | 1 +// / 1 \ | + + int returnPart(int type, int face, float[] touchPoint) + { + switch(type) + { + case TYPE_NOT_SPLIT : return 0; + + case TYPE_SPLIT_EDGE : float y1 = (face > 1 ? touchPoint[1] : -touchPoint[1]); + float x1 = touchPoint[0]; + + boolean e0 = x1>0; + boolean e1 = y1>(+SQ3/3)*x1; + boolean e2 = y1>(-SQ3/3)*x1; + + if( e1 && e2 ) return 0; + if( !e1 && e0 ) return 1; + if( !e0 &&!e2 ) return 2; + + case TYPE_SPLIT_CORNER: float y2 = (face > 1 ? touchPoint[1] : -touchPoint[1]); + float x2 = touchPoint[0]; + + boolean c0 = x2>0; + boolean c1 = y2>(+SQ3/3)*x2; + boolean c2 = y2>(-SQ3/3)*x2; + + if( c0 && c2 ) return 0; + if( !c1 &&!c2 ) return 1; + if( !c0 && c1 ) return 2; + } + + return 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Jing has nL=2 + + public float returnRotationFactor(int numLayers, int row) + { + return numLayers==2 ? 1.0f : ((float)numLayers)/(numLayers-row); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(int face, float[] p) + { + float y = (face > 1 ? p[1] : -p[1]); + float x = p[0]; + return (y >= -DIST2D) && (y <= DIST2D*(2-6*x)) && (y <= DIST2D*(2+6*x)); + } +} diff --git a/src/main/java/org/distorted/objectlb/Movement6.java b/src/main/java/org/distorted/objectlb/Movement6.java new file mode 100644 index 00000000..f3484a5c --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Movement6.java @@ -0,0 +1,82 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.type.Static3D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Hexahedral objects: map the 2D swipes of user's fingers to 3D rotations + +public class Movement6 extends Movement +{ + public static final float DIST3D = 0.5f; + public static final float DIST2D = 0.5f; + + public static final Static3D[] FACE_AXIS = new Static3D[] + { + new Static3D(1,0,0), new Static3D(-1,0,0), + new Static3D(0,1,0), new Static3D(0,-1,0), + new Static3D(0,0,1), new Static3D(0,0,-1) + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Movement6(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) + { + super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// corner edge +// \ 0 / 3 | 0 +// 3 \ / 1 ___ | ___ +// / \ | +// / 2 \ 2 | 1 + + int returnPart(int type, int face, float[] touchPoint) + { + switch(type) + { + case TYPE_NOT_SPLIT : return 0; + case TYPE_SPLIT_EDGE : boolean e0 = touchPoint[0] > 0; + boolean e1 = touchPoint[1] > 0; + return e0 ? (e1 ? 0:1) : (e1 ? 3:2); + case TYPE_SPLIT_CORNER: boolean c0 = touchPoint[1] >= touchPoint[0]; + boolean c1 = touchPoint[1] >=-touchPoint[0]; + return c0 ? (c1 ? 0:3) : (c1 ? 1:2); + } + + return 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float returnRotationFactor(int numLayers, int row) + { + return 1.0f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(int face, float[] p) + { + return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D ); + } +} diff --git a/src/main/java/org/distorted/objectlb/Movement8.java b/src/main/java/org/distorted/objectlb/Movement8.java new file mode 100644 index 00000000..6a5ac37e --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Movement8.java @@ -0,0 +1,101 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.type.Static3D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Octahedral objects: map the 2D swipes of user's fingers to 3D rotations + +public class Movement8 extends Movement +{ + public static final float DIST3D = SQ6/6; + public static final float DIST2D = SQ3/6; + + public static final Static3D[] FACE_AXIS = new Static3D[] + { + new Static3D(+SQ6/3,+SQ3/3, 0), new Static3D(-SQ6/3,-SQ3/3, 0), + 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), + new Static3D( 0,+SQ3/3,-SQ6/3), new Static3D( 0,-SQ3/3,+SQ6/3) + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Movement8(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) + { + super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// corner edge +// | \ 0 / +// 2 | 0 \ / +// / \ 2 | 1 +// / 1 \ | + + int returnPart(int type, int face, float[] touchPoint) + { + switch(type) + { + case TYPE_NOT_SPLIT : return 0; + + case TYPE_SPLIT_EDGE : float y1 = (face%2 == 0 ? touchPoint[1] : -touchPoint[1]); + float x1 = touchPoint[0]; + + boolean e0 = x1>0; + boolean e1 = y1>(+SQ3/3)*x1; + boolean e2 = y1>(-SQ3/3)*x1; + + if( e1 && e2 ) return 0; + if( !e1 && e0 ) return 1; + if( !e0 &&!e2 ) return 2; + + case TYPE_SPLIT_CORNER: float y2 = (face%2 == 0 ? touchPoint[1] : -touchPoint[1]); + float x2 = touchPoint[0]; + + boolean c0 = x2>0; + boolean c1 = y2>(+SQ3/3)*x2; + boolean c2 = y2>(-SQ3/3)*x2; + + if( c0 && c2 ) return 0; + if( !c1 &&!c2 ) return 1; + if( !c0 && c1 ) return 2; + } + + return 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float returnRotationFactor(int numLayers, int row) + { + return 1.0f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(int face, float[] p) + { + float y = (face%2 == 0 ? p[1] : -p[1]); + float x = p[0]; + return (y >= -DIST2D) && (y <= DIST2D*(2-6*x)) && (y <= DIST2D*(2+6*x)); + } +} diff --git a/src/main/java/org/distorted/objectlb/ObjectList.java b/src/main/java/org/distorted/objectlb/ObjectList.java new file mode 100644 index 00000000..b14f5503 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/ObjectList.java @@ -0,0 +1,587 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.res.Resources; + +import org.distorted.objects.TwistyBandaged2Bar; +import org.distorted.objects.TwistyBandaged3Plate; +import org.distorted.objects.TwistyBandagedEvil; +import org.distorted.objects.TwistyBandagedFused; +import org.distorted.objects.TwistyCube; +import org.distorted.objects.TwistyDiamond; +import org.distorted.objects.TwistyDino4; +import org.distorted.objects.TwistyDino6; +import org.distorted.objects.TwistyHelicopter; +import org.distorted.objects.TwistyIvy; +import org.distorted.objects.TwistyJing; +import org.distorted.objects.TwistyKilominx; +import org.distorted.objects.TwistyMegaminx; +import org.distorted.objects.TwistyMirror; +import org.distorted.objects.TwistyPyraminx; +import org.distorted.objects.TwistyRedi; +import org.distorted.objects.TwistyRex; +import org.distorted.objects.TwistySkewb; +import org.distorted.objects.TwistySquare1; +import org.distorted.objects.TwistySquare2; +import org.distorted.objects.TwistyUltimate; +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.type.Static4D; +import org.distorted.main.R; +import org.distorted.main.RubikActivity; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public enum ObjectList + { + ///////////////////// Size // DB Level // NumScrambles // Mesh // small icon // medium icon // big icon // huge icon + + CUBE ( + new int[][] { + {2 , 12, 12, R.raw.cube2, R.drawable.ui_small_cube2, R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2} , + {3 , 16, 17, R.raw.cube3, R.drawable.ui_small_cube3, R.drawable.ui_medium_cube3, R.drawable.ui_big_cube3, R.drawable.ui_huge_cube3} , + {4 , 20, 24, R.raw.cube4, R.drawable.ui_small_cube4, R.drawable.ui_medium_cube4, R.drawable.ui_big_cube4, R.drawable.ui_huge_cube4} , + {5 , 24, 28, R.raw.cube5, R.drawable.ui_small_cube5, R.drawable.ui_medium_cube5, R.drawable.ui_big_cube5, R.drawable.ui_huge_cube5} + }, + 0 + ), + + JING ( + new int[][] { + {2 , 11, 11, R.raw.jing, R.drawable.ui_small_jing2, R.drawable.ui_medium_jing2, R.drawable.ui_big_jing2, R.drawable.ui_huge_jing2} , + }, + 1 + ), + + PYRA ( + new int[][] { + {3 , 10, 10, R.raw.pyra3, R.drawable.ui_small_pyra3, R.drawable.ui_medium_pyra3, R.drawable.ui_big_pyra3, R.drawable.ui_huge_pyra3} , + {4 , 15, 17, R.raw.pyra4, R.drawable.ui_small_pyra4, R.drawable.ui_medium_pyra4, R.drawable.ui_big_pyra4, R.drawable.ui_huge_pyra4} , + {5 , 20, 23, R.raw.pyra5, R.drawable.ui_small_pyra5, R.drawable.ui_medium_pyra5, R.drawable.ui_big_pyra5, R.drawable.ui_huge_pyra5} + }, + 1 + ), + + KILO ( + new int[][] { + {3 , 18, 18, R.raw.kilo3, R.drawable.ui_small_kilo3, R.drawable.ui_medium_kilo3, R.drawable.ui_big_kilo3, R.drawable.ui_huge_kilo3} , + {5 , 33, 33, R.raw.kilo5, R.drawable.ui_small_kilo5, R.drawable.ui_medium_kilo5, R.drawable.ui_big_kilo5, R.drawable.ui_huge_kilo5} , + }, + 2 + ), + + MEGA ( + new int[][] { + {3 , 21, 21, R.raw.mega3, R.drawable.ui_small_mega3, R.drawable.ui_medium_mega3, R.drawable.ui_big_mega3, R.drawable.ui_huge_mega3} , + {5 , 35, 37, R.raw.mega5, R.drawable.ui_small_mega5, R.drawable.ui_medium_mega5, R.drawable.ui_big_mega5, R.drawable.ui_huge_mega5} , + }, + 2 + ), + + ULTI ( + new int[][] { + {2 , 18, 18, R.raw.ulti, R.drawable.ui_small_ulti, R.drawable.ui_medium_ulti, R.drawable.ui_big_ulti, R.drawable.ui_huge_ulti} , + }, + 3 + ), + + DIAM ( + new int[][] { + {2 , 10, 12, R.raw.diam2, R.drawable.ui_small_diam2, R.drawable.ui_medium_diam2, R.drawable.ui_big_diam2, R.drawable.ui_huge_diam2} , + {3 , 18, 24, R.raw.diam3, R.drawable.ui_small_diam3, R.drawable.ui_medium_diam3, R.drawable.ui_big_diam3, R.drawable.ui_huge_diam3} , + {4 , 32, 32, R.raw.diam4, R.drawable.ui_small_diam4, R.drawable.ui_medium_diam4, R.drawable.ui_big_diam4, R.drawable.ui_huge_diam4} , + }, + 3 + ), + + DINO ( + new int[][] { + {3 , 10, 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} , + }, + 4 + ), + + DIN4 ( + new int[][] { + {3 , 7, 7, R.raw.dino, R.drawable.ui_small_din4, R.drawable.ui_medium_din4, R.drawable.ui_big_din4, R.drawable.ui_huge_din4} , + }, + 4 + ), + + REDI ( + new int[][] { + {3 , 14, 16, R.raw.redi, R.drawable.ui_small_redi, R.drawable.ui_medium_redi, R.drawable.ui_big_redi, R.drawable.ui_huge_redi} , + }, + 4 + ), + + HELI ( + new int[][] { + {3 , 18, 20, R.raw.heli, R.drawable.ui_small_heli, R.drawable.ui_medium_heli, R.drawable.ui_big_heli, R.drawable.ui_huge_heli} , + }, + 4 + ), + + SKEW ( + new int[][] { + {2 , 11, 11, R.raw.skew2, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} , + {3 , 17, 21, R.raw.skew3, R.drawable.ui_small_skewm, R.drawable.ui_medium_skewm, R.drawable.ui_big_skewm, R.drawable.ui_huge_skewm} , + }, + 5 + ), + + IVY ( + new int[][] { + {2 , 8, 8, R.raw.ivy, R.drawable.ui_small_ivy, R.drawable.ui_medium_ivy, R.drawable.ui_big_ivy, R.drawable.ui_huge_ivy} , + }, + 5 + ), + + REX ( + new int[][] { + {3 , 16, 19, R.raw.rex, R.drawable.ui_small_rex, R.drawable.ui_medium_rex, R.drawable.ui_big_rex, R.drawable.ui_huge_rex} , + }, + 5 + ), + + BAN1 ( + new int[][] { + {3 , 16, 16, R.raw.ban1, R.drawable.ui_small_ban1, R.drawable.ui_medium_ban1, R.drawable.ui_big_ban1, R.drawable.ui_huge_ban1} , + }, + 6 + ), + + BAN2 ( + new int[][] { + {3 , 16, 16, R.raw.ban2, R.drawable.ui_small_ban2, R.drawable.ui_medium_ban2, R.drawable.ui_big_ban2, R.drawable.ui_huge_ban2} , + }, + 6 + ), + + BAN3 ( + new int[][] { + {3 , 16, 16, R.raw.ban3, R.drawable.ui_small_ban3, R.drawable.ui_medium_ban3, R.drawable.ui_big_ban3, R.drawable.ui_huge_ban3} , + }, + 6 + ), + + BAN4 ( + new int[][] { + {3 , 16, 16, R.raw.ban4, R.drawable.ui_small_ban4, R.drawable.ui_medium_ban4, R.drawable.ui_big_ban4, R.drawable.ui_huge_ban4} , + }, + 6 + ), + + SQU1 ( + new int[][] { + {3 , 24, 24, R.raw.square1, R.drawable.ui_small_square1, R.drawable.ui_medium_square1, R.drawable.ui_big_square1, R.drawable.ui_huge_square1} , + }, + 7 + ), + + SQU2 ( + new int[][] { + {3 , 24, 24, R.raw.square2, R.drawable.ui_small_square2, R.drawable.ui_medium_square2, R.drawable.ui_big_square2, R.drawable.ui_huge_square2} , + }, + 7 + ), + + MIRR ( + new int[][] { + {2 , 12, 12, R.raw.mirr2, R.drawable.ui_small_mirr2, R.drawable.ui_medium_mirr2, R.drawable.ui_big_mirr2, R.drawable.ui_huge_mirr2} , + {3 , 16, 17, R.raw.mirr3, R.drawable.ui_small_mirr3, R.drawable.ui_medium_mirr3, R.drawable.ui_big_mirr3, R.drawable.ui_huge_mirr3} , + }, + 7 + ), + ; + + public static final int NUM_OBJECTS = values().length; + public static final int MAX_NUM_OBJECTS; + public static final int MAX_LEVEL; + public static final int MAX_SCRAMBLE; + public static final int MAX_OBJECT_SIZE; + + private final int[] mObjectSizes, mDBLevels, mNumScrambles, mSmallIconIDs, mMediumIconIDs, mBigIconIDs, mHugeIconIDs, mResourceIDs; + private final int mRow, mNumSizes; + + private static final ObjectList[] objects; + private static int mNumAll; + private static int[] mIndices; + private static int mColCount, mRowCount; + + static + { + mNumAll = 0; + int num, i = 0; + objects = new ObjectList[NUM_OBJECTS]; + int maxNum = Integer.MIN_VALUE; + int maxLevel = Integer.MIN_VALUE; + int maxScramble= Integer.MIN_VALUE; + int maxSize = Integer.MIN_VALUE; + + for(ObjectList object: ObjectList.values()) + { + objects[i] = object; + i++; + num = object.mObjectSizes.length; + mNumAll += num; + if( num> maxNum ) maxNum = num; + + for(int j=0; j maxScramble ) maxScramble= object.mNumScrambles[j]; + if( object.mDBLevels[j] > maxLevel ) maxLevel = object.mDBLevels[j]; + if( object.mObjectSizes[j] > maxSize ) maxSize = object.mObjectSizes[j]; + } + } + + MAX_NUM_OBJECTS = maxNum; + MAX_LEVEL = maxLevel; + MAX_SCRAMBLE = maxScramble; + MAX_OBJECT_SIZE = maxSize; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void setUpColAndRow() + { + mIndices = new int[NUM_OBJECTS]; + mRowCount= 0; + + for(int obj=0; obj=mRowCount ) mRowCount = mIndices[obj]+1; + } + + mColCount = 0; + + for(int row=0; rowmColCount ) mColCount = numObjects; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int computeNumObjectsInRow(int row) + { + int num=0; + + for(int object=0; object=0 && ordinal0 ) + { + String name = obj.substring(0,u); + int size = Integer.parseInt( obj.substring(u+1,l) ); + + for(int i=0; i0 || j>0 ) list.append(','); + list.append(name); + list.append('_'); + list.append(sizes[j]); + } + } + + return list.toString(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getTotal() + { + return mNumAll; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getDBLevel(int ordinal, int sizeIndex) + { + if( ordinal>=0 && ordinal=0 && sizeIndex=0 && ordinal=0 && sizeIndex=0 && ordinal. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class ObjectShape + { + private final double[][] mVertices; + private final int[][] mVertIndices; + private final float[][] mBands; + private final int[] mBandIndices; + private final float[][] mCorners; + private final int[] mCornerIndices; + private final float[][] mCenters; + private final int[] mCenterIndices; + private final int mNumComponents; + private final float[] mConvexityCenter; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ObjectShape(double[][] vertices, int[][] vertIndices, float[][] bands, int[] bandIndices, + float[][] corners, int[] cornIndices, float[][] centers, int[] centIndices, + int numComponents, float[] convexityCenter) + { + mVertices = vertices; + mVertIndices = vertIndices; + mBands = bands; + mBandIndices = bandIndices; + mCorners = corners; + mCornerIndices = cornIndices; + mCenters = centers; + mCenterIndices = centIndices; + mNumComponents = numComponents; + mConvexityCenter = convexityCenter; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public double[][] getVertices() + { + return mVertices; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int[][] getVertIndices() + { + return mVertIndices; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[][] getBands() + { + return mBands; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int[] getBandIndices() + { + return mBandIndices; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[][] getCorners() + { + return mCorners; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int[] getCornerIndices() + { + return mCornerIndices; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[][] getCenters() + { + return mCenters; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int[] getCenterIndices() + { + return mCenterIndices; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int getNumComponents() + { + return mNumComponents; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[] getConvexityCenter() + { + return mConvexityCenter; + } + } diff --git a/src/main/java/org/distorted/objectlb/ObjectSticker.java b/src/main/java/org/distorted/objectlb/ObjectSticker.java new file mode 100644 index 00000000..b0ac746a --- /dev/null +++ b/src/main/java/org/distorted/objectlb/ObjectSticker.java @@ -0,0 +1,68 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2021 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class ObjectSticker + { + private final float[] mCoords; + private final float[] mCurvature; + private final float[] mRadii; + private final float mStroke; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ObjectSticker(float[] coords, float[] curvature, float[] radii, float stroke) + { + mCoords = coords; + mCurvature = curvature; + mRadii = radii; + mStroke = stroke; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[] getCoords() + { + return mCoords; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[] getCurvature() + { + return mCurvature; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float[] getRadii() + { + return mRadii; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float getStroke() + { + return mStroke; + } + } diff --git a/src/main/java/org/distorted/objectlb/QuatHelper.java b/src/main/java/org/distorted/objectlb/QuatHelper.java new file mode 100644 index 00000000..d06f10a3 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/QuatHelper.java @@ -0,0 +1,163 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2021 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class QuatHelper + { +/////////////////////////////////////////////////////////////////////////////////////////////////// +// return quat1*quat2 + + public static Static4D quatMultiply( Static4D quat1, Static4D quat2 ) + { + float qx = quat1.get0(); + float qy = quat1.get1(); + float qz = quat1.get2(); + float qw = quat1.get3(); + + float rx = quat2.get0(); + float ry = quat2.get1(); + float rz = quat2.get2(); + float rw = quat2.get3(); + + float tx = rw*qx - rz*qy + ry*qz + rx*qw; + float ty = rw*qy + rz*qx + ry*qw - rx*qz; + float tz = rw*qz + rz*qw - ry*qx + rx*qy; + float tw = rw*qw - rz*qz - ry*qy - rx*qx; + + return new Static4D(tx,ty,tz,tw); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// rotate 'vector' by quat ( i.e. return quat*vector*(quat^-1) ) + + public static Static4D rotateVectorByQuat(Static4D vector, Static4D quat) + { + float qx = quat.get0(); + float qy = quat.get1(); + float qz = quat.get2(); + float qw = quat.get3(); + + Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); + Static4D tmp = quatMultiply(quat,vector); + + return quatMultiply(tmp,quatInverted); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// rotate 'vector' by quat^(-1) ( i.e. return (quat^-1)*vector*quat ) + + public static Static4D rotateVectorByInvertedQuat(Static4D vector, Static4D quat) + { + float qx = quat.get0(); + float qy = quat.get1(); + float qz = quat.get2(); + float qw = quat.get3(); + + Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); + Static4D tmp = quatMultiply(quatInverted,vector); + + return quatMultiply(tmp,quat); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static Static4D quatFromDrag(float dragX, float dragY) + { + float axisX = dragY; // inverted X and Y - rotation axis is perpendicular to (dragX,dragY) + float axisY = dragX; // Why not (-dragY, dragX) ? because Y axis is also inverted! + float axisZ = 0; + float axisL = (float)Math.sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ); + + if( axisL>0 ) + { + axisX /= axisL; + axisY /= axisL; + axisZ /= axisL; + + float ratio = axisL; + ratio = ratio - (int)ratio; // the cos() is only valid in (0,Pi) + + float cosA = (float)Math.cos(Math.PI*ratio); + float sinA = (float)Math.sqrt(1-cosA*cosA); + + return new Static4D(axisX*sinA, axisY*sinA, axisZ*sinA, cosA); + } + + return new Static4D(0f, 0f, 0f, 1f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static double computeCos(double oldX, double oldY, double newX, double newY, double len1, double len2) + { + double ret= (oldX*newX+oldY*newY) / (len1*len2); + if( ret<-1.0 ) return -1.0; + if( ret> 1.0 ) return 1.0; + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// sin of (signed!) angle between vectors 'old' and 'new', counterclockwise! + + public static double computeSin(double oldX, double oldY, double newX, double newY, double len1, double len2) + { + double ret= (newX*oldY-oldX*newY) / (len1*len2); + if( ret<-1.0 ) return -1.0; + if( ret> 1.0 ) return 1.0; + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// return quat Q that turns 3D vector A=(ax,ay,az) to another 3D vector B=(bx,by,bz) +// take care of double-cover by ensuring that always Q.get3() >=0 + + public static Static4D retRotationQuat(float ax, float ay, float az, float bx, float by, float bz) + { + float nx = ay*bz - az*by; + float ny = az*bx - ax*bz; + float nz = ax*by - ay*bx; + + float sin = (float)Math.sqrt(nx*nx + ny*ny + nz*nz); + float cos = ax*bx + ay*by + az*bz; + + if( sin!=0 ) + { + nx /= sin; + ny /= sin; + nz /= sin; + } + + // Why sin<=0 and cos>=0 ? + // 0 0 both sin and cos are positive. + // But1: quats work counterclockwise -> negate cos. + // But2: double-cover, we prefer to have the cos positive (so that unit=(0,0,0,1)) + // so negate again both cos and sin. + float sinHalf =-(float)Math.sqrt((1-cos)/2); + float cosHalf = (float)Math.sqrt((1+cos)/2); + + return new Static4D(nx*sinHalf,ny*sinHalf,nz*sinHalf,cosHalf); + } + } diff --git a/src/main/java/org/distorted/objectlb/ScrambleState.java b/src/main/java/org/distorted/objectlb/ScrambleState.java new file mode 100644 index 00000000..0efbf652 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/ScrambleState.java @@ -0,0 +1,141 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2021 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import java.util.Random; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class ScrambleState +{ + private final int mTotal, mNumAxis; + private final int[] mNum; + private final int[] mInfo; + private final int[] mTmp; + private final int LEN = 4; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ScrambleState(int[][] axis) + { + mTmp = new int[LEN]; + + mNumAxis = axis.length; + mNum = new int[mNumAxis]; + int total =0; + + for(int i=0; imax ) max=value; + } + } + + for(int i=0; i=0 && indexExcluded. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// producer of the ScrambleStateGraph - but only for a single Twisty Puzzle, the 'BandagedEvil'. + +import java.util.ArrayList; + +public class ScrambleStateBandagedEvil +{ + private static final int INVALID_MOVE = -1; + + private static final int CORNER_S = 0; + private static final int CORNER_X = 1; + private static final int CORNER_Y = 2; + private static final int CORNER_Z = 3; + + private static final int CENTER_0 = 0; + private static final int CENTER_1 = 1; + private static final int CENTER_2 = 2; + private static final int CENTER_3 = 3; + + private int mID; + private final int[] mMoves; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ScrambleStateBandagedEvil(int id) + { + mID = id; + mMoves = createMoves(mID); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void computeGraph() + { + ArrayList graph; + + int id = 0; + int id1 = setCenter(id , CENTER_2, 0); + int id2 = setCenter(id1 , CENTER_2, 1); + int id3 = setCenter(id2 , CENTER_3, 2); + int id4 = setCenter(id3 , CENTER_2, 3); + + int id5 = setCorner(id4 , CORNER_X, 0); + int id6 = setCorner(id5 , CORNER_Y, 1); + int id7 = setCorner(id6 , CORNER_X, 2); + int id8 = setCorner(id7 , CORNER_Z, 3); + int id9 = setCorner(id8 , CORNER_Y, 4); + int id10= setCorner(id9 , CORNER_Y, 5); + int id11= setCorner(id10, CORNER_S, 6); + int id12= setCorner(id11, CORNER_Z, 7); + + ScrambleStateBandagedEvil bsg = new ScrambleStateBandagedEvil(id12); + graph = new ArrayList<>(); + graph.add(bsg); + + insertChildren(graph,id12); + pruneGraph(graph); + remapGraph(graph); + + int num = graph.size(); + android.util.Log.e("D", "\n"+num+" states\n"); + + for(int i=0; i list, int id) + { + ScrambleStateBandagedEvil bsg = findState(list,id); + + if( bsg==null ) + { + android.util.Log.e("D", "error: "+id+" doesn't exist"); + return; + } + + for(int i=0; i<12; i++) + { + int move = bsg.getMove(i); + + if( move!=INVALID_MOVE ) + { + ScrambleStateBandagedEvil tmp = findState(list,move); + + if( tmp==null ) + { + tmp = new ScrambleStateBandagedEvil(move); + list.add(tmp); + insertChildren(list,move); + } + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void pruneGraph(ArrayList list) + { + int num = list.size(), numAxis; + boolean pruned = false; + ScrambleStateBandagedEvil bsg; + + for(int i=0; i list) + { + int id, num = list.size(); + ScrambleStateBandagedEvil bsg; + + for(int i=0; i list, int id, int newId) + { + ScrambleStateBandagedEvil bsg; + int size = list.size(); + + for(int i=0; i list, int id) + { + ScrambleStateBandagedEvil bsg; + int num = list.size(); + + for(int i=0; i=0 && index<12) ? mMoves[index] : -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int numAxis() + { + int num = 0; + + if( mMoves[ 0]!=INVALID_MOVE || mMoves[ 1]!=INVALID_MOVE || mMoves[ 2]!=INVALID_MOVE ) num++; + if( mMoves[ 3]!=INVALID_MOVE || mMoves[ 4]!=INVALID_MOVE || mMoves[ 5]!=INVALID_MOVE ) num++; + if( mMoves[ 6]!=INVALID_MOVE || mMoves[ 7]!=INVALID_MOVE || mMoves[ 8]!=INVALID_MOVE ) num++; + if( mMoves[ 9]!=INVALID_MOVE || mMoves[10]!=INVALID_MOVE || mMoves[11]!=INVALID_MOVE ) num++; + + return num; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void setMove(int index, int newMove) + { + if( index>=0 && index<12 ) mMoves[index] = newMove; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static String debug(int id) + { + int ce0 = getCenter(id,0); + int ce1 = getCenter(id,1); + int ce2 = getCenter(id,2); + int ce3 = getCenter(id,3); + + int co0 = getCorner(id,0); + int co1 = getCorner(id,1); + int co2 = getCorner(id,2); + int co3 = getCorner(id,3); + int co4 = getCorner(id,4); + int co5 = getCorner(id,5); + int co6 = getCorner(id,6); + int co7 = getCorner(id,7); + + String center = centerString(ce0) + centerString(ce1) + centerString(ce2) + centerString(ce3); + String corner = cornerString(co0) + cornerString(co1) + cornerString(co2) + cornerString(co3) + + cornerString(co4) + cornerString(co5) + cornerString(co6) + cornerString(co7); + + return center + " -" + corner; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static String centerString(int center) + { + return " "+center; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static String cornerString(int corner) + { + switch(corner) + { + case CORNER_S: return " S"; + case CORNER_X: return " X"; + case CORNER_Y: return " Y"; + case CORNER_Z: return " Z"; + } + + return "?"; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int[] createMoves(int id) + { + int[] ret = new int[12]; + + boolean moveX = xPossible(id); + boolean moveY = yPossible(id); + boolean moveZ0 = z0Possible(id); + boolean moveZ2 = z2Possible(id); + + if( moveX ) createXmoves(id,ret); + else { ret[ 0] = INVALID_MOVE; ret[ 1] = INVALID_MOVE; ret[ 2] = INVALID_MOVE; } + if( moveY ) createYmoves(id,ret); + else { ret[ 3] = INVALID_MOVE; ret[ 4] = INVALID_MOVE; ret[ 5] = INVALID_MOVE; } + if( moveZ0) createZ0moves(id,ret); + else { ret[ 6] = INVALID_MOVE; ret[ 7] = INVALID_MOVE; ret[ 8] = INVALID_MOVE; } + if( moveZ2) createZ2moves(id,ret); + else { ret[ 9] = INVALID_MOVE; ret[10] = INVALID_MOVE; ret[11] = INVALID_MOVE; } + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static boolean xPossible(int id) + { + if( getCorner(id,4)==CORNER_X ) return false; + if( getCorner(id,5)==CORNER_X ) return false; + if( getCorner(id,6)==CORNER_X ) return false; + if( getCorner(id,7)==CORNER_X ) return false; + + if( getCenter(id,1)==CENTER_1 ) return false; + if( getCenter(id,2)==CENTER_1 ) return false; + if( getCenter(id,3)==CENTER_1 ) return false; + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static boolean yPossible(int id) + { + if( getCorner(id,2)==CORNER_Y ) return false; + if( getCorner(id,3)==CORNER_Y ) return false; + if( getCorner(id,6)==CORNER_Y ) return false; + if( getCorner(id,7)==CORNER_Y ) return false; + + if( getCenter(id,0)==CENTER_0 ) return false; + if( getCenter(id,2)==CENTER_0 ) return false; + if( getCenter(id,3)==CENTER_0 ) return false; + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static boolean z0Possible(int id) + { + if( getCorner(id,0)==CORNER_Z ) return false; + if( getCorner(id,2)==CORNER_Z ) return false; + if( getCorner(id,4)==CORNER_Z ) return false; + if( getCorner(id,6)==CORNER_Z ) return false; + + if( getCenter(id,0)==CENTER_1 ) return false; + if( getCenter(id,1)==CENTER_0 ) return false; + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static boolean z2Possible(int id) + { + if( getCorner(id,1)==CORNER_Z ) return false; + if( getCorner(id,3)==CORNER_Z ) return false; + if( getCorner(id,5)==CORNER_Z ) return false; + if( getCorner(id,7)==CORNER_Z ) return false; + + if( getCenter(id,0)==CENTER_3 ) return false; + if( getCenter(id,1)==CENTER_2 ) return false; + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int getCorner(int id, int index) + { + return (id>>(14-2*index))&3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int getCenter(int id, int index) + { + return (id>>(22-2*index))&3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int setCorner(int id, int corner, int index) + { + return id + ((corner-getCorner(id,index))<<(14-2*index)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int setCenter(int id, int center, int index) + { + return id + ((center-getCenter(id,index))<<(22-2*index)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void createXmoves(int id, int[] moves) + { + int id1 = rotateX(id); + moves[0] = id1; + int id2 = rotateX(id1); + moves[1] = id2; + int id3 = rotateX(id2); + moves[2] = id3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void createYmoves(int id, int[] moves) + { + int id1 = rotateY(id); + moves[3] = id1; + int id2 = rotateY(id1); + moves[4] = id2; + int id3 = rotateY(id2); + moves[5] = id3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void createZ0moves(int id, int[] moves) + { + int id1 = rotateZ0(id); + moves[6] = id1; + int id2 = rotateZ0(id1); + moves[7] = id2; + int id3 = rotateZ0(id2); + moves[8] = id3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static void createZ2moves(int id, int[] moves) + { + int id1 = rotateZ2(id); + moves[ 9] = id1; + int id2 = rotateZ2(id1); + moves[10] = id2; + int id3 = rotateZ2(id2); + moves[11] = id3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotateX(int id) + { + int newCorner4 = rotCornerX(getCorner(id,5)); + int newCorner5 = rotCornerX(getCorner(id,7)); + int newCorner6 = rotCornerX(getCorner(id,4)); + int newCorner7 = rotCornerX(getCorner(id,6)); + int newCenter = rotCenter (getCenter(id,0)); + + int id1 = setCorner(id ,newCorner4,4); + int id2 = setCorner(id1,newCorner5,5); + int id3 = setCorner(id2,newCorner6,6); + int id4 = setCorner(id3,newCorner7,7); + int id5 = setCenter(id4,newCenter ,0); + + return id5; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotateY(int id) + { + int newCorner2 = rotCornerY(getCorner(id,6)); + int newCorner3 = rotCornerY(getCorner(id,2)); + int newCorner6 = rotCornerY(getCorner(id,7)); + int newCorner7 = rotCornerY(getCorner(id,3)); + int newCenter = rotCenter (getCenter(id,1)); + + int id1 = setCorner(id ,newCorner2,2); + int id2 = setCorner(id1,newCorner3,3); + int id3 = setCorner(id2,newCorner6,6); + int id4 = setCorner(id3,newCorner7,7); + int id5 = setCenter(id4,newCenter ,1); + + return id5; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotateZ0(int id) + { + int newCorner0 = rotCornerZ(getCorner(id,2)); + int newCorner2 = rotCornerZ(getCorner(id,6)); + int newCorner4 = rotCornerZ(getCorner(id,0)); + int newCorner6 = rotCornerZ(getCorner(id,4)); + int newCenter = rotCenter (getCenter(id,2)); + + int id1 = setCorner(id ,newCorner0,0); + int id2 = setCorner(id1,newCorner2,2); + int id3 = setCorner(id2,newCorner4,4); + int id4 = setCorner(id3,newCorner6,6); + int id5 = setCenter(id4,newCenter ,2); + + return id5; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotateZ2(int id) + { + int newCorner1 = rotCornerZ(getCorner(id,3)); + int newCorner3 = rotCornerZ(getCorner(id,7)); + int newCorner5 = rotCornerZ(getCorner(id,1)); + int newCorner7 = rotCornerZ(getCorner(id,5)); + int newCenter = rotCenter (getCenter(id,3)); + + int id1 = setCorner(id ,newCorner1,1); + int id2 = setCorner(id1,newCorner3,3); + int id3 = setCorner(id2,newCorner5,5); + int id4 = setCorner(id3,newCorner7,7); + int id5 = setCenter(id4,newCenter ,3); + + return id5; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotCornerX(int corner) + { + switch(corner) + { + case CORNER_S: return CORNER_S; + case CORNER_X: android.util.Log.e("DIST", "rotateX: ERROR"); + return CORNER_S; + case CORNER_Y: return CORNER_Z; + case CORNER_Z: return CORNER_Y; + } + + return CORNER_S; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotCornerY(int corner) + { + switch(corner) + { + case CORNER_S: return CORNER_S; + case CORNER_X: return CORNER_Z; + case CORNER_Y: android.util.Log.e("DIST", "rotateY: ERROR"); + return CORNER_S; + case CORNER_Z: return CORNER_X; + } + + return CORNER_S; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotCornerZ(int corner) + { + switch(corner) + { + case CORNER_S: return CORNER_S; + case CORNER_X: return CORNER_Y; + case CORNER_Y: return CORNER_X; + case CORNER_Z: android.util.Log.e("DIST", "rotateZ: ERROR"); + return CORNER_S; + } + + return CORNER_S; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private static int rotCenter(int center) + { + switch(center) + { + case CENTER_0: return CENTER_3; + case CENTER_1: return CENTER_0; + case CENTER_2: return CENTER_1; + case CENTER_3: return CENTER_2; + } + + return CENTER_0; + } +} diff --git a/src/main/java/org/distorted/objectlb/ScrambleStateSquare1.java b/src/main/java/org/distorted/objectlb/ScrambleStateSquare1.java new file mode 100644 index 00000000..99dd997b --- /dev/null +++ b/src/main/java/org/distorted/objectlb/ScrambleStateSquare1.java @@ -0,0 +1,593 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2021 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import java.util.ArrayList; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// producer of the ScrambleStateGraph - but only for a single Twisty Puzzle, the 'Square-1'. + +public class ScrambleStateSquare1 +{ + private static final int INVALID_MOVE = -1; + private static final int NUM_MOVES = 23; + + private int mDist; + private boolean mFresh; + private long mID; + private final long[] mMoves; + + private final int[][] mPermittedAngles; + private final int[] mCornerQuat, mTmp; + + // QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]] + static final int[][] QUAT_MULT = new int[][] + { + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,}, + { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,}, + { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,}, + { 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,}, + { 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,}, + { 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,}, + { 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,}, + { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,}, + { 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,}, + { 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,}, + { 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,}, + { 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,}, + { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,}, + { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,}, + { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3,}, + { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4,}, + { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5,}, + { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6,}, + { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7,}, + { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8,}, + { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9,}, + { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10,}, + { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11,}, + { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,} + }; + + // quat indices that make corner cubits bandage the puzzle. + private static final int[][] BAD_CORNER_QUATS = new int[][] + { + { 2, 8,17,23}, + { 5,11,14,20}, + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ScrambleStateSquare1(long id, int dist) + { + mCornerQuat = new int[8]; + mTmp = new int[8]; + mPermittedAngles = new int[2][12]; + + mDist = dist; + mFresh = true; + mID = id; + mMoves = createMoves(mID); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void setNotFresh() + { + mFresh = false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean isFresh() + { + return mFresh; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void computeGraph() + { + ArrayList graph; + + ScrambleStateSquare1 bsg = new ScrambleStateSquare1(0,0); + graph = new ArrayList<>(); + graph.add(bsg); + +android.util.Log.e("D", "INSERTING"); + + insertChildren(graph,0); + +//android.util.Log.e("D", "PRUNING "+graph.size()); + +// pruneGraph(graph); + +android.util.Log.e("D", "REMAPPING "+graph.size()); + + remapGraph(graph); + + int num = graph.size(); + android.util.Log.e("D", "\n"+num+" states\n"); + + for(int i=0; i list, long id) + { + ScrambleStateSquare1 bsg = findState(list,id); + + if( bsg==null ) + { + android.util.Log.e("D", "error: "+id+" doesn't exist"); + return; + } + + int dist = bsg.mDist; + if( dist>6 ) return; + + for(int i=0; i list) + { + int num = list.size(), numAxis; + boolean pruned = false; + ScrambleStateSquare1 bsg; + + for(int i=0; i list) + { + long id; + int num = list.size(); + ScrambleStateSquare1 bsg; + + for(int i=0; i list, long id, long newId) + { + ScrambleStateSquare1 bsg; + int size = list.size(); + + for(int i=0; i list, long id) + { + ScrambleStateSquare1 bsg; + int num = list.size(); + + for(int i=0; i=0 && index=0 && index=12)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean cornerIsLeft(int index) + { + int q = mCornerQuat[index]; + + switch(index) + { + case 0: + case 4: return ((q>=3 && q<= 7) || (q>=18 && q<=22)); + case 1: + case 5: return ((q>=6 && q<=10) || (q>=15 && q<=19)); + case 2: + case 6: return ((q==0 || q==1 || (q>=9 && q<=11)) || (q>=12 && q<=16)); + case 3: + case 7: return ((q>=0 && q<=4) || (q==12 || q==13 || (q>=21 && q<=23))); + } + + return false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int makeQuat(int axis,int index) + { + if( axis==1 ) return 13; + if( index<0 ) index+=12; + return index; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean cornerBelongs(int index, int axis, int layer) + { + if( axis==0 ) + { + boolean up = cornerIsUp(index); + return ((up && layer==2) || (!up && layer==0)); + } + else + { + boolean le = cornerIsLeft(index); + return ((le && layer==0) || (!le && layer==1)); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private long updateCornerQuats(int axis, int layer, int index) + { + int quat = makeQuat(axis,index); + + for(int corner=0; corner<8; corner++) + { + if( cornerBelongs(corner,axis,layer) ) + { + int curr = mCornerQuat[corner]; + mTmp[corner] = QUAT_MULT[quat][curr]; + } + else + { + mTmp[corner] = mCornerQuat[corner]; + } + } + + return returnID(mTmp); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean quatIsBad(int quatIndex, int corner) + { + int index = (corner%2); + + return ( quatIndex==BAD_CORNER_QUATS[index][0] || + quatIndex==BAD_CORNER_QUATS[index][1] || + quatIndex==BAD_CORNER_QUATS[index][2] || + quatIndex==BAD_CORNER_QUATS[index][3] ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int isPermittedDo(int angle) + { + for(int corner=0; corner<8; corner++) + { + if( !cornerIsUp(corner) ) + { + int currQuat = mCornerQuat[corner]; + int finalQuat= QUAT_MULT[angle][currQuat]; + if( quatIsBad(finalQuat,corner) ) return 0; + } + } + + return 1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int isPermittedUp(int angle) + { + for(int corner=0; corner<8; corner++) + { + if( cornerIsUp(corner) ) + { + int currQuat = mCornerQuat[corner]; + int finalQuat= QUAT_MULT[angle][currQuat]; + if( quatIsBad(finalQuat,corner) ) return 0; + } + } + + return 1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void computePermittedAngles() + { + for(int angle=0; angle<12; angle++) + { + mPermittedAngles[0][angle] = isPermittedDo(angle); + mPermittedAngles[1][angle] = isPermittedUp(angle); + } + } +} diff --git a/src/main/java/org/distorted/objectlb/Twisty12.java b/src/main/java/org/distorted/objectlb/Twisty12.java new file mode 100644 index 00000000..bebc8fad --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Twisty12.java @@ -0,0 +1,95 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.res.Resources; + +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Twisty12 extends TwistyObject +{ + static final int MINX_LGREEN = 0xff53aa00; + static final int MINX_PINK = 0xfffd7ab7; + static final int MINX_SANDY = 0xffefd48b; + static final int MINX_LBLUE = 0xff00a2d7; + static final int MINX_ORANGE = 0xffff6200; + static final int MINX_VIOLET = 0xff7d59a4; + static final int MINX_DGREEN = 0xff007a47; + static final int MINX_DRED = 0xffbd0000; + static final int MINX_DBLUE = 0xff1a29b2; + static final int MINX_DYELLOW= 0xffffc400; + static final int MINX_WHITE = 0xffffffff; + static final int MINX_GREY = 0xff727c7b; + + static final int[] FACE_COLORS = new int[] + { + MINX_LGREEN, MINX_PINK , MINX_SANDY , MINX_LBLUE, + MINX_ORANGE, MINX_VIOLET , MINX_DGREEN, MINX_DRED , + MINX_DBLUE , MINX_DYELLOW, MINX_WHITE , MINX_GREY + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Twisty12(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) + { + super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getColor(int face) + { + return FACE_COLORS[face]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getNumFaceColors() + { + return 12; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getFOV() + { + return 30; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float getScreenRatio() + { + return 0.35f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float returnMultiplier() + { + return 1.0f; + } +} diff --git a/src/main/java/org/distorted/objectlb/Twisty4.java b/src/main/java/org/distorted/objectlb/Twisty4.java new file mode 100644 index 00000000..26b6a1b8 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Twisty4.java @@ -0,0 +1,81 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.res.Resources; + +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Twisty4 extends TwistyObject +{ + private static final int[] FACE_COLORS = new int[] + { + COLOR_GREEN , COLOR_YELLOW, + COLOR_BLUE , COLOR_RED + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Twisty4(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) + { + super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getColor(int face) + { + return FACE_COLORS[face]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getNumFaceColors() + { + return 4; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getFOV() + { + return 30; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float getScreenRatio() + { + return 0.88f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float returnMultiplier() + { + return getNumLayers()/(SQ6/3); + } +} diff --git a/src/main/java/org/distorted/objectlb/Twisty6.java b/src/main/java/org/distorted/objectlb/Twisty6.java new file mode 100644 index 00000000..4adb102b --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Twisty6.java @@ -0,0 +1,82 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.res.Resources; + +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Twisty6 extends TwistyObject +{ + private static final int[] FACE_COLORS = new int[] + { + COLOR_YELLOW, COLOR_WHITE, + COLOR_BLUE , COLOR_GREEN, + COLOR_RED , COLOR_ORANGE + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Twisty6(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) + { + super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getColor(int face) + { + return FACE_COLORS[face]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getNumFaceColors() + { + return 6; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getFOV() + { + return 60; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float getScreenRatio() + { + return 0.5f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float returnMultiplier() + { + return getNumLayers(); + } +} diff --git a/src/main/java/org/distorted/objectlb/Twisty8.java b/src/main/java/org/distorted/objectlb/Twisty8.java new file mode 100644 index 00000000..cb49f095 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/Twisty8.java @@ -0,0 +1,83 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.res.Resources; + +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Twisty8 extends TwistyObject +{ + private static final int[] FACE_COLORS = new int[] + { + COLOR_ORANGE, COLOR_VIOLET, + COLOR_WHITE , COLOR_BLUE , + COLOR_YELLOW, COLOR_RED , + COLOR_GREEN , COLOR_GREY + }; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Twisty8(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) + { + super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getColor(int face) + { + return FACE_COLORS[face]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getNumFaceColors() + { + return 8; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getFOV() + { + return 60; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float getScreenRatio() + { + return 0.65f; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float returnMultiplier() + { + return 1.5f; + } +} diff --git a/src/main/java/org/distorted/objectlb/TwistyObject.java b/src/main/java/org/distorted/objectlb/TwistyObject.java new file mode 100644 index 00000000..089f1277 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/TwistyObject.java @@ -0,0 +1,1314 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import android.content.SharedPreferences; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Paint; + +import com.google.firebase.crashlytics.FirebaseCrashlytics; + +import org.distorted.library.effect.Effect; +import org.distorted.library.effect.MatrixEffectMove; +import org.distorted.library.effect.MatrixEffectQuaternion; +import org.distorted.library.effect.MatrixEffectScale; +import org.distorted.library.effect.VertexEffectQuaternion; +import org.distorted.library.effect.VertexEffectRotate; +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedLibrary; +import org.distorted.library.main.DistortedNode; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshBase; +import org.distorted.library.mesh.MeshFile; +import org.distorted.library.mesh.MeshJoined; +import org.distorted.library.mesh.MeshSquare; +import org.distorted.library.message.EffectListener; +import org.distorted.library.type.Dynamic1D; +import org.distorted.library.type.Static1D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; +import org.distorted.main.BuildConfig; + +import java.io.DataInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Random; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class TwistyObject extends DistortedNode + { + public static final int COLOR_YELLOW = 0xffffff00; + public static final int COLOR_WHITE = 0xffffffff; + public static final int COLOR_BLUE = 0xff0000ff; + public static final int COLOR_GREEN = 0xff00bb00; + public static final int COLOR_RED = 0xff990000; + public static final int COLOR_ORANGE = 0xffff6200; + public static final int COLOR_GREY = 0xff727c7b; + public static final int COLOR_VIOLET = 0xff7700bb; + public static final int COLOR_BLACK = 0xff000000; + + public static final int TEXTURE_HEIGHT = 256; + static final int NUM_STICKERS_IN_ROW = 4; + + public static final float SQ2 = (float)Math.sqrt(2); + public static final float SQ3 = (float)Math.sqrt(3); + public static final float SQ5 = (float)Math.sqrt(5); + public static final float SQ6 = (float)Math.sqrt(6); + + private static final float NODE_RATIO = 1.60f; + private static final float MAX_SIZE_CHANGE = 1.35f; + private static final float MIN_SIZE_CHANGE = 0.75f; + + private static final Static3D CENTER = new Static3D(0,0,0); + private static final int POST_ROTATION_MILLISEC = 500; + + protected final int NUM_FACE_COLORS; + protected final int NUM_TEXTURES; + protected final Cubit[] CUBITS; + + MeshBase[] mMeshes; + final Static4D[] OBJECT_QUATS; + final int NUM_CUBITS; + final int NUM_AXIS; + final int NUM_QUATS; + + private final int mNumCubitFaces; + private final Static3D[] mAxis; + private final float[][] mCuts; + private final int[] mNumCuts; + private final int mNodeSize; + private final float[][] mOrigPos; + private final Static3D mNodeScale; + private final Static4D mQuat; + private final int mNumLayers, mRealSize; + private final ObjectList mList; + private final DistortedEffects mEffects; + private final VertexEffectRotate mRotateEffect; + private final Dynamic1D mRotationAngle; + private final Static3D mRotationAxis; + private final Static3D mObjectScale; + private final int[] mQuatDebug; + private final float mCameraDist; + private final Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal; + private final DistortedTexture mTexture; + private final float mInitScreenRatio; + private final int mSolvedFunctionIndex; + private final boolean mIsBandaged; + private float mObjectScreenRatio; + private int[][] mSolvedQuats; + private int[][] mQuatMult; + private int[] mTmpQuats; + private int mNumTexRows, mNumTexCols; + private int mRotRowBitmap; + private int mRotAxis; + private MeshBase mMesh; + private final TwistyObjectScrambler mScrambler; + + //////////////////// SOLVED1 //////////////////////// + + private int[] mFaceMap; + private int[][] mScramble; + private int[] mColors; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + TwistyObject(int numLayers, int realSize, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh, + DistortedEffects nodeEffects, int[][] moves, ObjectList list, Resources res, int screenWidth) + { + super(nodeTexture,nodeEffects,nodeMesh); + + mNodeSize = screenWidth; + + resizeFBO(mNodeSize, (int)(NODE_RATIO*mNodeSize)); + + mNumLayers = numLayers; + mRealSize = realSize; + mList = list; + mOrigPos = getCubitPositions(mNumLayers); + mAxis = getRotationAxis(); + mInitScreenRatio = getScreenRatio(); + mObjectScreenRatio = 1.0f; + mNumCubitFaces = getNumCubitFaces(); + mSolvedFunctionIndex = getSolvedFunctionIndex(); + + mCuts = getCuts(mNumLayers); + mNumCuts = new int[mAxis.length]; + if( mCuts==null ) for(int i=0; i3 ) + { + bandaged=true; + break; + } + } + + mIsBandaged = bandaged; + + mQuatDebug = new int[NUM_CUBITS]; + + if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE; + if( mObjectScreenRatio=2 ) return -2; + + return nonBlackIndex; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean shouldResetTextureMaps() + { + return false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int[] buildSolvedQuats(Static3D faceAx, Static4D[] quats) + { + final float MAXD = 0.0001f; + float x = faceAx.get0(); + float y = faceAx.get1(); + float z = faceAx.get2(); + float a,dx,dy,dz,qx,qy,qz; + Static4D quat; + + int len = quats.length; + int place = 0; + + for(int q=1; q-MAXD && dx-MAXD && dy-MAXD && dz-MAXDIFF && qx-MAXDIFF && qy-MAXDIFF && qzMAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE; + if( mObjectScreenRatio-MAX_ERROR && + dY-MAX_ERROR && + dZ-MAX_ERROR && + dW-MAX_ERROR ) return i; + + dX = OBJECT_QUATS[i].get0() + rX; + dY = OBJECT_QUATS[i].get1() + rY; + dZ = OBJECT_QUATS[i].get2() + rZ; + dW = OBJECT_QUATS[i].get3() + rW; + + if( dX-MAX_ERROR && + dY-MAX_ERROR && + dZ-MAX_ERROR && + dW-MAX_ERROR ) return i; + } + + return -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int getCubitFaceColorIndex(int cubit, int face) + { + Static4D texMap = mMesh.getTextureMap(NUM_FACE_COLORS*cubit + face); + + int x = (int)(texMap.get0()/texMap.get2()); + int y = (int)(texMap.get1()/texMap.get3()); + + return (mNumTexRows-1-y)*NUM_STICKERS_IN_ROW + x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// the getFaceColors + final black in a grid (so that we do not exceed the maximum texture size) + + public void createTexture() + { + Bitmap bitmap; + + Paint paint = new Paint(); + bitmap = Bitmap.createBitmap( mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888); + Canvas canvas = new Canvas(bitmap); + + paint.setAntiAlias(true); + paint.setTextAlign(Paint.Align.CENTER); + paint.setStyle(Paint.Style.FILL); + + paint.setColor(COLOR_BLACK); + canvas.drawRect(0, 0, mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, paint); + + int face = 0; + FactorySticker factory = FactorySticker.getInstance(); + + for(int row=0; row=NUM_TEXTURES ) break; + ObjectSticker sticker = retSticker(face); + factory.drawRoundedPolygon(canvas, paint, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT, getColor(face%NUM_FACE_COLORS), sticker); + face++; + } + + if( !mTexture.setTexture(bitmap) ) + { + int max = DistortedLibrary.getMaxTextureSize(); + FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance(); + crashlytics.log("failed to set texture of size "+bitmap.getWidth()+"x"+bitmap.getHeight()+" max is "+max); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int getNumLayers() + { + return mNumLayers; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void continueRotation(float angleInDegrees) + { + mRotationAngleStatic.set0(angleInDegrees); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public Static4D getRotationQuat() + { + return mQuat; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void recomputeScaleFactor(int scrWidth) + { + mNodeScale.set(scrWidth,NODE_RATIO*scrWidth,scrWidth); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void savePreferences(SharedPreferences.Editor editor) + { + for(int i=0; i=0 && mQuatDebug[i]=NUM_AXIS ) + { + android.util.Log.e("object", "invalid rotation axis: "+axis); + return; + } + if( row<0 || row>=mNumLayers ) + { + android.util.Log.e("object", "invalid rotation row: "+row); + return; + } + + mRotAxis = axis; + mRotRowBitmap= computeBitmapFromRow( (1<=1 ) + { + return mRotationAngle.getPoint(pointNum-1).get0(); + } + else + { + FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance(); + crashlytics.log("points in RotationAngle: "+pointNum); + return 0; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public synchronized void removeRotationNow() + { + float angle = getAngle(); + double nearestAngleInRadians = angle*Math.PI/180; + float sinA =-(float)Math.sin(nearestAngleInRadians*0.5); + float cosA = (float)Math.cos(nearestAngleInRadians*0.5); + float axisX = mAxis[mRotAxis].get0(); + float axisY = mAxis[mRotAxis].get1(); + float axisZ = mAxis[mRotAxis].get2(); + Static4D quat = new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA); + + mRotationAngle.removeAll(); + mRotationAngleStatic.set0(0); + + for(int i=0; i=basicArray.length ? 0 : axis]; + int nearestAngle = 360/basicAngle; + + int tmp = (int)((angle+nearestAngle/2)/nearestAngle); + if( angle< -(nearestAngle*0.5) ) tmp-=1; + + if( tmp!=0 ) return nearestAngle*tmp; + + return speed> 1.2f ? nearestAngle*(angle>0 ? 1:-1) : 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public float getCameraDist() + { + return mCameraDist; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int getNodeSize() + { + return mNodeSize; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public ObjectList getObjectList() + { + return mList; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total) + { + mScrambler.randomizeNewScramble(scramble,rnd,curr,total); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + abstract int getFOV(); + abstract int getNumFaceColors(); + abstract int getColor(int face); + abstract float returnMultiplier(); + abstract float getScreenRatio(); + + protected abstract float[][] getCuts(int numLayers); + protected abstract int getNumCubitFaces(); + protected abstract Static4D[] getQuats(); + protected abstract float[][] getCubitPositions(int numLayers); + protected abstract int getCubitVariant(int cubit, int numLayers); + protected abstract int getNumCubitVariants(int numLayers); + protected abstract Static4D getQuat(int cubit, int numLayers); + protected abstract ObjectShape getObjectShape(int cubit, int numLayers); + protected abstract int[] getSolvedQuats(int cubit, int numLayers); + protected abstract int getSolvedFunctionIndex(); + protected abstract ScrambleState[] getScrambleStates(); + protected abstract int getNumStickerTypes(int numLayers); + protected abstract ObjectSticker retSticker(int face); + protected abstract int getFaceColor(int cubit, int cubitface, int numLayers); + + public abstract Movement getMovement(); + public abstract Static3D[] getRotationAxis(); + public abstract int[] getBasicAngle(); + public abstract int getObjectName(int numLayers); + public abstract int getInventor(int numLayers); + public abstract int getComplexity(int numLayers); + } diff --git a/src/main/java/org/distorted/objectlb/TwistyObjectScrambler.java b/src/main/java/org/distorted/objectlb/TwistyObjectScrambler.java new file mode 100644 index 00000000..11d95644 --- /dev/null +++ b/src/main/java/org/distorted/objectlb/TwistyObjectScrambler.java @@ -0,0 +1,392 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2021 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 . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objectlb; + +import java.util.Random; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class TwistyObjectScrambler + { + private final ScrambleState[] mStates; + private final int mType; + private final int mNumAxis; + private final int mNumLayers; + + // type=0, i.e. main + private int mCurrState; + private int mIndexExcluded; + private int[][] mScrambleTable; + private int[] mNumOccurences; + + // type=1, i.e. the exception: Square-1 + private static final int BASIC_ANGLE = 12; + private static final int LAST_SL = 0; // automatic rotations: last rot was a 'slash' i.e. along ROT_AXIS[1] + private static final int LAST_UP = 1; // last rot was along ROT_AXIS[0], upper layer and forelast was a slash + private static final int LAST_LO = 2; // last rot was along ROT_AXIS[0], lower layer and forelast was a slash + private static final int LAST_UL = 3; // two last rots were along ROT_AXIS[0] (so the next must be a slash) + + private int[][] mPermittedAngles; + private int[] mCornerQuat; + private int mPermittedUp, mPermittedDo; + private int[][] mBadCornerQuats; + private int mLastRot; + private int[][] mQuatMult; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + TwistyObjectScrambler(int type, int numAxis, int numLayers, ScrambleState[] states) + { + mType = type; + mNumAxis = numAxis; + mNumLayers = numLayers; + mStates = states; + + if( mType==1 ) + { + mPermittedAngles = new int[2][BASIC_ANGLE]; + mCornerQuat = new int[8]; + mLastRot = LAST_SL; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]] + + void initializeQuatMult() + { + mQuatMult = new int[][] + { + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,}, + { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,}, + { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,}, + { 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,}, + { 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,}, + { 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,}, + { 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,}, + { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,}, + { 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,}, + { 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,}, + { 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,}, + { 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,}, + { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,}, + { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,}, + { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3,}, + { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4,}, + { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5,}, + { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6,}, + { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7,}, + { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8,}, + { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9,}, + { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10,}, + { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11,}, + { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,} + }; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void initializeScrambling() + { + if( mScrambleTable ==null ) + { + mScrambleTable = new int[mNumAxis][mNumLayers]; + } + if( mNumOccurences ==null ) + { + int max=0; + + for (ScrambleState mState : mStates) + { + int tmp = mState.getTotal(-1); + if (max < tmp) max = tmp; + } + + mNumOccurences = new int[max]; + } + + for(int i=0; i=12)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean cornerIsLeft(int index) + { + int q = mCornerQuat[index]; + + switch(index) + { + case 0: + case 4: return ((q>=3 && q<= 7) || (q>=18 && q<=22)); + case 1: + case 5: return ((q>=6 && q<=10) || (q>=15 && q<=19)); + case 2: + case 6: return ((q==0 || q==1 || (q>=9 && q<=11)) || (q>=12 && q<=16)); + case 3: + case 7: return ((q>=0 && q<=4) || (q==12 || q==13 || (q>=21 && q<=23))); + } + + return false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean quatIsBad(int quatIndex, int corner) + { + if( mBadCornerQuats ==null ) + { + // quat indices that make corner cubits bandage the puzzle. + mBadCornerQuats = new int[][] { { 2, 8,17,23}, { 5,11,14,20} }; + } + + int index = (corner%2); + + return ( quatIndex== mBadCornerQuats[index][0] || + quatIndex== mBadCornerQuats[index][1] || + quatIndex== mBadCornerQuats[index][2] || + quatIndex== mBadCornerQuats[index][3] ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean isPermittedDo(int angle) + { + if( mQuatMult==null ) initializeQuatMult(); + + for(int corner=0; corner<8; corner++) + { + if( !cornerIsUp(corner) ) + { + int currQuat = mCornerQuat[corner]; + int finalQuat= mQuatMult[angle][currQuat]; + if( quatIsBad(finalQuat,corner) ) return false; + } + } + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean isPermittedUp(int angle) + { + if( mQuatMult==null ) initializeQuatMult(); + + for(int corner=0; corner<8; corner++) + { + if( cornerIsUp(corner) ) + { + int currQuat = mCornerQuat[corner]; + int finalQuat= mQuatMult[angle][currQuat]; + if( quatIsBad(finalQuat,corner) ) return false; + } + } + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void computePermittedAngles() + { + mPermittedDo = 0; + + for(int angle=0; angle. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.SharedPreferences; - -import org.distorted.helpers.QuatHelper; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class Cubit - { - private final float[] mOrigPosition; - private final float[] mCurrentPosition; - private TwistyObject mParent; - private final int mNumAxis; - private final int mLen; - - int mQuatIndex; - int[] mRotationRow; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Cubit(TwistyObject parent, float[] position, int numAxis) - { - mQuatIndex= 0; - mParent = parent; - mLen = position.length; - - mOrigPosition = new float[mLen]; - mCurrentPosition = new float[mLen]; - - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.library.type.Static2D; -import org.distorted.library.type.Static3D; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public abstract class Movement - { - // it doesn't matter where we touch a face - the list of enabled rotAxis will always be the same - static final int TYPE_NOT_SPLIT = 0; - // each face is split into several parts by lines coming from its center to the midpoints of each edge - static final int TYPE_SPLIT_EDGE = 1; - // each face is split into several parts by lines coming from its center to the vertices - static final int TYPE_SPLIT_CORNER = 2; - - static final float SQ3 = (float)Math.sqrt(3); - static final float SQ6 = (float)Math.sqrt(6); - - private final int mNumFaceAxis; - private final float[] mPoint, mCamera, mTouch; - private final float[] mPoint2D, mMove2D; - private final int[] mEnabledRotAxis; - private final float mDistanceCenterFace3D; - private final Static3D[] mFaceAxis; - - private int mLastTouchedFace; - private float[][][] mCastedRotAxis; - private Static4D[][] mCastedRotAxis4D; - private float[][] mTouchBorders, mA, mB; - - private final int mType; - private final int[][][] mEnabled; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - abstract int returnPart(int type, int face, float[] touchPoint); - abstract boolean isInsideFace(int face, float[] point); - public abstract float returnRotationFactor(int numLayers, int row); - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Movement(Static3D[] rotAxis, Static3D[] faceAxis, float[][] cuts, boolean[][] rotatable, - float distance3D, int size, int type, int[][][] enabled) - { - mPoint = new float[3]; - mCamera= new float[3]; - mTouch = new float[3]; - - mPoint2D = new float[2]; - mMove2D = new float[2]; - - mType = type; - mEnabled = enabled; - - mFaceAxis = faceAxis; - mNumFaceAxis= mFaceAxis.length; - - mEnabledRotAxis = new int[rotAxis.length+1]; - - mDistanceCenterFace3D = distance3D; // distance from the center of the object to each of its faces - - computeCastedAxis(rotAxis); - computeBorders(cuts,rotatable,size); - computeLinear(distance3D,rotAxis,faceAxis); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// mCastedRotAxis[1][2]{0,1} are the 2D coords of the 2nd rotAxis cast onto the face defined by the -// 1st faceAxis. - - private void computeCastedAxis(Static3D[] rotAxis) - { - mCastedRotAxis = new float[mNumFaceAxis][rotAxis.length][2]; - mCastedRotAxis4D = new Static4D[mNumFaceAxis][rotAxis.length]; - - float fx,fy,fz,f; - - for( int casted=0; casted mDistanceCenterFace3D; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace, -// compute point 'output[]' which: -// 1) lies on a face of the Object, i.e. surface defined by (axis, distance from (0,0,0)) -// 2) is co-linear with mCamera and mPoint -// -// output = camera + alpha*(point-camera), where alpha = [dist-axis*camera] / [axis*(point-camera)] - - private void castTouchPointOntoFace(Static3D faceAxis, float[] output) - { - float d0 = mPoint[0]-mCamera[0]; - float d1 = mPoint[1]-mCamera[1]; - float d2 = mPoint[2]-mCamera[2]; - float a0 = faceAxis.get0(); - float a1 = faceAxis.get1(); - float a2 = faceAxis.get2(); - - float denom = a0*d0 + a1*d1 + a2*d2; - - if( denom != 0.0f ) - { - float axisCam = a0*mCamera[0] + a1*mCamera[1] + a2*mCamera[2]; - float alpha = (mDistanceCenterFace3D-axisCam)/denom; - - output[0] = mCamera[0] + d0*alpha; - output[1] = mCamera[1] + d1*alpha; - output[2] = mCamera[2] + d2*alpha; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Convert the 3D point3D into a 2D point on the same face surface, but in a different -// coordinate system: a in-plane 2D coord where the origin is in the point where the axis intersects -// the surface, and whose Y axis points 'north' i.e. is in the plane given by the 3D origin, the -// original 3D Y axis and our 2D in-plane origin. -// If those 3 points constitute a degenerate triangle which does not define a plane - which can only -// happen if axis is vertical (or in theory when 2D origin and 3D origin meet, but that would have to -// mean that the distance between the center of the Object and its faces is 0) - then we arbitrarily -// decide that 2D Y = (0,0,-1) in the North Pole and (0,0,1) in the South Pole) - - private void convertTo2Dcoords(float[] point3D, Static3D faceAxis, float[] output) - { - float y0,y1,y2; // base Y vector of the 2D coord system - float a0 = faceAxis.get0(); - float a1 = faceAxis.get1(); - float a2 = faceAxis.get2(); - - if( a0==0.0f && a2==0.0f ) - { - y0=0; y1=0; y2=-a1; - } - else if( a1==0.0f ) - { - y0=0; y1=1; y2=0; - } - else - { - float norm = (float)(-a1/Math.sqrt(1-a1*a1)); - y0 = norm*a0; y1= norm*(a1-1/a1); y2=norm*a2; - } - - float x0 = y1*a2 - y2*a1; // - float x1 = y2*a0 - y0*a2; // (2D coord baseY) x (axis) = 2D coord baseX - float x2 = y0*a1 - y1*a0; // - - float originAlpha = point3D[0]*a0 + point3D[1]*a1 + point3D[2]*a2; - - float origin0 = originAlpha*a0; // coords of the point where axis - float origin1 = originAlpha*a1; // intersects surface plane i.e. - float origin2 = originAlpha*a2; // the origin of our 2D coord system - - float v0 = point3D[0] - origin0; - float v1 = point3D[1] - origin1; - float v2 = point3D[2] - origin2; - - output[0] = v0*x0 + v1*x1 + v2*x2; - output[1] = v0*y0 + v1*y1 + v2*y2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeBorder(float[] cuts, boolean[] rotatable, int size) - { - int len = cuts.length; - float[] border = new float[len]; - - for(int i=0; i0 ? border[i-1] : -Float.MAX_VALUE; - } - else - { - if( rotatable[i+1] ) border[i] = cuts[i]/size; - else - { - int found = -1; - - for(int j=i+2; j<=len; j++) - { - if( rotatable[j] ) - { - found=j; - break; - } - } - - border[i] = found>0 ? (cuts[i]+cuts[found-1])/(2*size) : Float.MAX_VALUE; - } - } - } - - return border; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// size, not numLayers (see Master Skewb where size!=numLayers) - - void computeBorders(float[][] cuts, boolean[][] rotatable, int size) - { - int numCuts = cuts.length; - mTouchBorders = new float[numCuts][]; - - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objects.TwistyMinx.C2; -import static org.distorted.objects.TwistyMinx.COS54; -import static org.distorted.objects.TwistyMinx.LEN; -import static org.distorted.objects.TwistyMinx.SIN54; -import static org.distorted.objects.TwistyObject.SQ5; - -import org.distorted.library.type.Static3D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Dodecahedral objects: map the 2D swipes of user's fingers to 3D rotations - -class Movement12 extends Movement -{ - static final float DIST3D = (float)Math.sqrt(0.625f+0.275f*SQ5); - static final float DIST2D = (SIN54/COS54)/2; - - static final Static3D[] FACE_AXIS = new Static3D[] - { - new Static3D( C2/LEN, SIN54/LEN, 0 ), - new Static3D( C2/LEN,-SIN54/LEN, 0 ), - new Static3D( -C2/LEN, SIN54/LEN, 0 ), - new Static3D( -C2/LEN,-SIN54/LEN, 0 ), - new Static3D( 0 , C2/LEN, SIN54/LEN ), - new Static3D( 0 , C2/LEN,-SIN54/LEN ), - new Static3D( 0 , -C2/LEN, SIN54/LEN ), - new Static3D( 0 , -C2/LEN,-SIN54/LEN ), - new Static3D( SIN54/LEN, 0 , C2/LEN ), - new Static3D( SIN54/LEN, 0 , -C2/LEN ), - new Static3D(-SIN54/LEN, 0 , C2/LEN ), - new Static3D(-SIN54/LEN, 0 , -C2/LEN ) - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Movement12(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) - { - super(rotAxis, FACE_AXIS, cuts,rotatable,DIST3D, size, type, enabled); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float returnRotationFactor(int numLayers, int row) - { - return 1.0f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// return angle (in radians) that the line connecting the center C of the pentagonal face and the -// first vertex of the pentagon makes with a vertical line coming upwards from the center C. - - private float returnAngle(int face) - { - switch(face) - { - case 0: - case 2: - case 6: - case 7: return 0.0f; - case 1: - case 3: - case 4: - case 5: return (float)(36*Math.PI/180); - case 9: - case 10: return (float)(54*Math.PI/180); - case 8: - case 11: return (float)(18*Math.PI/180); - } - - return 0.0f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// The pair (distance,angle) defines a point P in R^2 in polar coordinate system. Let V be the vector -// from the center of the coordinate system to P. -// Let P' be the point defined by polar (distance,angle+PI/2). Let Lh be the half-line starting at -// P' and going in the direction of V. -// Return true iff point 'point' lies on the left of Lh, i.e. when we rotate (using the center of -// the coordinate system as the center of rotation) 'point' and Lh in such a way that Lh points -// directly upwards, is 'point' on the left or the right of it? - - private boolean isOnTheLeft(float[] point, float distance, float angle) - { - float sin = (float)Math.sin(angle); - float cos = (float)Math.cos(angle); - - float vx = point[0] + sin*distance; - float vy = point[1] - cos*distance; - - return vx*sin < vy*cos; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int returnPart(int type, int face, float[] point) - { - switch(type) - { - case TYPE_SPLIT_EDGE : return partEdge(point,face); - case TYPE_SPLIT_CORNER: return partCorner(point,face); - default : return 0; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Return 0,1,2,3,4 - the vertex of the pentagon to which point 'point' is the closest, if the -// 'point' is inside the pentagon - or -1 otherwise. -// The 'first' vertex is the one we meet the first when we rotate clockwise starting from 12:00. -// This vertex makes angle 'returnAngle()' with the line coming out upwards from the center of the -// pentagon. -// Distance from the center to a vertex of the pentagon = 1/(6*COS54) - - int partEdge(float[] point, int face) - { - float angle = returnAngle(face); - float A = (float)(Math.PI/5); - - for(int i=0; i<5; i++) - { - if( isOnTheLeft(point, DIST2D, (9-2*i)*A-angle) ) return -1; - } - - if( isOnTheLeft(point, 0, 2.5f*A-angle) ) - { - if( isOnTheLeft(point, 0, 3.5f*A-angle) ) - { - return isOnTheLeft(point, 0, 5.5f*A-angle) ? 3 : 4; - } - else return 0; - } - else - { - if( isOnTheLeft(point, 0, 4.5f*A-angle) ) - { - return 2; - } - else - { - return isOnTheLeft(point, 0, 6.5f*A-angle) ? 1 : 0; - } - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// TODO - no such object yet - - int partCorner(float[] point, int face) - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(int face, float[] p) - { - float angle = returnAngle(face); - float A = (float)(Math.PI/5); - - for(int i=0; i<5; i++) - { - if( isOnTheLeft(p, DIST2D, (9-2*i)*A-angle) ) return false; - } - - return true; - } -} diff --git a/src/main/java/org/distorted/objects/Movement4.java b/src/main/java/org/distorted/objects/Movement4.java deleted file mode 100644 index dbccd4ed..00000000 --- a/src/main/java/org/distorted/objects/Movement4.java +++ /dev/null @@ -1,102 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.library.type.Static3D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Tetrahedral objects: map the 2D swipes of user's fingers to 3D rotations - -class Movement4 extends Movement -{ - static final float DIST3D = SQ6/12; - static final float DIST2D = SQ3/6; - - static final Static3D[] FACE_AXIS = new Static3D[] - { - new Static3D( 0,+SQ3/3,+SQ6/3), - new Static3D( 0,+SQ3/3,-SQ6/3), - new Static3D(-SQ6/3,-SQ3/3, 0), - new Static3D(+SQ6/3,-SQ3/3, 0), - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Movement4(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) - { - super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// corner edge -// | \ 0 / -// 2 | 0 \ / -// / \ 2 | 1 -// / 1 \ | - - int returnPart(int type, int face, float[] touchPoint) - { - switch(type) - { - case TYPE_NOT_SPLIT : return 0; - - case TYPE_SPLIT_EDGE : float y1 = (face > 1 ? touchPoint[1] : -touchPoint[1]); - float x1 = touchPoint[0]; - - boolean e0 = x1>0; - boolean e1 = y1>(+SQ3/3)*x1; - boolean e2 = y1>(-SQ3/3)*x1; - - if( e1 && e2 ) return 0; - if( !e1 && e0 ) return 1; - if( !e0 &&!e2 ) return 2; - - case TYPE_SPLIT_CORNER: float y2 = (face > 1 ? touchPoint[1] : -touchPoint[1]); - float x2 = touchPoint[0]; - - boolean c0 = x2>0; - boolean c1 = y2>(+SQ3/3)*x2; - boolean c2 = y2>(-SQ3/3)*x2; - - if( c0 && c2 ) return 0; - if( !c1 &&!c2 ) return 1; - if( !c0 && c1 ) return 2; - } - - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Jing has nL=2 - - public float returnRotationFactor(int numLayers, int row) - { - return numLayers==2 ? 1.0f : ((float)numLayers)/(numLayers-row); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(int face, float[] p) - { - float y = (face > 1 ? p[1] : -p[1]); - float x = p[0]; - return (y >= -DIST2D) && (y <= DIST2D*(2-6*x)) && (y <= DIST2D*(2+6*x)); - } -} diff --git a/src/main/java/org/distorted/objects/Movement6.java b/src/main/java/org/distorted/objects/Movement6.java deleted file mode 100644 index 4ea12b47..00000000 --- a/src/main/java/org/distorted/objects/Movement6.java +++ /dev/null @@ -1,82 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.library.type.Static3D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Hexahedral objects: map the 2D swipes of user's fingers to 3D rotations - -class Movement6 extends Movement -{ - static final float DIST3D = 0.5f; - static final float DIST2D = 0.5f; - - static final Static3D[] FACE_AXIS = new Static3D[] - { - new Static3D(1,0,0), new Static3D(-1,0,0), - new Static3D(0,1,0), new Static3D(0,-1,0), - new Static3D(0,0,1), new Static3D(0,0,-1) - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Movement6(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) - { - super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// corner edge -// \ 0 / 3 | 0 -// 3 \ / 1 ___ | ___ -// / \ | -// / 2 \ 2 | 1 - - int returnPart(int type, int face, float[] touchPoint) - { - switch(type) - { - case TYPE_NOT_SPLIT : return 0; - case TYPE_SPLIT_EDGE : boolean e0 = touchPoint[0] > 0; - boolean e1 = touchPoint[1] > 0; - return e0 ? (e1 ? 0:1) : (e1 ? 3:2); - case TYPE_SPLIT_CORNER: boolean c0 = touchPoint[1] >= touchPoint[0]; - boolean c1 = touchPoint[1] >=-touchPoint[0]; - return c0 ? (c1 ? 0:3) : (c1 ? 1:2); - } - - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float returnRotationFactor(int numLayers, int row) - { - return 1.0f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(int face, float[] p) - { - return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D ); - } -} diff --git a/src/main/java/org/distorted/objects/Movement8.java b/src/main/java/org/distorted/objects/Movement8.java deleted file mode 100644 index 32afaa60..00000000 --- a/src/main/java/org/distorted/objects/Movement8.java +++ /dev/null @@ -1,101 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.library.type.Static3D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Octahedral objects: map the 2D swipes of user's fingers to 3D rotations - -class Movement8 extends Movement -{ - static final float DIST3D = SQ6/6; - static final float DIST2D = SQ3/6; - - static final Static3D[] FACE_AXIS = new Static3D[] - { - new Static3D(+SQ6/3,+SQ3/3, 0), new Static3D(-SQ6/3,-SQ3/3, 0), - 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), - new Static3D( 0,+SQ3/3,-SQ6/3), new Static3D( 0,-SQ3/3,+SQ6/3) - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Movement8(Static3D[] rotAxis,float[][] cuts, boolean[][] rotatable, int size, int type, int[][][] enabled) - { - super(rotAxis, FACE_AXIS, cuts, rotatable, DIST3D, size, type, enabled); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// corner edge -// | \ 0 / -// 2 | 0 \ / -// / \ 2 | 1 -// / 1 \ | - - int returnPart(int type, int face, float[] touchPoint) - { - switch(type) - { - case TYPE_NOT_SPLIT : return 0; - - case TYPE_SPLIT_EDGE : float y1 = (face%2 == 0 ? touchPoint[1] : -touchPoint[1]); - float x1 = touchPoint[0]; - - boolean e0 = x1>0; - boolean e1 = y1>(+SQ3/3)*x1; - boolean e2 = y1>(-SQ3/3)*x1; - - if( e1 && e2 ) return 0; - if( !e1 && e0 ) return 1; - if( !e0 &&!e2 ) return 2; - - case TYPE_SPLIT_CORNER: float y2 = (face%2 == 0 ? touchPoint[1] : -touchPoint[1]); - float x2 = touchPoint[0]; - - boolean c0 = x2>0; - boolean c1 = y2>(+SQ3/3)*x2; - boolean c2 = y2>(-SQ3/3)*x2; - - if( c0 && c2 ) return 0; - if( !c1 &&!c2 ) return 1; - if( !c0 && c1 ) return 2; - } - - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float returnRotationFactor(int numLayers, int row) - { - return 1.0f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(int face, float[] p) - { - float y = (face%2 == 0 ? p[1] : -p[1]); - float x = p[0]; - return (y >= -DIST2D) && (y <= DIST2D*(2-6*x)) && (y <= DIST2D*(2+6*x)); - } -} diff --git a/src/main/java/org/distorted/objects/ObjectList.java b/src/main/java/org/distorted/objects/ObjectList.java deleted file mode 100644 index 186e585a..00000000 --- a/src/main/java/org/distorted/objects/ObjectList.java +++ /dev/null @@ -1,566 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; -import org.distorted.main.R; -import org.distorted.main.RubikActivity; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public enum ObjectList - { - ///////////////////// Size // DB Level // NumScrambles // Mesh // small icon // medium icon // big icon // huge icon - - CUBE ( - new int[][] { - {2 , 12, 12, R.raw.cube2, R.drawable.ui_small_cube2, R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2} , - {3 , 16, 17, R.raw.cube3, R.drawable.ui_small_cube3, R.drawable.ui_medium_cube3, R.drawable.ui_big_cube3, R.drawable.ui_huge_cube3} , - {4 , 20, 24, R.raw.cube4, R.drawable.ui_small_cube4, R.drawable.ui_medium_cube4, R.drawable.ui_big_cube4, R.drawable.ui_huge_cube4} , - {5 , 24, 28, R.raw.cube5, R.drawable.ui_small_cube5, R.drawable.ui_medium_cube5, R.drawable.ui_big_cube5, R.drawable.ui_huge_cube5} - }, - 0 - ), - - JING ( - new int[][] { - {2 , 11, 11, R.raw.jing, R.drawable.ui_small_jing2, R.drawable.ui_medium_jing2, R.drawable.ui_big_jing2, R.drawable.ui_huge_jing2} , - }, - 1 - ), - - PYRA ( - new int[][] { - {3 , 10, 10, R.raw.pyra3, R.drawable.ui_small_pyra3, R.drawable.ui_medium_pyra3, R.drawable.ui_big_pyra3, R.drawable.ui_huge_pyra3} , - {4 , 15, 17, R.raw.pyra4, R.drawable.ui_small_pyra4, R.drawable.ui_medium_pyra4, R.drawable.ui_big_pyra4, R.drawable.ui_huge_pyra4} , - {5 , 20, 23, R.raw.pyra5, R.drawable.ui_small_pyra5, R.drawable.ui_medium_pyra5, R.drawable.ui_big_pyra5, R.drawable.ui_huge_pyra5} - }, - 1 - ), - - KILO ( - new int[][] { - {3 , 18, 18, R.raw.kilo3, R.drawable.ui_small_kilo3, R.drawable.ui_medium_kilo3, R.drawable.ui_big_kilo3, R.drawable.ui_huge_kilo3} , - {5 , 33, 33, R.raw.kilo5, R.drawable.ui_small_kilo5, R.drawable.ui_medium_kilo5, R.drawable.ui_big_kilo5, R.drawable.ui_huge_kilo5} , - }, - 2 - ), - - MEGA ( - new int[][] { - {3 , 21, 21, R.raw.mega3, R.drawable.ui_small_mega3, R.drawable.ui_medium_mega3, R.drawable.ui_big_mega3, R.drawable.ui_huge_mega3} , - {5 , 35, 37, R.raw.mega5, R.drawable.ui_small_mega5, R.drawable.ui_medium_mega5, R.drawable.ui_big_mega5, R.drawable.ui_huge_mega5} , - }, - 2 - ), - - ULTI ( - new int[][] { - {2 , 18, 18, R.raw.ulti, R.drawable.ui_small_ulti, R.drawable.ui_medium_ulti, R.drawable.ui_big_ulti, R.drawable.ui_huge_ulti} , - }, - 3 - ), - - DIAM ( - new int[][] { - {2 , 10, 12, R.raw.diam2, R.drawable.ui_small_diam2, R.drawable.ui_medium_diam2, R.drawable.ui_big_diam2, R.drawable.ui_huge_diam2} , - {3 , 18, 24, R.raw.diam3, R.drawable.ui_small_diam3, R.drawable.ui_medium_diam3, R.drawable.ui_big_diam3, R.drawable.ui_huge_diam3} , - {4 , 32, 32, R.raw.diam4, R.drawable.ui_small_diam4, R.drawable.ui_medium_diam4, R.drawable.ui_big_diam4, R.drawable.ui_huge_diam4} , - }, - 3 - ), - - DINO ( - new int[][] { - {3 , 10, 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} , - }, - 4 - ), - - DIN4 ( - new int[][] { - {3 , 7, 7, R.raw.dino, R.drawable.ui_small_din4, R.drawable.ui_medium_din4, R.drawable.ui_big_din4, R.drawable.ui_huge_din4} , - }, - 4 - ), - - REDI ( - new int[][] { - {3 , 14, 16, R.raw.redi, R.drawable.ui_small_redi, R.drawable.ui_medium_redi, R.drawable.ui_big_redi, R.drawable.ui_huge_redi} , - }, - 4 - ), - - HELI ( - new int[][] { - {3 , 18, 20, R.raw.heli, R.drawable.ui_small_heli, R.drawable.ui_medium_heli, R.drawable.ui_big_heli, R.drawable.ui_huge_heli} , - }, - 4 - ), - - SKEW ( - new int[][] { - {2 , 11, 11, R.raw.skew2, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} , - {3 , 17, 21, R.raw.skew3, R.drawable.ui_small_skewm, R.drawable.ui_medium_skewm, R.drawable.ui_big_skewm, R.drawable.ui_huge_skewm} , - }, - 5 - ), - - IVY ( - new int[][] { - {2 , 8, 8, R.raw.ivy, R.drawable.ui_small_ivy, R.drawable.ui_medium_ivy, R.drawable.ui_big_ivy, R.drawable.ui_huge_ivy} , - }, - 5 - ), - - REX ( - new int[][] { - {3 , 16, 19, R.raw.rex, R.drawable.ui_small_rex, R.drawable.ui_medium_rex, R.drawable.ui_big_rex, R.drawable.ui_huge_rex} , - }, - 5 - ), - - BAN1 ( - new int[][] { - {3 , 16, 16, R.raw.ban1, R.drawable.ui_small_ban1, R.drawable.ui_medium_ban1, R.drawable.ui_big_ban1, R.drawable.ui_huge_ban1} , - }, - 6 - ), - - BAN2 ( - new int[][] { - {3 , 16, 16, R.raw.ban2, R.drawable.ui_small_ban2, R.drawable.ui_medium_ban2, R.drawable.ui_big_ban2, R.drawable.ui_huge_ban2} , - }, - 6 - ), - - BAN3 ( - new int[][] { - {3 , 16, 16, R.raw.ban3, R.drawable.ui_small_ban3, R.drawable.ui_medium_ban3, R.drawable.ui_big_ban3, R.drawable.ui_huge_ban3} , - }, - 6 - ), - - BAN4 ( - new int[][] { - {3 , 16, 16, R.raw.ban4, R.drawable.ui_small_ban4, R.drawable.ui_medium_ban4, R.drawable.ui_big_ban4, R.drawable.ui_huge_ban4} , - }, - 6 - ), - - SQU1 ( - new int[][] { - {3 , 24, 24, R.raw.square1, R.drawable.ui_small_square1, R.drawable.ui_medium_square1, R.drawable.ui_big_square1, R.drawable.ui_huge_square1} , - }, - 7 - ), - - SQU2 ( - new int[][] { - {3 , 24, 24, R.raw.square2, R.drawable.ui_small_square2, R.drawable.ui_medium_square2, R.drawable.ui_big_square2, R.drawable.ui_huge_square2} , - }, - 7 - ), - - MIRR ( - new int[][] { - {2 , 12, 12, R.raw.mirr2, R.drawable.ui_small_mirr2, R.drawable.ui_medium_mirr2, R.drawable.ui_big_mirr2, R.drawable.ui_huge_mirr2} , - {3 , 16, 17, R.raw.mirr3, R.drawable.ui_small_mirr3, R.drawable.ui_medium_mirr3, R.drawable.ui_big_mirr3, R.drawable.ui_huge_mirr3} , - }, - 7 - ), - ; - - public static final int NUM_OBJECTS = values().length; - public static final int MAX_NUM_OBJECTS; - public static final int MAX_LEVEL; - public static final int MAX_SCRAMBLE; - public static final int MAX_OBJECT_SIZE; - - private final int[] mObjectSizes, mDBLevels, mNumScrambles, mSmallIconIDs, mMediumIconIDs, mBigIconIDs, mHugeIconIDs, mResourceIDs; - private final int mRow, mNumSizes; - - private static final ObjectList[] objects; - private static int mNumAll; - private static int[] mIndices; - private static int mColCount, mRowCount; - - static - { - mNumAll = 0; - int num, i = 0; - objects = new ObjectList[NUM_OBJECTS]; - int maxNum = Integer.MIN_VALUE; - int maxLevel = Integer.MIN_VALUE; - int maxScramble= Integer.MIN_VALUE; - int maxSize = Integer.MIN_VALUE; - - for(ObjectList object: ObjectList.values()) - { - objects[i] = object; - i++; - num = object.mObjectSizes.length; - mNumAll += num; - if( num> maxNum ) maxNum = num; - - for(int j=0; j maxScramble ) maxScramble= object.mNumScrambles[j]; - if( object.mDBLevels[j] > maxLevel ) maxLevel = object.mDBLevels[j]; - if( object.mObjectSizes[j] > maxSize ) maxSize = object.mObjectSizes[j]; - } - } - - MAX_NUM_OBJECTS = maxNum; - MAX_LEVEL = maxLevel; - MAX_SCRAMBLE = maxScramble; - MAX_OBJECT_SIZE = maxSize; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static void setUpColAndRow() - { - mIndices = new int[NUM_OBJECTS]; - mRowCount= 0; - - for(int obj=0; obj=mRowCount ) mRowCount = mIndices[obj]+1; - } - - mColCount = 0; - - for(int row=0; rowmColCount ) mColCount = numObjects; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private static int computeNumObjectsInRow(int row) - { - int num=0; - - for(int object=0; object=0 && ordinal0 ) - { - String name = obj.substring(0,u); - int size = Integer.parseInt( obj.substring(u+1,l) ); - - for(int i=0; i0 || j>0 ) list.append(','); - list.append(name); - list.append('_'); - list.append(sizes[j]); - } - } - - return list.toString(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static int getTotal() - { - return mNumAll; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static int getDBLevel(int ordinal, int sizeIndex) - { - if( ordinal>=0 && ordinal=0 && sizeIndex=0 && ordinal=0 && sizeIndex=0 && ordinal. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class Twisty12 extends TwistyObject -{ - static final int MINX_LGREEN = 0xff53aa00; - static final int MINX_PINK = 0xfffd7ab7; - static final int MINX_SANDY = 0xffefd48b; - static final int MINX_LBLUE = 0xff00a2d7; - static final int MINX_ORANGE = 0xffff6200; - static final int MINX_VIOLET = 0xff7d59a4; - static final int MINX_DGREEN = 0xff007a47; - static final int MINX_DRED = 0xffbd0000; - static final int MINX_DBLUE = 0xff1a29b2; - static final int MINX_DYELLOW= 0xffffc400; - static final int MINX_WHITE = 0xffffffff; - static final int MINX_GREY = 0xff727c7b; - - static final int[] FACE_COLORS = new int[] - { - MINX_LGREEN, MINX_PINK , MINX_SANDY , MINX_LBLUE, - MINX_ORANGE, MINX_VIOLET , MINX_DGREEN, MINX_DRED , - MINX_DBLUE , MINX_DYELLOW, MINX_WHITE , MINX_GREY - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Twisty12(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) - { - super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getColor(int face) - { - return FACE_COLORS[face]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNumFaceColors() - { - return 12; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getFOV() - { - return 30; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float getScreenRatio() - { - return 0.35f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float returnMultiplier() - { - return 1.0f; - } -} diff --git a/src/main/java/org/distorted/objects/Twisty4.java b/src/main/java/org/distorted/objects/Twisty4.java deleted file mode 100644 index 54ddeb82..00000000 --- a/src/main/java/org/distorted/objects/Twisty4.java +++ /dev/null @@ -1,81 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2019 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class Twisty4 extends TwistyObject -{ - private static final int[] FACE_COLORS = new int[] - { - COLOR_GREEN , COLOR_YELLOW, - COLOR_BLUE , COLOR_RED - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Twisty4(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) - { - super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getColor(int face) - { - return FACE_COLORS[face]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNumFaceColors() - { - return 4; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getFOV() - { - return 30; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float getScreenRatio() - { - return 0.88f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float returnMultiplier() - { - return getNumLayers()/(SQ6/3); - } -} diff --git a/src/main/java/org/distorted/objects/Twisty6.java b/src/main/java/org/distorted/objects/Twisty6.java deleted file mode 100644 index 074922f6..00000000 --- a/src/main/java/org/distorted/objects/Twisty6.java +++ /dev/null @@ -1,82 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2019 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class Twisty6 extends TwistyObject -{ - private static final int[] FACE_COLORS = new int[] - { - COLOR_YELLOW, COLOR_WHITE, - COLOR_BLUE , COLOR_GREEN, - COLOR_RED , COLOR_ORANGE - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Twisty6(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) - { - super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getColor(int face) - { - return FACE_COLORS[face]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNumFaceColors() - { - return 6; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getFOV() - { - return 60; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float getScreenRatio() - { - return 0.5f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float returnMultiplier() - { - return getNumLayers(); - } -} diff --git a/src/main/java/org/distorted/objects/Twisty8.java b/src/main/java/org/distorted/objects/Twisty8.java deleted file mode 100644 index e9e020e3..00000000 --- a/src/main/java/org/distorted/objects/Twisty8.java +++ /dev/null @@ -1,83 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2019 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class Twisty8 extends TwistyObject -{ - private static final int[] FACE_COLORS = new int[] - { - COLOR_ORANGE, COLOR_VIOLET, - COLOR_WHITE , COLOR_BLUE , - COLOR_YELLOW, COLOR_RED , - COLOR_GREEN , COLOR_GREY - }; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - Twisty8(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) - { - super(numLayers, realSize, quat, texture, mesh, effects, moves, list, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getColor(int face) - { - return FACE_COLORS[face]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNumFaceColors() - { - return 8; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getFOV() - { - return 60; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float getScreenRatio() - { - return 0.65f; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float returnMultiplier() - { - return 1.5f; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyBandaged2Bar.java b/src/main/java/org/distorted/objects/TwistyBandaged2Bar.java index b1189d75..54e3f3e0 100644 --- a/src/main/java/org/distorted/objects/TwistyBandaged2Bar.java +++ b/src/main/java/org/distorted/objects/TwistyBandaged2Bar.java @@ -21,26 +21,27 @@ package org.distorted.objects; import android.content.res.Resources; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; import org.distorted.library.mesh.MeshSquare; import org.distorted.library.type.Static4D; import org.distorted.main.R; +import org.distorted.objectlb.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// -class TwistyBandaged2Bar extends TwistyBandagedAbstract +public class TwistyBandaged2Bar extends TwistyBandagedAbstract { - TwistyBandaged2Bar(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyBandaged2Bar(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, quat, texture, mesh, effects, moves, ObjectList.BAN2, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { diff --git a/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java b/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java index e7b6fb35..1e7a5172 100644 --- a/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java +++ b/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java @@ -21,26 +21,27 @@ package org.distorted.objects; import android.content.res.Resources; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; import org.distorted.library.mesh.MeshSquare; import org.distorted.library.type.Static4D; -import org.distorted.helpers.ScrambleState; import org.distorted.main.R; +import org.distorted.objectlb.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// -class TwistyBandaged3Plate extends TwistyBandagedAbstract +public class TwistyBandaged3Plate extends TwistyBandagedAbstract { - TwistyBandaged3Plate(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyBandaged3Plate(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, quat, texture, mesh, effects, moves, ObjectList.BAN3, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java index e7381c74..6991d6d2 100644 --- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java +++ b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java @@ -19,18 +19,22 @@ package org.distorted.objects; -import static org.distorted.objects.Movement.TYPE_NOT_SPLIT; +import static org.distorted.objectlb.Movement.TYPE_NOT_SPLIT; import android.content.res.Resources; -import org.distorted.helpers.ObjectShape; -import org.distorted.helpers.ObjectSticker; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ObjectShape; +import org.distorted.objectlb.ObjectSticker; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; import org.distorted.library.mesh.MeshSquare; import org.distorted.library.type.Static3D; import org.distorted.library.type.Static4D; +import org.distorted.objectlb.Movement; +import org.distorted.objectlb.Movement6; +import org.distorted.objectlb.ObjectList; +import org.distorted.objectlb.Twisty6; /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -123,7 +127,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int[] getSolvedQuats(int cubit, int numLayers) + protected int[] getSolvedQuats(int cubit, int numLayers) { if( mQuats==null ) initializeQuats(); int status = retCubitSolvedStatus(cubit,numLayers); @@ -156,7 +160,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - ObjectShape getObjectShape(int cubit, int numLayers) + protected ObjectShape getObjectShape(int cubit, int numLayers) { int variant = getCubitVariant(cubit,numLayers); @@ -220,7 +224,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D getQuat(int cubit, int numLayers) + protected Static4D getQuat(int cubit, int numLayers) { if( mInitQuats ==null ) { @@ -240,14 +244,14 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitVariants(int numLayers) + protected int getNumCubitVariants(int numLayers) { return mDimensions.length; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getCubitVariant(int cubit, int numLayers) + protected int getCubitVariant(int cubit, int numLayers) { float[][] pos = getPositions(); @@ -262,7 +266,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - ObjectSticker retSticker(int face) + protected ObjectSticker retSticker(int face) { if( mStickers==null ) { @@ -297,7 +301,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCubitPositions(int size) + protected float[][] getCubitPositions(int size) { int numCubits = getNumCubits(); float[][] tmp = new float[numCubits][]; @@ -312,7 +316,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D[] getQuats() + protected Static4D[] getQuats() { if( mQuats==null ) initializeQuats(); return mQuats; @@ -320,7 +324,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCuts(int numLayers) + protected float[][] getCuts(int numLayers) { if( numLayers<2 ) return null; @@ -356,21 +360,21 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getSolvedFunctionIndex() + protected int getSolvedFunctionIndex() { return 0; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumStickerTypes(int numLayers) + protected int getNumStickerTypes(int numLayers) { return NUM_STICKERS; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitFaces() + protected int getNumCubitFaces() { return 6; } @@ -405,7 +409,7 @@ abstract class TwistyBandagedAbstract extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getFaceColor(int cubit, int cubitface, int numLayers) + protected int getFaceColor(int cubit, int cubitface, int numLayers) { if( mFaceMap==null ) { diff --git a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java b/src/main/java/org/distorted/objects/TwistyBandagedEvil.java index 7365c1e7..dc538d61 100644 --- a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java +++ b/src/main/java/org/distorted/objects/TwistyBandagedEvil.java @@ -21,26 +21,27 @@ package org.distorted.objects; import android.content.res.Resources; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; import org.distorted.library.mesh.MeshSquare; import org.distorted.library.type.Static4D; import org.distorted.main.R; +import org.distorted.objectlb.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// -class TwistyBandagedEvil extends TwistyBandagedAbstract +public class TwistyBandagedEvil extends TwistyBandagedAbstract { - TwistyBandagedEvil(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyBandagedEvil(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, quat, texture, mesh, effects, moves, ObjectList.BAN4, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { diff --git a/src/main/java/org/distorted/objects/TwistyBandagedFused.java b/src/main/java/org/distorted/objects/TwistyBandagedFused.java index b699efd7..651c270f 100644 --- a/src/main/java/org/distorted/objects/TwistyBandagedFused.java +++ b/src/main/java/org/distorted/objects/TwistyBandagedFused.java @@ -21,26 +21,27 @@ package org.distorted.objects; import android.content.res.Resources; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; import org.distorted.library.mesh.MeshSquare; import org.distorted.library.type.Static4D; import org.distorted.main.R; +import org.distorted.objectlb.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// -class TwistyBandagedFused extends TwistyBandagedAbstract +public class TwistyBandagedFused extends TwistyBandagedAbstract { - TwistyBandagedFused(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyBandagedFused(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, quat, texture, mesh, effects, moves, ObjectList.BAN1, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java index f1b6557b..b1e39051 100644 --- a/src/main/java/org/distorted/objects/TwistyCube.java +++ b/src/main/java/org/distorted/objects/TwistyCube.java @@ -19,23 +19,27 @@ package org.distorted.objects; -import static org.distorted.objects.Movement.TYPE_NOT_SPLIT; +import static org.distorted.objectlb.Movement.TYPE_NOT_SPLIT; import android.content.res.Resources; -import org.distorted.helpers.ObjectShape; -import org.distorted.helpers.ObjectSticker; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ObjectShape; +import org.distorted.objectlb.ObjectSticker; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; 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.objectlb.Movement; +import org.distorted.objectlb.Movement6; +import org.distorted.objectlb.ObjectList; +import org.distorted.objectlb.Twisty6; /////////////////////////////////////////////////////////////////////////////////////////////////// -class TwistyCube extends Twisty6 +public class TwistyCube extends Twisty6 { static final Static3D[] ROT_AXIS = new Static3D[] { @@ -59,15 +63,15 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - TwistyCube(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyCube(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, size, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { @@ -158,7 +162,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int[] getSolvedQuats(int cubit, int numLayers) + protected int[] getSolvedQuats(int cubit, int numLayers) { if( mQuats ==null ) initializeQuats(); int status = retCubitSolvedStatus(cubit,numLayers); @@ -167,7 +171,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - ObjectShape getObjectShape(int cubit, int numLayers) + protected ObjectShape getObjectShape(int cubit, int numLayers) { int extraI, extraV, num; float height; @@ -214,7 +218,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D getQuat(int cubit, int numLayers) + protected Static4D getQuat(int cubit, int numLayers) { if( mQuats ==null ) initializeQuats(); return mQuats[0]; @@ -222,21 +226,21 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitVariants(int numLayers) + protected int getNumCubitVariants(int numLayers) { return 1; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getCubitVariant(int cubit, int numLayers) + protected int getCubitVariant(int cubit, int numLayers) { return 0; } /////////////////////////////////////////////////////////////////////////////////////////////////// - ObjectSticker retSticker(int face) + protected ObjectSticker retSticker(int face) { if( mStickers==null ) { @@ -253,7 +257,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCubitPositions(int numLayers) + protected float[][] getCubitPositions(int numLayers) { int numCubits = numLayers>1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1; float[][] tmp = new float[numCubits][]; @@ -274,7 +278,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D[] getQuats() + protected Static4D[] getQuats() { if( mQuats ==null ) initializeQuats(); return mQuats; @@ -282,7 +286,7 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCuts(int numLayers) + protected float[][] getCuts(int numLayers) { if( numLayers<2 ) return null; @@ -318,30 +322,30 @@ class TwistyCube extends Twisty6 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getSolvedFunctionIndex() + protected int getSolvedFunctionIndex() { return 0; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumStickerTypes(int numLayers) + protected int getNumStickerTypes(int numLayers) { return 1; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitFaces() + protected int getNumCubitFaces() { return 6; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getFaceColor(int cubit, int cubitface, int numLayers) + protected int getFaceColor(int cubit, int cubitface, int numLayers) { - return CUBITS[cubit].mRotationRow[cubitface/2] == (cubitface%2==0 ? (1<<(numLayers-1)):1) ? cubitface : NUM_TEXTURES; + return CUBITS[cubit].getRotRow(cubitface/2) == (cubitface%2==0 ? (1<<(numLayers-1)):1) ? cubitface : NUM_TEXTURES; } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java index 2bc947d2..aaa207e5 100644 --- a/src/main/java/org/distorted/objects/TwistyDiamond.java +++ b/src/main/java/org/distorted/objects/TwistyDiamond.java @@ -19,19 +19,23 @@ package org.distorted.objects; -import static org.distorted.objects.Movement.TYPE_NOT_SPLIT; +import static org.distorted.objectlb.Movement.TYPE_NOT_SPLIT; import android.content.res.Resources; -import org.distorted.helpers.ObjectShape; -import org.distorted.helpers.ObjectSticker; -import org.distorted.helpers.ScrambleState; +import org.distorted.objectlb.ObjectShape; +import org.distorted.objectlb.ObjectSticker; +import org.distorted.objectlb.ScrambleState; import org.distorted.library.main.DistortedEffects; import org.distorted.library.main.DistortedTexture; 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.objectlb.Movement; +import org.distorted.objectlb.Movement8; +import org.distorted.objectlb.ObjectList; +import org.distorted.objectlb.Twisty8; /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -63,15 +67,15 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - TwistyDiamond(int size, Static4D quat, DistortedTexture texture, - MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth) + public TwistyDiamond(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, + DistortedEffects effects, int[][] moves, Resources res, int scrWidth) { super(size, size, quat, texture, mesh, effects, moves, ObjectList.DIAM, res, scrWidth); } /////////////////////////////////////////////////////////////////////////////////////////////////// - ScrambleState[] getScrambleStates() + protected ScrambleState[] getScrambleStates() { if( mStates==null ) { @@ -118,7 +122,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - int[] getSolvedQuats(int cubit, int numLayers) + protected int[] getSolvedQuats(int cubit, int numLayers) { if( mQuats==null ) initializeQuats(); if( mFaceMap==null ) mFaceMap = new int[] {4,0,6,2,7,3,5,1}; @@ -128,7 +132,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D[] getQuats() + protected Static4D[] getQuats() { if( mQuats==null ) initializeQuats(); return mQuats; @@ -136,21 +140,21 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getSolvedFunctionIndex() + protected int getSolvedFunctionIndex() { return 0; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumStickerTypes(int numLayers) + protected int getNumStickerTypes(int numLayers) { return 1; } /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCuts(int numLayers) + protected float[][] getCuts(int numLayers) { if( numLayers<2 ) return null; @@ -188,7 +192,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitFaces() + protected int getNumCubitFaces() { return 8; } @@ -302,7 +306,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - float[][] getCubitPositions(int layers) + protected float[][] getCubitPositions(int layers) { int numO = getNumOctahedrons(layers); int numT = getNumTetrahedrons(layers); @@ -349,7 +353,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - ObjectShape getObjectShape(int cubit, int numLayers) + protected ObjectShape getObjectShape(int cubit, int numLayers) { int variant = getCubitVariant(cubit,numLayers); int N = numLayers>3 ? 5:6; @@ -403,7 +407,7 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - Static4D getQuat(int cubit, int numLayers) + protected Static4D getQuat(int cubit, int numLayers) { if( mQuats==null ) initializeQuats(); int numO = getNumOctahedrons(numLayers); @@ -427,21 +431,21 @@ public class TwistyDiamond extends Twisty8 /////////////////////////////////////////////////////////////////////////////////////////////////// - int getNumCubitVariants(int numLayers) + protected int getNumCubitVariants(int numLayers) { return 2; } /////////////////////////////////////////////////////////////////////////////////////////////////// - int getCubitVariant(int cubit, int numLayers) + protected int getCubitVariant(int cubit, int numLayers) { return cubit. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.SharedPreferences; -import android.content.res.Resources; -import android.graphics.Bitmap; -import android.graphics.Canvas; -import android.graphics.Paint; - -import com.google.firebase.crashlytics.FirebaseCrashlytics; - -import org.distorted.helpers.FactoryCubit; -import org.distorted.helpers.FactorySticker; -import org.distorted.helpers.ObjectShape; -import org.distorted.helpers.ObjectSticker; -import org.distorted.helpers.QuatHelper; -import org.distorted.helpers.ScrambleState; -import org.distorted.library.effect.Effect; -import org.distorted.library.effect.MatrixEffectMove; -import org.distorted.library.effect.MatrixEffectQuaternion; -import org.distorted.library.effect.MatrixEffectScale; -import org.distorted.library.effect.VertexEffectQuaternion; -import org.distorted.library.effect.VertexEffectRotate; -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedLibrary; -import org.distorted.library.main.DistortedNode; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshBase; -import org.distorted.library.mesh.MeshFile; -import org.distorted.library.mesh.MeshJoined; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.message.EffectListener; -import org.distorted.library.type.Dynamic1D; -import org.distorted.library.type.Static1D; -import org.distorted.library.type.Static3D; -import org.distorted.library.type.Static4D; -import org.distorted.main.BuildConfig; - -import java.io.DataInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.util.Random; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public abstract class TwistyObject extends DistortedNode - { - public static final int COLOR_YELLOW = 0xffffff00; - public static final int COLOR_WHITE = 0xffffffff; - public static final int COLOR_BLUE = 0xff0000ff; - public static final int COLOR_GREEN = 0xff00bb00; - public static final int COLOR_RED = 0xff990000; - public static final int COLOR_ORANGE = 0xffff6200; - public static final int COLOR_GREY = 0xff727c7b; - public static final int COLOR_VIOLET = 0xff7700bb; - public static final int COLOR_BLACK = 0xff000000; - - public static final int TEXTURE_HEIGHT = 256; - static final int NUM_STICKERS_IN_ROW = 4; - - static final float SQ2 = (float)Math.sqrt(2); - static final float SQ3 = (float)Math.sqrt(3); - static final float SQ5 = (float)Math.sqrt(5); - static final float SQ6 = (float)Math.sqrt(6); - - private static final float NODE_RATIO = 1.60f; - private static final float MAX_SIZE_CHANGE = 1.35f; - private static final float MIN_SIZE_CHANGE = 0.75f; - - private static final Static3D CENTER = new Static3D(0,0,0); - private static final int POST_ROTATION_MILLISEC = 500; - - MeshBase[] mMeshes; - final Static4D[] OBJECT_QUATS; - final Cubit[] CUBITS; - final int NUM_FACE_COLORS; - final int NUM_TEXTURES; - final int NUM_CUBITS; - final int NUM_AXIS; - final int NUM_QUATS; - - private final int mNumCubitFaces; - private final Static3D[] mAxis; - private final float[][] mCuts; - private final int[] mNumCuts; - private final int mNodeSize; - private final float[][] mOrigPos; - private final Static3D mNodeScale; - private final Static4D mQuat; - private final int mNumLayers, mRealSize; - private final ObjectList mList; - private final DistortedEffects mEffects; - private final VertexEffectRotate mRotateEffect; - private final Dynamic1D mRotationAngle; - private final Static3D mRotationAxis; - private final Static3D mObjectScale; - private final int[] mQuatDebug; - private final float mCameraDist; - private final Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal; - private final DistortedTexture mTexture; - private final float mInitScreenRatio; - private final int mSolvedFunctionIndex; - private final boolean mIsBandaged; - private float mObjectScreenRatio; - private int[][] mSolvedQuats; - private int[][] mQuatMult; - private int[] mTmpQuats; - private int mNumTexRows, mNumTexCols; - private int mRotRowBitmap; - private int mRotAxis; - private MeshBase mMesh; - private final TwistyObjectScrambler mScrambler; - - //////////////////// SOLVED1 //////////////////////// - - private int[] mFaceMap; - private int[][] mScramble; - private int[] mColors; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistyObject(int numLayers, int realSize, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh, - DistortedEffects nodeEffects, int[][] moves, ObjectList list, Resources res, int screenWidth) - { - super(nodeTexture,nodeEffects,nodeMesh); - - mNodeSize = screenWidth; - - resizeFBO(mNodeSize, (int)(NODE_RATIO*mNodeSize)); - - mNumLayers = numLayers; - mRealSize = realSize; - mList = list; - mOrigPos = getCubitPositions(mNumLayers); - mAxis = getRotationAxis(); - mInitScreenRatio = getScreenRatio(); - mObjectScreenRatio = 1.0f; - mNumCubitFaces = getNumCubitFaces(); - mSolvedFunctionIndex = getSolvedFunctionIndex(); - - mCuts = getCuts(mNumLayers); - mNumCuts = new int[mAxis.length]; - if( mCuts==null ) for(int i=0; i3 ) - { - bandaged=true; - break; - } - } - - mIsBandaged = bandaged; - - mQuatDebug = new int[NUM_CUBITS]; - - if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE; - if( mObjectScreenRatio=2 ) return -2; - - return nonBlackIndex; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean shouldResetTextureMaps() - { - return false; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int[] buildSolvedQuats(Static3D faceAx, Static4D[] quats) - { - final float MAXD = 0.0001f; - float x = faceAx.get0(); - float y = faceAx.get1(); - float z = faceAx.get2(); - float a,dx,dy,dz,qx,qy,qz; - Static4D quat; - - int len = quats.length; - int place = 0; - - for(int q=1; q-MAXD && dx-MAXD && dy-MAXD && dz-MAXDIFF && qx-MAXDIFF && qy-MAXDIFF && qzMAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE; - if( mObjectScreenRatio-MAX_ERROR && - dY-MAX_ERROR && - dZ-MAX_ERROR && - dW-MAX_ERROR ) return i; - - dX = OBJECT_QUATS[i].get0() + rX; - dY = OBJECT_QUATS[i].get1() + rY; - dZ = OBJECT_QUATS[i].get2() + rZ; - dW = OBJECT_QUATS[i].get3() + rW; - - if( dX-MAX_ERROR && - dY-MAX_ERROR && - dZ-MAX_ERROR && - dW-MAX_ERROR ) return i; - } - - return -1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getCubitFaceColorIndex(int cubit, int face) - { - Static4D texMap = mMesh.getTextureMap(NUM_FACE_COLORS*cubit + face); - - int x = (int)(texMap.get0()/texMap.get2()); - int y = (int)(texMap.get1()/texMap.get3()); - - return (mNumTexRows-1-y)*NUM_STICKERS_IN_ROW + x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// the getFaceColors + final black in a grid (so that we do not exceed the maximum texture size) - - public void createTexture() - { - Bitmap bitmap; - - Paint paint = new Paint(); - bitmap = Bitmap.createBitmap( mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888); - Canvas canvas = new Canvas(bitmap); - - paint.setAntiAlias(true); - paint.setTextAlign(Paint.Align.CENTER); - paint.setStyle(Paint.Style.FILL); - - paint.setColor(COLOR_BLACK); - canvas.drawRect(0, 0, mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, paint); - - int face = 0; - FactorySticker factory = FactorySticker.getInstance(); - - for(int row=0; row=NUM_TEXTURES ) break; - ObjectSticker sticker = retSticker(face); - factory.drawRoundedPolygon(canvas, paint, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT, getColor(face%NUM_FACE_COLORS), sticker); - face++; - } - - if( !mTexture.setTexture(bitmap) ) - { - int max = DistortedLibrary.getMaxTextureSize(); - FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance(); - crashlytics.log("failed to set texture of size "+bitmap.getWidth()+"x"+bitmap.getHeight()+" max is "+max); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getNumLayers() - { - return mNumLayers; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public void continueRotation(float angleInDegrees) - { - mRotationAngleStatic.set0(angleInDegrees); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public Static4D getRotationQuat() - { - return mQuat; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public void recomputeScaleFactor(int scrWidth) - { - mNodeScale.set(scrWidth,NODE_RATIO*scrWidth,scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public void savePreferences(SharedPreferences.Editor editor) - { - for(int i=0; i=0 && mQuatDebug[i]=NUM_AXIS ) - { - android.util.Log.e("object", "invalid rotation axis: "+axis); - return; - } - if( row<0 || row>=mNumLayers ) - { - android.util.Log.e("object", "invalid rotation row: "+row); - return; - } - - mRotAxis = axis; - mRotRowBitmap= computeBitmapFromRow( (1<=1 ) - { - return mRotationAngle.getPoint(pointNum-1).get0(); - } - else - { - FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance(); - crashlytics.log("points in RotationAngle: "+pointNum); - return 0; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public synchronized void removeRotationNow() - { - float angle = getAngle(); - double nearestAngleInRadians = angle*Math.PI/180; - float sinA =-(float)Math.sin(nearestAngleInRadians*0.5); - float cosA = (float)Math.cos(nearestAngleInRadians*0.5); - float axisX = mAxis[mRotAxis].get0(); - float axisY = mAxis[mRotAxis].get1(); - float axisZ = mAxis[mRotAxis].get2(); - Static4D quat = new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA); - - mRotationAngle.removeAll(); - mRotationAngleStatic.set0(0); - - for(int i=0; i=basicArray.length ? 0 : axis]; - int nearestAngle = 360/basicAngle; - - int tmp = (int)((angle+nearestAngle/2)/nearestAngle); - if( angle< -(nearestAngle*0.5) ) tmp-=1; - - if( tmp!=0 ) return nearestAngle*tmp; - - return speed> 1.2f ? nearestAngle*(angle>0 ? 1:-1) : 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public float getCameraDist() - { - return mCameraDist; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getNodeSize() - { - return mNodeSize; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public ObjectList getObjectList() - { - return mList; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total) - { - mScrambler.randomizeNewScramble(scramble,rnd,curr,total); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - abstract float getScreenRatio(); - abstract float[][] getCubitPositions(int numLayers); - abstract Static4D[] getQuats(); - abstract int getNumFaceColors(); - abstract int getNumStickerTypes(int numLayers); - abstract int getNumCubitFaces(); - abstract ObjectSticker retSticker(int face); - abstract int getColor(int face); - abstract int getFaceColor(int cubit, int cubitface, int numLayers); - abstract float returnMultiplier(); - abstract float[][] getCuts(int numLayers); - abstract int getCubitVariant(int cubit, int numLayers); - abstract int getNumCubitVariants(int numLayers); - abstract Static4D getQuat(int cubit, int numLayers); - abstract ObjectShape getObjectShape(int cubit, int numLayers); - abstract int[] getSolvedQuats(int cubit, int numLayers); - abstract int getSolvedFunctionIndex(); - abstract int getFOV(); - abstract ScrambleState[] getScrambleStates(); - - public abstract Movement getMovement(); - public abstract Static3D[] getRotationAxis(); - public abstract int[] getBasicAngle(); - public abstract int getObjectName(int numLayers); - public abstract int getInventor(int numLayers); - public abstract int getComplexity(int numLayers); - } diff --git a/src/main/java/org/distorted/objects/TwistyObjectScrambler.java b/src/main/java/org/distorted/objects/TwistyObjectScrambler.java deleted file mode 100644 index 844e3d2a..00000000 --- a/src/main/java/org/distorted/objects/TwistyObjectScrambler.java +++ /dev/null @@ -1,394 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 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 . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.helpers.ScrambleState; - -import java.util.Random; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyObjectScrambler - { - private final ScrambleState[] mStates; - private final int mType; - private final int mNumAxis; - private final int mNumLayers; - - // type=0, i.e. main - private int mCurrState; - private int mIndexExcluded; - private int[][] mScrambleTable; - private int[] mNumOccurences; - - // type=1, i.e. the exception: Square-1 - private static final int BASIC_ANGLE = 12; - private static final int LAST_SL = 0; // automatic rotations: last rot was a 'slash' i.e. along ROT_AXIS[1] - private static final int LAST_UP = 1; // last rot was along ROT_AXIS[0], upper layer and forelast was a slash - private static final int LAST_LO = 2; // last rot was along ROT_AXIS[0], lower layer and forelast was a slash - private static final int LAST_UL = 3; // two last rots were along ROT_AXIS[0] (so the next must be a slash) - - private int[][] mPermittedAngles; - private int[] mCornerQuat; - private int mPermittedUp, mPermittedDo; - private int[][] mBadCornerQuats; - private int mLastRot; - private int[][] mQuatMult; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistyObjectScrambler(int type, int numAxis, int numLayers, ScrambleState[] states) - { - mType = type; - mNumAxis = numAxis; - mNumLayers = numLayers; - mStates = states; - - if( mType==1 ) - { - mPermittedAngles = new int[2][BASIC_ANGLE]; - mCornerQuat = new int[8]; - mLastRot = LAST_SL; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]] - - void initializeQuatMult() - { - mQuatMult = new int[][] - { - { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,}, - { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,}, - { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,}, - { 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,}, - { 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,}, - { 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,}, - { 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,}, - { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,}, - { 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,}, - { 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,}, - { 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,}, - { 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,}, - { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,}, - { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,}, - { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3,}, - { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5, 4,}, - { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6, 5,}, - { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7, 6,}, - { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8, 7,}, - { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8,}, - { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9,}, - { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 10,}, - { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11,}, - { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,} - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeScrambling() - { - if( mScrambleTable ==null ) - { - mScrambleTable = new int[mNumAxis][mNumLayers]; - } - if( mNumOccurences ==null ) - { - int max=0; - - for (ScrambleState mState : mStates) - { - int tmp = mState.getTotal(-1); - if (max < tmp) max = tmp; - } - - mNumOccurences = new int[max]; - } - - for(int i=0; i=12)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean cornerIsLeft(int index) - { - int q = mCornerQuat[index]; - - switch(index) - { - case 0: - case 4: return ((q>=3 && q<= 7) || (q>=18 && q<=22)); - case 1: - case 5: return ((q>=6 && q<=10) || (q>=15 && q<=19)); - case 2: - case 6: return ((q==0 || q==1 || (q>=9 && q<=11)) || (q>=12 && q<=16)); - case 3: - case 7: return ((q>=0 && q<=4) || (q==12 || q==13 || (q>=21 && q<=23))); - } - - return false; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean quatIsBad(int quatIndex, int corner) - { - if( mBadCornerQuats ==null ) - { - // quat indices that make corner cubits bandage the puzzle. - mBadCornerQuats = new int[][] { { 2, 8,17,23}, { 5,11,14,20} }; - } - - int index = (corner%2); - - return ( quatIndex== mBadCornerQuats[index][0] || - quatIndex== mBadCornerQuats[index][1] || - quatIndex== mBadCornerQuats[index][2] || - quatIndex== mBadCornerQuats[index][3] ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean isPermittedDo(int angle) - { - if( mQuatMult==null ) initializeQuatMult(); - - for(int corner=0; corner<8; corner++) - { - if( !cornerIsUp(corner) ) - { - int currQuat = mCornerQuat[corner]; - int finalQuat= mQuatMult[angle][currQuat]; - if( quatIsBad(finalQuat,corner) ) return false; - } - } - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private boolean isPermittedUp(int angle) - { - if( mQuatMult==null ) initializeQuatMult(); - - for(int corner=0; corner<8; corner++) - { - if( cornerIsUp(corner) ) - { - int currQuat = mCornerQuat[corner]; - int finalQuat= mQuatMult[angle][currQuat]; - if( quatIsBad(finalQuat,corner) ) return false; - } - } - - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void computePermittedAngles() - { - mPermittedDo = 0; - - for(int angle=0; angle