commit 3f7a4363de0d0d6811a7af427db00e7264c09c3b Author: Leszek Koltunski Date: Wed Sep 29 16:07:33 2021 +0200 Remove all files that have been separated into a new library 'objectlib' diff --git a/build.gradle b/build.gradle index acbc5977..9fab29b5 100644 --- a/build.gradle +++ b/build.gradle @@ -34,12 +34,13 @@ android { } dependencies { + api project(':distorted-library') + api project(':distorted-objectlib') + 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.2' - - api project(':distorted-library') implementation 'androidx.appcompat:appcompat:1.3.1' implementation 'com.google.android.material:material:1.4.0' } diff --git a/src/main/java/org/distorted/control/RubikControl.java b/src/main/java/org/distorted/control/RubikControl.java index 83f09cbd..57fb7b31 100644 --- a/src/main/java/org/distorted/control/RubikControl.java +++ b/src/main/java/org/distorted/control/RubikControl.java @@ -24,9 +24,11 @@ import org.distorted.library.main.DistortedNode; import org.distorted.library.main.DistortedScreen; import org.distorted.library.message.EffectListener; import org.distorted.library.type.Static4D; + +import org.distorted.objectlib.main.TwistyObject; + import org.distorted.main.RubikActivity; import org.distorted.main.RubikSurfaceView; -import org.distorted.objectlib.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 d825aec8..a5b723ca 100644 --- a/src/main/java/org/distorted/control/RubikControlRotate.java +++ b/src/main/java/org/distorted/control/RubikControlRotate.java @@ -22,7 +22,6 @@ package org.distorted.control; import android.graphics.Bitmap; import android.graphics.BitmapFactory; -import org.distorted.objectlib.QuatHelper; import org.distorted.library.effect.MatrixEffectQuaternion; import org.distorted.library.effect.MatrixEffectScale; import org.distorted.library.main.DistortedEffects; @@ -36,9 +35,12 @@ import org.distorted.library.type.Dynamic3D; import org.distorted.library.type.Dynamic4D; import org.distorted.library.type.Static3D; import org.distorted.library.type.Static4D; + +import org.distorted.objectlib.main.TwistyObject; +import org.distorted.objectlib.main.QuatHelper; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.TwistyObject; import java.io.IOException; import java.io.InputStream; diff --git a/src/main/java/org/distorted/control/RubikControlWhole.java b/src/main/java/org/distorted/control/RubikControlWhole.java index 05936ffc..3a21092f 100644 --- a/src/main/java/org/distorted/control/RubikControlWhole.java +++ b/src/main/java/org/distorted/control/RubikControlWhole.java @@ -32,6 +32,7 @@ import org.distorted.library.mesh.MeshQuad; import org.distorted.library.type.Dynamic; import org.distorted.library.type.Dynamic3D; import org.distorted.library.type.Static3D; + import org.distorted.main.R; import org.distorted.main.RubikActivity; import org.distorted.main.RubikSurfaceView; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogEffects.java b/src/main/java/org/distorted/dialogs/RubikDialogEffects.java index 9d9389cc..949323f0 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogEffects.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogEffects.java @@ -51,7 +51,7 @@ import org.distorted.main.RubikActivity; public class RubikDialogEffects extends AppCompatDialogFragment implements SeekBar.OnSeekBarChangeListener, AdapterView.OnItemSelectedListener { - private TextView[] mDurationText; + private final TextView[] mDurationText; private float mTextSize; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java index 9ace877e..938f2745 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java @@ -35,9 +35,10 @@ import android.view.Window; import android.widget.Button; import android.widget.TextView; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.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 0dceb398..d9a51af5 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPattern.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPattern.java @@ -39,9 +39,10 @@ import android.widget.Button; import android.widget.ImageView; import android.widget.TextView; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.ObjectList; import org.distorted.patterns.RubikPatternList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPatternListAdapter.java b/src/main/java/org/distorted/dialogs/RubikDialogPatternListAdapter.java index caebeaf3..35f081e8 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPatternListAdapter.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPatternListAdapter.java @@ -35,8 +35,8 @@ import org.distorted.main.R; class RubikDialogPatternListAdapter extends BaseExpandableListAdapter { - private Context mContext; - private int mTab, mWidth; + private final Context mContext; + private final int mTab, mWidth; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPatternPagerAdapter.java b/src/main/java/org/distorted/dialogs/RubikDialogPatternPagerAdapter.java index f469b6a5..479624ea 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPatternPagerAdapter.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPatternPagerAdapter.java @@ -33,10 +33,10 @@ import org.distorted.patterns.RubikPatternList; class RubikDialogPatternPagerAdapter extends PagerAdapter { - private FragmentActivity mAct; - private RubikDialogPatternView[] mViews; - private RubikDialogPattern mDialog; - private int mNumTabs; + private final FragmentActivity mAct; + private final RubikDialogPatternView[] mViews; + private final RubikDialogPattern mDialog; + private final int mNumTabs; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java index 80a640c4..98aaa5e0 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java @@ -26,9 +26,10 @@ import android.view.View; import android.widget.ExpandableListView; import android.widget.FrameLayout; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.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/RubikDialogPrivacy.java b/src/main/java/org/distorted/dialogs/RubikDialogPrivacy.java index a2979478..e959f132 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogPrivacy.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogPrivacy.java @@ -29,7 +29,6 @@ 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.TextView; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScores.java b/src/main/java/org/distorted/dialogs/RubikDialogScores.java index ed0748c9..9e00c0c1 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScores.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScores.java @@ -38,9 +38,10 @@ import android.widget.Button; import android.widget.ImageView; import android.widget.TextView; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.ObjectList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java index 2883de4b..bb65bfd4 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java @@ -30,10 +30,11 @@ import android.view.View; import android.view.ViewGroup; import android.widget.LinearLayout; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.network.RubikScores; import org.distorted.network.RubikNetwork; -import org.distorted.objectlib.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 c828c44b..f3a53e08 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java @@ -31,9 +31,10 @@ import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.TextView; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.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 14a1e0c6..5ab56b2f 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogSetName.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogSetName.java @@ -38,9 +38,10 @@ import android.widget.Button; import android.widget.EditText; import android.widget.TextView; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.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/RubikDialogSolverError.java b/src/main/java/org/distorted/dialogs/RubikDialogSolverError.java index fcea3acd..942c11d1 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogSolverError.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogSolverError.java @@ -32,7 +32,6 @@ 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.TextView; diff --git a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java index c4aaf24e..51f61785 100644 --- a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java +++ b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java @@ -35,10 +35,11 @@ import androidx.fragment.app.FragmentActivity; import com.google.firebase.analytics.FirebaseAnalytics; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.main.BuildConfig; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import org.distorted.objectlib.ObjectList; import org.distorted.tutorials.TutorialList; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/BaseEffect.java b/src/main/java/org/distorted/effects/BaseEffect.java index 3d37932a..27a51fa4 100644 --- a/src/main/java/org/distorted/effects/BaseEffect.java +++ b/src/main/java/org/distorted/effects/BaseEffect.java @@ -23,11 +23,12 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import android.content.SharedPreferences; +import org.distorted.library.main.DistortedScreen; + import org.distorted.effects.scramble.ScrambleEffect; import org.distorted.effects.objectchange.ObjectChangeEffect; import org.distorted.effects.solve.SolveEffect; import org.distorted.effects.win.WinEffect; -import org.distorted.library.main.DistortedScreen; import org.distorted.main.R; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/EffectController.java b/src/main/java/org/distorted/effects/EffectController.java index ec2fe22d..885119e7 100644 --- a/src/main/java/org/distorted/effects/EffectController.java +++ b/src/main/java/org/distorted/effects/EffectController.java @@ -19,9 +19,9 @@ package org.distorted.effects; -import org.distorted.helpers.MovesFinished; import org.distorted.library.message.EffectListener; -import org.distorted.objectlib.TwistyObject; +import org.distorted.objectlib.main.TwistyObject; +import org.distorted.helpers.MovesFinished; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java b/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java index 67378ec1..fb6e816b 100644 --- a/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java +++ b/src/main/java/org/distorted/effects/objectchange/ObjectChangeEffect.java @@ -19,15 +19,17 @@ package org.distorted.effects.objectchange; -import org.distorted.effects.BaseEffect; +import java.lang.reflect.Method; + import org.distorted.library.effect.Effect; 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.objectlib.TwistyObject; -import java.lang.reflect.Method; +import org.distorted.objectlib.main.TwistyObject; + +import org.distorted.effects.BaseEffect; +import org.distorted.effects.EffectController; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java b/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java index 2b52cc6b..7de0c200 100644 --- a/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java +++ b/src/main/java/org/distorted/effects/scramble/ScrambleEffect.java @@ -19,18 +19,20 @@ package org.distorted.effects.scramble; -import org.distorted.effects.BaseEffect; -import org.distorted.helpers.MovesFinished; +import java.lang.reflect.Method; +import java.util.Random; + import org.distorted.library.effect.Effect; 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.objectlib.ObjectList; -import org.distorted.objectlib.TwistyObject; -import java.lang.reflect.Method; -import java.util.Random; +import org.distorted.objectlib.main.ObjectList; +import org.distorted.objectlib.main.TwistyObject; + +import org.distorted.effects.BaseEffect; +import org.distorted.effects.EffectController; +import org.distorted.helpers.MovesFinished; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/scramble/ScrambleEffectRotations.java b/src/main/java/org/distorted/effects/scramble/ScrambleEffectRotations.java index 1370c10b..9bfb2863 100644 --- a/src/main/java/org/distorted/effects/scramble/ScrambleEffectRotations.java +++ b/src/main/java/org/distorted/effects/scramble/ScrambleEffectRotations.java @@ -19,6 +19,8 @@ package org.distorted.effects.scramble; +import java.util.Random; + import org.distorted.library.effect.Effect; import org.distorted.library.effect.MatrixEffectMove; import org.distorted.library.effect.MatrixEffectQuaternion; @@ -28,8 +30,6 @@ import org.distorted.library.type.DynamicQuat; import org.distorted.library.type.Static3D; import org.distorted.library.type.Static4D; -import java.util.Random; - /////////////////////////////////////////////////////////////////////////////////////////////////// public class ScrambleEffectRotations extends ScrambleEffect diff --git a/src/main/java/org/distorted/effects/solve/SolveEffect.java b/src/main/java/org/distorted/effects/solve/SolveEffect.java index eed228d8..b7a9f7dd 100644 --- a/src/main/java/org/distorted/effects/solve/SolveEffect.java +++ b/src/main/java/org/distorted/effects/solve/SolveEffect.java @@ -19,15 +19,17 @@ package org.distorted.effects.solve; -import org.distorted.effects.BaseEffect; +import java.lang.reflect.Method; + import org.distorted.library.effect.Effect; 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.objectlib.TwistyObject; -import java.lang.reflect.Method; +import org.distorted.objectlib.main.TwistyObject; + +import org.distorted.effects.BaseEffect; +import org.distorted.effects.EffectController; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/effects/win/WinEffect.java b/src/main/java/org/distorted/effects/win/WinEffect.java index 6752d90a..ce1f4905 100644 --- a/src/main/java/org/distorted/effects/win/WinEffect.java +++ b/src/main/java/org/distorted/effects/win/WinEffect.java @@ -19,15 +19,17 @@ package org.distorted.effects.win; -import org.distorted.effects.BaseEffect; +import java.lang.reflect.Method; + import org.distorted.library.effect.Effect; 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.objectlib.TwistyObject; -import java.lang.reflect.Method; +import org.distorted.objectlib.main.TwistyObject; + +import org.distorted.effects.BaseEffect; +import org.distorted.effects.EffectController; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/helpers/BlockController.java b/src/main/java/org/distorted/helpers/BlockController.java index 53e01049..a36e54be 100644 --- a/src/main/java/org/distorted/helpers/BlockController.java +++ b/src/main/java/org/distorted/helpers/BlockController.java @@ -21,13 +21,13 @@ package org.distorted.helpers; import com.google.firebase.crashlytics.FirebaseCrashlytics; -import org.distorted.library.message.EffectMessageSender; -import org.distorted.main.BuildConfig; - import java.lang.ref.WeakReference; import java.util.Timer; import java.util.TimerTask; +import org.distorted.library.message.EffectMessageSender; +import org.distorted.main.BuildConfig; + /////////////////////////////////////////////////////////////////////////////////////////////////// public class BlockController diff --git a/src/main/java/org/distorted/helpers/MovesAndLockController.java b/src/main/java/org/distorted/helpers/MovesAndLockController.java index a5fda393..9264b03e 100644 --- a/src/main/java/org/distorted/helpers/MovesAndLockController.java +++ b/src/main/java/org/distorted/helpers/MovesAndLockController.java @@ -19,6 +19,10 @@ package org.distorted.helpers; +import java.util.ArrayList; +import java.util.Timer; +import java.util.TimerTask; + import android.view.View; import android.widget.ImageButton; import android.widget.LinearLayout; @@ -26,10 +30,6 @@ import android.widget.LinearLayout; import org.distorted.main.R; import org.distorted.main.RubikActivity; -import java.util.ArrayList; -import java.util.Timer; -import java.util.TimerTask; - /////////////////////////////////////////////////////////////////////////////////////////////////// public class MovesAndLockController implements MovesFinished diff --git a/src/main/java/org/distorted/main/RubikActivity.java b/src/main/java/org/distorted/main/RubikActivity.java index e735bc65..471a0304 100644 --- a/src/main/java/org/distorted/main/RubikActivity.java +++ b/src/main/java/org/distorted/main/RubikActivity.java @@ -21,7 +21,6 @@ package org.distorted.main; import android.content.Intent; import android.content.SharedPreferences; -import android.content.res.Resources; import android.os.Build; import android.os.Bundle; import android.os.LocaleList; @@ -36,44 +35,21 @@ import android.widget.LinearLayout; import com.google.firebase.analytics.FirebaseAnalytics; +import org.distorted.library.main.DistortedLibrary; +import org.distorted.library.main.DistortedScreen; +import org.distorted.library.type.Static4D; + +import org.distorted.objectlib.main.TwistyObject; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.dialogs.RubikDialogError; import org.distorted.dialogs.RubikDialogPrivacy; import org.distorted.effects.BaseEffect; import org.distorted.helpers.BlockController; import org.distorted.helpers.TwistyActivity; import org.distorted.helpers.TwistyPreRender; -import org.distorted.library.main.DistortedEffects; -import org.distorted.library.main.DistortedLibrary; - -import org.distorted.library.main.DistortedScreen; -import org.distorted.library.main.DistortedTexture; -import org.distorted.library.mesh.MeshSquare; -import org.distorted.library.type.Static4D; -import org.distorted.objectlib.TwistyObject; import org.distorted.network.RubikScores; import org.distorted.network.RubikNetwork; -import org.distorted.objectlib.ObjectList; -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.screens.ScreenList; import org.distorted.screens.RubikScreenPlay; import org.distorted.tutorials.TutorialActivity; @@ -674,40 +650,4 @@ public class RubikActivity extends TwistyActivity myIntent.putExtra("siz", size); startActivity(myIntent); } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static TwistyObject create(ObjectList object, int size, Static4D quat, int[][] moves, Resources res, int scrWidth) - { - DistortedTexture texture = new DistortedTexture(); - DistortedEffects effects = new DistortedEffects(); - MeshSquare mesh = new MeshSquare(20,20); // mesh of the node, not of the cubits - - switch(object.ordinal()) - { - case 0: return new TwistyCube (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 1: return new TwistyJing (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 2: return new TwistyPyraminx (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 3: return new TwistyKilominx (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 4: return new TwistyMegaminx (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 5: return new TwistyUltimate (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 6: return new TwistyDiamond (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 7: return new TwistyDino6 (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 8: return new TwistyDino4 (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 9: return new TwistyRedi (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 10: return new TwistyHelicopter (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 11: return new TwistySkewb (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 12: return new TwistyIvy (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 13: return new TwistyRex (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 14: return new TwistyBandagedFused (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 15: return new TwistyBandaged2Bar (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 16: return new TwistyBandaged3Plate (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 17: return new TwistyBandagedEvil (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 18: return new TwistySquare1 (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 19: return new TwistySquare2 (size, quat, texture, mesh, effects, moves, res, scrWidth); - case 20: return new TwistyMirror (size, quat, texture, mesh, effects, moves, res, scrWidth); - } - - return null; - } } diff --git a/src/main/java/org/distorted/main/RubikPreRender.java b/src/main/java/org/distorted/main/RubikPreRender.java index df6c4100..b35fda65 100644 --- a/src/main/java/org/distorted/main/RubikPreRender.java +++ b/src/main/java/org/distorted/main/RubikPreRender.java @@ -34,6 +34,9 @@ import com.google.android.play.core.tasks.OnFailureListener; import com.google.android.play.core.tasks.Task; import com.google.firebase.analytics.FirebaseAnalytics; +import org.distorted.objectlib.main.TwistyObject; +import org.distorted.objectlib.main.ObjectList; + import org.distorted.dialogs.RubikDialogNewRecord; import org.distorted.dialogs.RubikDialogSolved; import org.distorted.effects.BaseEffect; @@ -42,8 +45,6 @@ import org.distorted.effects.scramble.ScrambleEffect; import org.distorted.helpers.BlockController; import org.distorted.helpers.MovesFinished; import org.distorted.helpers.TwistyPreRender; -import org.distorted.objectlib.TwistyObject; -import org.distorted.objectlib.ObjectList; import org.distorted.network.RubikScores; import org.distorted.screens.RubikScreenPlay; import org.distorted.screens.ScreenList; @@ -124,7 +125,7 @@ public class RubikPreRender implements EffectController, TwistyPreRender Context con = mView.getContext(); Resources res = con.getResources(); - mNewObject = RubikActivity.create(object,size, mView.getQuat(), moves, res, mScreenWidth); + mNewObject = object.create(size, mView.getQuat(), moves, res, mScreenWidth); if( mNewObject!=null ) { diff --git a/src/main/java/org/distorted/main/RubikSurfaceView.java b/src/main/java/org/distorted/main/RubikSurfaceView.java index adf843ea..ce68f80a 100644 --- a/src/main/java/org/distorted/main/RubikSurfaceView.java +++ b/src/main/java/org/distorted/main/RubikSurfaceView.java @@ -30,17 +30,19 @@ import android.view.MotionEvent; import com.google.firebase.crashlytics.FirebaseCrashlytics; -import org.distorted.objectlib.QuatHelper; import org.distorted.library.type.Static2D; import org.distorted.library.type.Static4D; -import org.distorted.objectlib.TwistyObject; -import org.distorted.objectlib.Movement; + +import org.distorted.objectlib.main.QuatHelper; +import org.distorted.objectlib.main.TwistyObject; +import org.distorted.objectlib.main.Movement; + import org.distorted.screens.RubikScreenReady; -import org.distorted.solvers.SolverMain; import org.distorted.screens.ScreenList; import org.distorted.screens.RubikScreenPlay; import org.distorted.screens.RubikScreenSolver; import org.distorted.screens.RubikScreenSolving; +import org.distorted.solvers.SolverMain; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/network/RubikNetwork.java b/src/main/java/org/distorted/network/RubikNetwork.java index e1207644..ec092b03 100644 --- a/src/main/java/org/distorted/network/RubikNetwork.java +++ b/src/main/java/org/distorted/network/RubikNetwork.java @@ -19,6 +19,13 @@ package org.distorted.network; +import java.io.InputStream; +import java.net.HttpURLConnection; +import java.net.URL; +import java.net.UnknownHostException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + import android.app.Activity; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; @@ -27,16 +34,9 @@ import androidx.appcompat.app.AppCompatActivity; import androidx.fragment.app.FragmentActivity; import org.distorted.library.main.DistortedLibrary; -import org.distorted.objectlib.ObjectList; - -import java.io.InputStream; -import java.net.HttpURLConnection; -import java.net.URL; -import java.net.UnknownHostException; -import java.security.MessageDigest; -import java.security.NoSuchAlgorithmException; +import org.distorted.objectlib.main.ObjectList; -import static org.distorted.objectlib.ObjectList.MAX_LEVEL; +import static org.distorted.objectlib.main.ObjectList.MAX_LEVEL; /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/network/RubikScores.java b/src/main/java/org/distorted/network/RubikScores.java index 3f298859..0b07ef66 100644 --- a/src/main/java/org/distorted/network/RubikScores.java +++ b/src/main/java/org/distorted/network/RubikScores.java @@ -19,20 +19,21 @@ package org.distorted.network; +import java.util.UUID; + import android.content.Context; import android.content.SharedPreferences; import android.telephony.TelephonyManager; import com.google.firebase.crashlytics.FirebaseCrashlytics; -import org.distorted.main.BuildConfig; -import org.distorted.objectlib.ObjectList; +import static org.distorted.objectlib.main.ObjectList.MAX_NUM_OBJECTS; +import static org.distorted.objectlib.main.ObjectList.NUM_OBJECTS; +import static org.distorted.objectlib.main.ObjectList.MAX_LEVEL; -import java.util.UUID; +import org.distorted.objectlib.main.ObjectList; -import static org.distorted.objectlib.ObjectList.MAX_NUM_OBJECTS; -import static org.distorted.objectlib.ObjectList.NUM_OBJECTS; -import static org.distorted.objectlib.ObjectList.MAX_LEVEL; +import org.distorted.main.BuildConfig; /////////////////////////////////////////////////////////////////////////////////////////////////// // hold my own scores, and some other statistics. diff --git a/src/main/java/org/distorted/objectlib/Cubit.java b/src/main/java/org/distorted/objectlib/Cubit.java deleted file mode 100644 index 21393a9c..00000000 --- a/src/main/java/org/distorted/objectlib/Cubit.java +++ /dev/null @@ -1,227 +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.objectlib; - -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.objectlib; - -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.objectlib; - -import static org.distorted.objectlib.TwistyObject.COLOR_BLACK; -import static org.distorted.objectlib.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.objectlib; - -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.objectlib; - -import static org.distorted.objectlib.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/objectlib/Movement4.java b/src/main/java/org/distorted/objectlib/Movement4.java deleted file mode 100644 index ec4599ff..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/Movement6.java b/src/main/java/org/distorted/objectlib/Movement6.java deleted file mode 100644 index c5ae97ba..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/Movement8.java b/src/main/java/org/distorted/objectlib/Movement8.java deleted file mode 100644 index 8eb3414b..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/ObjectList.java b/src/main/java/org/distorted/objectlib/ObjectList.java deleted file mode 100644 index 2115db6d..00000000 --- a/src/main/java/org/distorted/objectlib/ObjectList.java +++ /dev/null @@ -1,559 +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.objectlib; - -import org.distorted.main.R; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -/* - CUBE_2 ( 0, 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} ), - CUBE_3 ( 0, new int[] {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} ), - CUBE_4 ( 0, new int[] {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} ), - CUBE_5 ( 0, new int[] {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} ), - JING_2 ( 1, 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} ), - PYRA_3 ( 1, 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} ), - PYRA_4 ( 1, new int[] {4 , 14, 17, R.raw.pyra4, R.drawable.ui_small_pyra4, R.drawable.ui_medium_pyra4, R.drawable.ui_big_pyra4, R.drawable.ui_huge_pyra4} ), - PYRA_5 ( 1, new int[] {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} ), - KILO_3 ( 2, 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} ), - KILO_5 ( 2, new int[] {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} ), - MEGA_3 ( 2, 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} ), - MEGA_5 ( 2, new int[] {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} ), - ULTI_2 ( 3, 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 } ), - DIAM_2 ( 3, 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} ), - DIAM_3 ( 3, new int[] {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} ), - DIAM_4 ( 3, new int[] {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} ), - DINO_3 ( 4, 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 } ), - DIN4_3 ( 4, 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 } ), - REDI_3 ( 4, 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 } ), - HELI_3 ( 4, 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 } ), - SKEW_2 ( 5, new int[] {2 , 11, 11, R.raw.skew2, R.drawable.ui_small_skew2, R.drawable.ui_medium_skew2, R.drawable.ui_big_skew2, R.drawable.ui_huge_skew2} ), - SKEW_3 ( 5, new int[] {3 , 17, 21, R.raw.skew3, R.drawable.ui_small_skew3, R.drawable.ui_medium_skew3, R.drawable.ui_big_skew3, R.drawable.ui_huge_skew3} ), - IVY_2 ( 5, 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 } ), - REX_3 ( 5, 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 } ), - BAN1_3 ( 6, 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 } ), - BAN2_3 ( 6, 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 } ), - BAN3_3 ( 6, 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 } ), - BAN4_3 ( 6, 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 } ), - SQU1_3 ( 7, new int[] {3 , 24, 24, R.raw.squa1, R.drawable.ui_small_squa1, R.drawable.ui_medium_squa1, R.drawable.ui_big_squa1, R.drawable.ui_huge_squa1} ), - SQU2_3 ( 7, new int[] {3 , 24, 24, R.raw.squa2, R.drawable.ui_small_squa2, R.drawable.ui_medium_squa2, R.drawable.ui_big_squa2, R.drawable.ui_huge_squa2} ), - MIRR_2 ( 7, 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} ), - MIRR_3 ( 7, new int[] {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} ), - ; -*/ - -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_skew2, R.drawable.ui_medium_skew2, R.drawable.ui_big_skew2, R.drawable.ui_huge_skew2} , - {3 , 17, 21, R.raw.skew3, R.drawable.ui_small_skew3, R.drawable.ui_medium_skew3, R.drawable.ui_big_skew3, R.drawable.ui_huge_skew3} , - }, - 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.squa1, R.drawable.ui_small_squa1, R.drawable.ui_medium_squa1, R.drawable.ui_big_squa1, R.drawable.ui_huge_squa1} , - }, - 7 - ), - - SQU2 ( - new int[][] { - {3 , 24, 24, R.raw.squa2, R.drawable.ui_small_squa2, R.drawable.ui_medium_squa2, R.drawable.ui_big_squa2, R.drawable.ui_huge_squa2} , - }, - 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.objectlib; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -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/objectlib/ObjectSticker.java b/src/main/java/org/distorted/objectlib/ObjectSticker.java deleted file mode 100644 index 3ec70849..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -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/objectlib/QuatHelper.java b/src/main/java/org/distorted/objectlib/QuatHelper.java deleted file mode 100644 index 0efff80d..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/ScrambleState.java b/src/main/java/org/distorted/objectlib/ScrambleState.java deleted file mode 100644 index 7a53bbd9..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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.objectlib; - -import java.util.ArrayList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// producer of the ScrambleStateGraph - but only for a single Twisty Puzzle, the 'BandagedEvil'. - -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/objectlib/ScrambleStateSquare1.java b/src/main/java/org/distorted/objectlib/ScrambleStateSquare1.java deleted file mode 100644 index 8969715c..00000000 --- a/src/main/java/org/distorted/objectlib/ScrambleStateSquare1.java +++ /dev/null @@ -1,593 +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.objectlib; - -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/objectlib/Twisty12.java b/src/main/java/org/distorted/objectlib/Twisty12.java deleted file mode 100644 index 22ea3246..00000000 --- a/src/main/java/org/distorted/objectlib/Twisty12.java +++ /dev/null @@ -1,95 +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.objectlib; - -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/objectlib/Twisty4.java b/src/main/java/org/distorted/objectlib/Twisty4.java deleted file mode 100644 index 72818ca2..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/Twisty6.java b/src/main/java/org/distorted/objectlib/Twisty6.java deleted file mode 100644 index 8c424f85..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/Twisty8.java b/src/main/java/org/distorted/objectlib/Twisty8.java deleted file mode 100644 index cbc0cbb8..00000000 --- a/src/main/java/org/distorted/objectlib/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.objectlib; - -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/objectlib/TwistyObject.java b/src/main/java/org/distorted/objectlib/TwistyObject.java deleted file mode 100644 index de070a7d..00000000 --- a/src/main/java/org/distorted/objectlib/TwistyObject.java +++ /dev/null @@ -1,1314 +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.objectlib; - -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/objectlib/TwistyObjectScrambler.java b/src/main/java/org/distorted/objectlib/TwistyObjectScrambler.java deleted file mode 100644 index 37b31b7d..00000000 --- a/src/main/java/org/distorted/objectlib/TwistyObjectScrambler.java +++ /dev/null @@ -1,392 +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.objectlib; - -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.res.Resources; - -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyBandaged2Bar extends TwistyBandagedAbstract -{ - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { {} , {0,1,1, 0,-1,1, 2,1,2, 2,-1,2}, {} }), - new ScrambleState( new int[][] { {0,-1,1, 0,1,1, 0,2,1, 2,-1,1, 2,1,1, 2,2,1}, {0,2,1, 2,2,1} , {} }), - new ScrambleState( new int[][] { {}, {0,2,2, 2,2,2} , {0,-1,2, 0,1,2, 0,2,2, 2,-1,2, 2,1,2, 2,2,2} }) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float[][] getPositions() - { - if( POSITIONS==null ) - { - POSITIONS = new float[][] - { - { 0.0f, +1.0f, 1.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, -1.0f}, - {-1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f}, - {-1.0f, +1.0f, +1.0f}, - {-1.0f, +1.0f, 0.0f}, - {-1.0f, +1.0f, -1.0f}, - {-1.0f, 0.0f, +1.0f}, - {-1.0f, 0.0f, 0.0f}, - {-1.0f, 0.0f, -1.0f}, - {-1.0f, -1.0f, +1.0f}, - {-1.0f, -1.0f, -1.0f}, - {+1.0f, +1.0f, +1.0f}, - {+1.0f, +1.0f, 0.0f}, - {+1.0f, +1.0f, -1.0f}, - {+1.0f, 0.0f, +1.0f}, - {+1.0f, 0.0f, 0.0f}, - {+1.0f, 0.0f, -1.0f}, - {+1.0f, -1.0f, +1.0f}, - {+1.0f, -1.0f, -1.0f}, - { 0.0f, 0.0f, +1.0f}, - { 0.0f, -1.0f, +1.0f}, - { 0.0f, 0.0f, -1.0f}, - { 0.0f, -1.0f, -1.0f} - }; - } - - return POSITIONS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int[] getQuatIndices() - { - if( QUAT_INDICES==null ) - { - QUAT_INDICES = new int[] { 2 }; - } - - return QUAT_INDICES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public int getObjectName(int numLayers) - { - return R.string.bandaged_2bar; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.bandaged_2bar_inventor; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - return 8; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java b/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java deleted file mode 100644 index f7edb245..00000000 --- a/src/main/java/org/distorted/objects/TwistyBandaged3Plate.java +++ /dev/null @@ -1,135 +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 android.content.res.Resources; - -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyBandaged3Plate extends TwistyBandagedAbstract -{ - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {{ 2,-1, 1, 2, 1, 6 }, { 0,-1, 5, 0, 1, 3 }, { 2,-1, 2, 2, 1, 4 }} ), - new ScrambleState( new int[][] {{ 2, 1, 0 }, { }, { 2, 1,10, 2, 2, 7 }} ), - new ScrambleState( new int[][] {{ }, { 0,-1,11, 0, 2, 8 }, { 2, 1, 0 }} ), - new ScrambleState( new int[][] {{ 2, 1,12, 2, 2, 9 }, { 0,-1, 0 }, { }} ), - new ScrambleState( new int[][] {{ 2,-1,10, 2, 2,13 }, { }, { 2,-1, 0 }} ), - new ScrambleState( new int[][] {{ }, { 0, 1, 0 }, { 2,-1,11, 2, 2,14 }} ), - new ScrambleState( new int[][] {{ 2,-1, 0 }, { 0, 1,12, 0, 2,15 }, { }} ), - new ScrambleState( new int[][] {{ }, { 2,-2, 7, 2,-1, 7, 2, 1, 7, 2, 2, 7}, { 2,-1,10, 2, 2, 1 }} ), - new ScrambleState( new int[][] {{ 0,-2, 8, 0,-1, 8, 0, 1, 8, 0, 2, 8}, { 0, 1,11, 0, 2, 2 }, { }} ), - new ScrambleState( new int[][] {{ 2,-1,12, 2, 2, 3 }, { }, { 0,-2, 9, 0,-1, 9, 0, 1, 9, 0, 2, 9}} ), - new ScrambleState( new int[][] {{ 2,-1,13, 2, 1, 4 }, { 2,-2,10, 2,-1,10, 2, 1,10, 2, 2,10}, { 2,-1, 1, 2, 1, 7 }} ), - new ScrambleState( new int[][] {{ 0,-2,11, 0,-1,11, 0, 1,11, 0, 2,11}, { 0,-1, 8, 0, 1, 2 }, { 2,-1,14, 2, 1, 5 }} ), - new ScrambleState( new int[][] {{ 2,-1, 3, 2, 1, 9 }, { 0,-1, 6, 0, 1,15 }, { 0,-2,12, 0,-1,12, 0, 1,12, 0, 2,12}} ), - new ScrambleState( new int[][] {{ 2, 1,10, 2, 2, 4 }, { 2,-2,13, 2,-1,13, 2, 1,13, 2, 2,13}, { }} ), - new ScrambleState( new int[][] {{ 0,-2,14, 0,-1,14, 0, 1,14, 0, 2,14}, { }, { 2, 1,11, 2, 2, 5 }} ), - new ScrambleState( new int[][] {{ }, { 0,-1,12, 0, 2, 6 }, { 0,-2,15, 0,-1,15, 0, 1,15, 0, 2,15}} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float[][] getPositions() - { - if( POSITIONS==null ) - { - POSITIONS = new float[][] - { - {-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f}, - { 1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f}, - {-1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f}, - { 1.0f, 1.0f, 1.0f}, - { 1.0f, 0.0f, 1.0f}, - { 1.0f, -1.0f, 1.0f}, - {-1.0f, -1.0f, 1.0f}, - { 0.0f, -1.0f, 1.0f}, - { 1.0f, -1.0f, 0.0f}, - { 1.0f, -1.0f, -1.0f}, - {-1.0f, 1.0f, -1.0f}, - {-1.0f, 1.0f, 0.0f}, - { 0.0f, 1.0f, -1.0f}, - { 0.0f, 1.0f, 0.0f}, - {-1.0f, 0.0f, -1.0f}, - {-1.0f, 0.0f, 0.0f}, - { 0.0f, 0.0f, -1.0f} - }; - } - return POSITIONS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int[] getQuatIndices() - { - if( QUAT_INDICES==null ) - { - QUAT_INDICES = new int[] { 1,3 }; - } - - return QUAT_INDICES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public int getObjectName(int numLayers) - { - return R.string.bandaged_3plate; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.bandaged_3plate_inventor; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - return 8; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java deleted file mode 100644 index 6aa795fd..00000000 --- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java +++ /dev/null @@ -1,483 +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 static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class TwistyBandagedAbstract extends Twisty6 -{ - // the three rotation axis of a 3x3 Cube. Must be normalized. - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(1,0,0), - new Static3D(0,1,0), - new Static3D(0,0,1) - }; - - private static final int[][] mDimensions = new int[][] - { - {1,1,1}, // has to be X>=Z>=Y so that all - {2,1,1}, // the faces are horizontal - {3,1,1}, - {2,1,2}, - {2,2,2} - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}}, - }; - - private static final int NUM_STICKERS = 4; - - private int[] mBasicAngle; - private Static4D[] mQuats; - private ObjectSticker[] mStickers; - private Static4D[] mInitQuats; - private int[][] mAxisMap; - private int[][] mFaceMap; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private Movement mMovement; - ScrambleState[] mStates; - float[][] POSITIONS; - int[] QUAT_INDICES; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistyBandagedAbstract(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth) - { - super(size, size, quat, texture, mesh, effects, moves, list, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - abstract float[][] getPositions(); - abstract int[] getQuatIndices(); - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f), - - new Static4D( SQ2/2, SQ2/2, 0.0f , 0.0f), - new Static4D( SQ2/2, -SQ2/2, 0.0f , 0.0f), - new Static4D( SQ2/2, 0.0f, SQ2/2, 0.0f), - new Static4D(-SQ2/2, 0.0f, SQ2/2, 0.0f), - new Static4D( SQ2/2, 0.0f, 0.0f, SQ2/2), - new Static4D( SQ2/2, 0.0f, 0.0f, -SQ2/2), - new Static4D( 0.0f, SQ2/2, SQ2/2, 0.0f), - new Static4D( 0.0f, SQ2/2, -SQ2/2, 0.0f), - new Static4D( 0.0f, SQ2/2, 0.0f, SQ2/2), - new Static4D( 0.0f, SQ2/2, 0.0f, -SQ2/2), - new Static4D( 0.0f, 0.0f, SQ2/2, SQ2/2), - new Static4D( 0.0f, 0.0f, SQ2/2, -SQ2/2), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f), - new Static4D( -0.5f, -0.5f, -0.5f, 0.5f), - new Static4D( -0.5f, 0.5f, -0.5f, -0.5f), - new Static4D( -0.5f, 0.5f, 0.5f, -0.5f), - new Static4D( -0.5f, 0.5f, 0.5f, 0.5f) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNumCubits() - { - return getPositions().length; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] getCubitPosition(int cubit) - { - float[][] pos = getPositions(); - - return ( cubit>=0 && cubit< pos.length ) ? pos[cubit] : null; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int getQuatIndex(int cubit) - { - int[] indices = getQuatIndices(); - return ( cubit>=0 && cubit< indices.length ) ? indices[cubit] : 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectShape getObjectShape(int cubit, int numLayers) - { - int variant = getCubitVariant(cubit,numLayers); - - final int[][] vert_indices = - { - {2,3,1,0}, - {7,6,4,5}, - {4,0,1,5}, - {7,3,2,6}, - {6,2,0,4}, - {3,7,5,1}, - }; - - float defHeight = 0.048f; - int[] bandIndices = new int[] { 0,0,1,1,2,2 }; - float[][] corners = new float[][] { {0.04f,0.15f} }; - int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - int[] centerIndices = new int[] { 0,1,2,3,4,5,6,7 }; - - int X = mDimensions[variant][0]; - int Y = mDimensions[variant][1]; - int Z = mDimensions[variant][2]; - - int maxXY = Math.max(X,Y); - int maxXZ = Math.max(X,Z); - int maxYZ = Math.max(Y,Z); - - double[][] vertices = - { - {+0.5f*X,+0.5f*Y,+0.5f*Z}, - {+0.5f*X,+0.5f*Y,-0.5f*Z}, - {+0.5f*X,-0.5f*Y,+0.5f*Z}, - {+0.5f*X,-0.5f*Y,-0.5f*Z}, - {-0.5f*X,+0.5f*Y,+0.5f*Z}, - {-0.5f*X,+0.5f*Y,-0.5f*Z}, - {-0.5f*X,-0.5f*Y,+0.5f*Z}, - {-0.5f*X,-0.5f*Y,-0.5f*Z} - }; - - float[][] bands= new float[][] - { - {defHeight/maxYZ,65,0.25f,0.5f,5,1,2}, - {defHeight/maxXZ,65,0.25f,0.5f,5,1,2}, - {defHeight/maxXY,65,0.25f,0.5f,5,1,2} - }; - - float[][] centers = new float[][] - { - {+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)}, - {+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)}, - {+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)}, - {+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)}, - {-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)}, - {-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)}, - {-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)}, - {-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)} - }; - - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D getQuat(int cubit, int numLayers) - { - if( mInitQuats ==null ) - { - mInitQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f), // NULL - new Static4D( SQ2/2, 0.0f, 0.0f, -SQ2/2), // X - new Static4D( 0.0f, SQ2/2, 0.0f, -SQ2/2), // Y - new Static4D( 0.0f, 0.0f, SQ2/2, -SQ2/2), // Z - new Static4D( -0.5f, +0.5f, -0.5f, +0.5f), // ZX - new Static4D( +0.5f, +0.5f, +0.5f, -0.5f), // YX - }; - } - - return mInitQuats[getQuatIndex(cubit)]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumCubitVariants(int numLayers) - { - return mDimensions.length; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getCubitVariant(int cubit, int numLayers) - { - float[][] pos = getPositions(); - - if( cubit>=0 && cubit (numLayers-1)*0.5f; - - return reaches ? stickerIndex*NUM_FACE_COLORS + face : NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public Static3D[] getRotationAxis() - { - return ROT_AXIS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public Movement getMovement() - { - if( mMovement==null ) - { - int numLayers = getNumLayers(); - if( mCuts==null ) getCuts(numLayers); - getLayerRotatable(numLayers); - mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers,TYPE_NOT_SPLIT,ENABLED); - } - return mMovement; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getBasicAngle() - { - if( mBasicAngle ==null ) mBasicAngle = new int[] { 4,4,4 }; - return mBasicAngle; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java b/src/main/java/org/distorted/objects/TwistyBandagedEvil.java deleted file mode 100644 index 9e0ab7e2..00000000 --- a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java +++ /dev/null @@ -1,259 +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 android.content.res.Resources; - -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyBandagedEvil extends TwistyBandagedAbstract -{ - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {{2, 1, 1,2,-1, 2} , {2, 2,142,2,-1, 28} , {0, 1,114} }), //0 - new ScrambleState( new int[][] {{2, 2, 2} , {2,-1,143} , {} }), - new ScrambleState( new int[][] {{2, 2, 1} , {} , {0, 1, 3,0, 2, 47} }), - new ScrambleState( new int[][] {{2, 1, 4} , {2, 1,132,2,-1,131} , {0, 1, 47,0,-1, 2} }), - new ScrambleState( new int[][] {{2,-1, 3} , {2, 1, 5,2,-1, 6} , {} }), - new ScrambleState( new int[][] {{} , {2, 2, 6,2,-1, 4} , {0, 1, 51} }), - new ScrambleState( new int[][] {{} , {2, 1, 4,2, 2, 5} , {2, 2, 7,2,-1, 80} }), - new ScrambleState( new int[][] {{2, 2, 8} , {} , {2, 1, 80,2, 2, 6} }), - new ScrambleState( new int[][] {{2, 2, 7} , {} , {0,-1, 9} }), - new ScrambleState( new int[][] {{2, 1, 10,2, 2, 11,2,-1, 12}, {} , {0, 1, 8} }), - new ScrambleState( new int[][] {{2, 1, 11,2, 2, 12,2,-1, 9}, {} , {0,-1,118} }), //10 - new ScrambleState( new int[][] {{2, 1, 12,2, 2, 9,2,-1, 10}, {} , {2, 1, 77} }), - new ScrambleState( new int[][] {{2, 1, 9,2, 2, 10,2,-1, 11}, {} , {2, 1, 13,2, 2,143} }), - new ScrambleState( new int[][] {{2, 1, 14,2, 2, 15,2,-1, 16}, {2, 1, 57,2,-1, 58} , {2, 1,143,2,-1, 12} }), - new ScrambleState( new int[][] {{2, 1, 15,2, 2, 16,2,-1, 13}, {} , {2, 1, 41} }), - new ScrambleState( new int[][] {{2, 1, 16,2, 2, 13,2,-1, 14}, {} , {0, 1, 82} }), - new ScrambleState( new int[][] {{2, 1, 13,2, 2, 14,2,-1, 15}, {2, 1, 17,2,-1, 18} , {0, 1,111,0,-1,115} }), - new ScrambleState( new int[][] {{} , {2, 2, 18,2,-1, 16} , {0,-1,139} }), - new ScrambleState( new int[][] {{2, 1, 19,2,-1, 20} , {2, 1, 16,2, 2, 17} , {2, 1,142} }), - new ScrambleState( new int[][] {{2, 2, 20,2,-1, 18} , {} , {2, 1, 39,2, 2,140} }), - new ScrambleState( new int[][] {{2, 1, 18,2, 2, 19} , {2, 1, 21} , {} }), //20 - new ScrambleState( new int[][] {{} , {2,-1, 20} , {0,-1, 22} }), - new ScrambleState( new int[][] {{2, 2, 23,2,-1, 24} , {} , {0, 1, 21} }), - new ScrambleState( new int[][] {{2, 1, 24,2, 2, 22} , {} , {2, 1, 92} }), - new ScrambleState( new int[][] {{2, 1, 22,2,-1, 23} , {} , {0, 1, 25} }), - new ScrambleState( new int[][] {{2, 1, 26,2, 2, 27} , {} , {0,-1, 24} }), - new ScrambleState( new int[][] {{2, 1, 27,2,-1, 25} , {2, 1, 74} , {} }), - new ScrambleState( new int[][] {{2, 2, 25,2,-1, 26} , {} , {2, 1, 28,2, 2,124} }), - new ScrambleState( new int[][] {{2, 1, 29,2, 2, 30,2,-1, 31}, {2,-1,142} , {2, 1,124,2,-1, 27} }), - new ScrambleState( new int[][] {{2, 1, 30,2, 2, 31,2,-1, 28}, {} , {2, 1,141} }), - new ScrambleState( new int[][] {{2, 1, 31,2, 2, 28,2,-1, 29}, {} , {0, 1,130} }), //30 - new ScrambleState( new int[][] {{2, 1, 28,2, 2, 29,2,-1, 30}, {2, 1, 32,2,-1, 33} , {0, 1, 89,0,-1, 90} }), - new ScrambleState( new int[][] {{} , {2, 2, 33,2,-1, 31} , {0,-1,137} }), - new ScrambleState( new int[][] {{2, 1, 34} , {2, 1, 31,2, 2, 32} , {} }), - new ScrambleState( new int[][] {{2,-1, 33} , {} , {2, 1, 35} }), - new ScrambleState( new int[][] {{} , {2,-1, 36} , {2,-1, 34} }), - new ScrambleState( new int[][] {{} , {2, 1, 35} , {2,-1, 37} }), - new ScrambleState( new int[][] {{} , {2, 1, 38,2, 2, 93} , {2, 1, 36} }), - new ScrambleState( new int[][] {{2, 1, 39} , {2, 1, 93,2,-1, 37} , {} }), - new ScrambleState( new int[][] {{2,-1, 38} , {2, 1, 40,2,-1, 64} , {2, 1,140,2,-1, 19} }), - new ScrambleState( new int[][] {{2, 1, 41,2,-1, 42} , {2, 2, 64,2,-1, 39} , {} }), //40 - new ScrambleState( new int[][] {{2, 2, 42,2,-1, 40} , {} , {2,-1, 14} }), - new ScrambleState( new int[][] {{2, 1, 40,2, 2, 41} , {} , {0, 1, 43,0, 2,128} }), - new ScrambleState( new int[][] {{2, 1, 44,2,-1, 45} , {2, 1,114,2, 2,113,2,-1, 86}, {0, 1,128,0,-1, 42} }), - new ScrambleState( new int[][] {{2, 2, 45,2,-1, 43} , {2, 1, 48,2,-1,108} , {2,-1, 81} }), - new ScrambleState( new int[][] {{2, 1, 43,2, 2, 44} , {} , {0, 1, 46} }), - new ScrambleState( new int[][] {{} , {2, 1, 47} , {0,-1, 45} }), - new ScrambleState( new int[][] {{} , {2,-1, 46} , {0, 2, 2,0,-1, 3} }), - new ScrambleState( new int[][] {{2,-1, 49} , {2, 2,108,2,-1, 44} , {} }), - new ScrambleState( new int[][] {{2, 1, 48} , {} , {0, 1, 50} }), - new ScrambleState( new int[][] {{} , {2, 1, 51,2, 2, 52} , {0,-1, 49} }), //50 - new ScrambleState( new int[][] {{} , {2, 1, 52,2,-1, 50} , {0,-1, 5} }), - new ScrambleState( new int[][] {{} , {2, 2, 50,2,-1, 51} , {2,-1, 53} }), - new ScrambleState( new int[][] {{} , {2, 1, 54,2, 2, 55} , {2, 1, 52} }), - new ScrambleState( new int[][] {{} , {2, 1, 55,2,-1, 53} , {0,-1,104} }), - new ScrambleState( new int[][] {{} , {2, 2, 53,2,-1, 54} , {0, 2, 56,0,-1, 65} }), - new ScrambleState( new int[][] {{2, 1, 57} , {} , {0, 1, 65,0, 2, 55} }), - new ScrambleState( new int[][] {{2,-1, 56} , {2, 2, 58,2,-1, 13} , {} }), - new ScrambleState( new int[][] {{} , {2, 1, 13,2, 2, 57} , {2,-1, 59} }), - new ScrambleState( new int[][] {{2, 1, 60} , {} , {2, 1, 58} }), - new ScrambleState( new int[][] {{2,-1, 59} , {} , {2, 1, 61} }), //60 - new ScrambleState( new int[][] {{2,-1, 62} , {} , {2,-1, 60} }), - new ScrambleState( new int[][] {{2, 1, 61} , {2,-1, 63} , {} }), - new ScrambleState( new int[][] {{} , {2, 1, 62} , {2, 1, 64} }), - new ScrambleState( new int[][] {{} , {2, 1, 39,2, 2, 40} , {2,-1, 63} }), - new ScrambleState( new int[][] {{2, 1, 66,2,-1, 67} , {2, 1, 78,2, 2, 79,2,-1, 80}, {0, 1, 55,0,-1, 56} }), - new ScrambleState( new int[][] {{2, 2, 67,2,-1, 65} , {2,-1,107} , {} }), - new ScrambleState( new int[][] {{2, 1, 65,2, 2, 66} , {} , {0, 1, 68} }), - new ScrambleState( new int[][] {{} , {2, 1, 69} , {0,-1, 67} }), - new ScrambleState( new int[][] {{} , {2,-1, 68} , {0,-1, 70} }), - new ScrambleState( new int[][] {{} , {2,-1, 71} , {0, 1, 69} }), //70 - new ScrambleState( new int[][] {{2,-1, 72} , {2, 1, 70} , {} }), - new ScrambleState( new int[][] {{2, 1, 71} , {} , {0,-1, 73} }), - new ScrambleState( new int[][] {{2, 1, 74,2, 2, 75} , {} , {0, 1, 72} }), - new ScrambleState( new int[][] {{2, 1, 75,2,-1, 73} , {2,-1, 26} , {0, 1, 83,0,-1,138} }), - new ScrambleState( new int[][] {{2, 2, 73,2,-1, 74} , {2, 1, 76,2,-1, 77} , {} }), - new ScrambleState( new int[][] {{} , {2, 2, 77,2,-1, 75} , {0, 1, 78} }), - new ScrambleState( new int[][] {{} , {2, 1, 75,2, 2, 76} , {2,-1, 11} }), - new ScrambleState( new int[][] {{} , {2, 1, 79,2, 2, 80,2,-1, 65}, {0,-1, 76} }), - new ScrambleState( new int[][] {{} , {2, 1, 80,2, 2, 65,2,-1, 78}, {2,-1,110} }), - new ScrambleState( new int[][] {{2, 1, 81,2,-1, 82} , {2, 1, 65,2, 2, 78,2,-1, 79}, {2, 1, 6,2,-1, 7} }), //80 - new ScrambleState( new int[][] {{2, 2, 82,2,-1, 80} , {} , {2, 1, 44} }), - new ScrambleState( new int[][] {{2, 1, 80,2, 2, 81} , {2, 1, 83,2,-1, 84} , {0,-1, 15} }), - new ScrambleState( new int[][] {{} , {2, 2, 84,2,-1, 82} , {0, 2,138,0,-1, 74} }), - new ScrambleState( new int[][] {{2, 1, 85} , {2, 1, 82,2, 2, 83} , {} }), - new ScrambleState( new int[][] {{2,-1, 84} , {} , {2, 1, 86,2, 2,119} }), - new ScrambleState( new int[][] {{2, 1, 87,2,-1, 88} , {2, 1, 43,2, 2,114,2,-1,113}, {2, 1,119,2,-1, 85} }), - new ScrambleState( new int[][] {{2, 2, 88,2,-1, 86} , {} , {2, 1, 94} }), - new ScrambleState( new int[][] {{2, 1, 86,2, 2, 87} , {2, 1, 89} , {} }), - new ScrambleState( new int[][] {{} , {2,-1, 88} , {0, 2, 90,0,-1, 31} }), - new ScrambleState( new int[][] {{2, 1, 91,2, 2, 92} , {} , {0, 1, 31,0, 2, 89} }), //90 - new ScrambleState( new int[][] {{2, 1, 92,2,-1, 90} , {} , {0, 1, 93} }), - new ScrambleState( new int[][] {{2, 2, 90,2,-1, 91} , {} , {2,-1, 23} }), - new ScrambleState( new int[][] {{} , {2, 2, 37,2,-1, 38} , {0,-1, 91} }), - new ScrambleState( new int[][] {{} , {2,-1, 95} , {2,-1, 87} }), - new ScrambleState( new int[][] {{} , {2, 1, 94} , {2,-1, 96} }), - new ScrambleState( new int[][] {{} , {2, 1, 97} , {2, 1, 95} }), - new ScrambleState( new int[][] {{2, 1, 98} , {2,-1, 96} , {} }), - new ScrambleState( new int[][] {{2,-1, 97} , {} , {2,-1, 99} }), - new ScrambleState( new int[][] {{2, 2,100,2,-1,101} , {} , {2, 1, 98} }), - new ScrambleState( new int[][] {{2, 1,101,2, 2, 99} , {2, 1,111,2,-1,112} , {} }), //100 - new ScrambleState( new int[][] {{2, 1, 99,2,-1,100} , {2, 1,102} , {2, 1,108,2,-1,109} }), - new ScrambleState( new int[][] {{2, 1,103,2,-1,104} , {2,-1,101} , {} }), - new ScrambleState( new int[][] {{2, 2,104,2,-1,102} , {} , {2,-1,105} }), - new ScrambleState( new int[][] {{2, 1,102,2, 2,103} , {} , {0, 1, 54} }), - new ScrambleState( new int[][] {{2,-1,106} , {} , {2, 1,103} }), - new ScrambleState( new int[][] {{2, 1,105} , {} , {2, 1,107} }), - new ScrambleState( new int[][] {{} , {2, 1, 66} , {2,-1,106} }), - new ScrambleState( new int[][] {{} , {2, 1, 44,2, 2, 48} , {2, 2,109,2,-1,101} }), - new ScrambleState( new int[][] {{2,-1,110} , {} , {2, 1,101,2, 2,108} }), - new ScrambleState( new int[][] {{2, 1,109} , {} , {2, 1, 79} }), //110 - new ScrambleState( new int[][] {{} , {2, 2,112,2,-1,100} , {0, 2,115,0,-1, 16} }), - new ScrambleState( new int[][] {{} , {2, 1,100,2, 2,111} , {2, 1,113} }), - new ScrambleState( new int[][] {{} , {2, 1, 86,2, 2, 43,2,-1,114}, {2,-1,112} }), - new ScrambleState( new int[][] {{} , {2, 1,113,2, 2, 86,2,-1, 43}, {0,-1, 0} }), - new ScrambleState( new int[][] {{2, 2,116} , {} , {0, 1, 16,0, 2,111} }), - new ScrambleState( new int[][] {{2, 2,115} , {} , {2,-1,117} }), - new ScrambleState( new int[][] {{2, 1,118} , {} , {2, 1,116} }), - new ScrambleState( new int[][] {{2,-1,117} , {} , {0, 1, 10} }), - new ScrambleState( new int[][] {{} , {2, 1,120,2, 2,121,2,-1,122}, {2, 2, 85,2,-1, 86} }), - new ScrambleState( new int[][] {{} , {2, 1,121,2, 2,122,2,-1,119}, {2,-1,129} }), //120 - new ScrambleState( new int[][] {{} , {2, 1,122,2, 2,119,2,-1,120}, {0, 1,125} }), - new ScrambleState( new int[][] {{} , {2, 1,119,2, 2,120,2,-1,121}, {0,-1,123} }), - new ScrambleState( new int[][] {{} , {2, 2,124} , {0, 1,122} }), - new ScrambleState( new int[][] {{} , {2, 2,123} , {2, 2, 27,2,-1, 28} }), - new ScrambleState( new int[][] {{} , {2, 1,126} , {0,-1,121} }), - new ScrambleState( new int[][] {{} , {2,-1,125} , {2,-1,127} }), - new ScrambleState( new int[][] {{} , {2, 2,128} , {2, 1,126} }), - new ScrambleState( new int[][] {{} , {2, 2,127} , {0, 2, 42,0,-1, 43} }), - new ScrambleState( new int[][] {{2, 2,130,2,-1,131} , {} , {2, 1,120} }), - new ScrambleState( new int[][] {{2, 1,131,2, 2,129} , {} , {0,-1, 30} }), //130 - new ScrambleState( new int[][] {{2, 1,129,2,-1,130} , {2, 1, 3,2, 2,132} , {} }), - new ScrambleState( new int[][] {{} , {2, 2,131,2,-1, 3} , {0,-1,133} }), - new ScrambleState( new int[][] {{} , {2,-1,134} , {0, 1,132} }), - new ScrambleState( new int[][] {{2,-1,135} , {2, 1,133} , {} }), - new ScrambleState( new int[][] {{2, 1,134} , {} , {0,-1,136} }), - new ScrambleState( new int[][] {{2, 1,137} , {} , {0, 1,135} }), - new ScrambleState( new int[][] {{2,-1,136} , {} , {0, 1, 32} }), - new ScrambleState( new int[][] {{2, 1,139} , {} , {0, 1, 74,0, 2, 83} }), - new ScrambleState( new int[][] {{2,-1,138} , {} , {0, 1, 17} }), - new ScrambleState( new int[][] {{} , {2, 1,141} , {2, 2, 19,2,-1, 39} }), //140 - new ScrambleState( new int[][] {{} , {2,-1,140} , {2,-1, 29} }), - new ScrambleState( new int[][] {{} , {2, 1, 28} , {2,-1, 18} }), - new ScrambleState( new int[][] {{} , {2, 1, 1} , {2, 2, 12,2,-1, 13} }) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float[][] getPositions() - { - if( POSITIONS==null ) - { - POSITIONS = new float[][] - { - { 1.0f, 1.0f, -1.0f}, - {-1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f}, - {-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, -1.0f}, - {-1.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f}, - {-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, -1.0f}, - {-1.0f, 1.0f, 0.0f, -1.0f, 1.0f, 1.0f}, - { 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f}, - { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f}, - {-1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 1.0f}, - { 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f}, - { 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f}, - { 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f}, - { 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, -1.0f} - }; - } - return POSITIONS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int[] getQuatIndices() - { - if( QUAT_INDICES==null ) - { - QUAT_INDICES = new int[] { 0, 1, 0, 0, 0, 2, 2, 2, 3, 3, 3, 3, 3 }; - } - - return QUAT_INDICES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public int getObjectName(int numLayers) - { - return R.string.bandaged_evil; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.bandaged_evil_inventor; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - return 8; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyBandagedFused.java b/src/main/java/org/distorted/objects/TwistyBandagedFused.java deleted file mode 100644 index c72683f1..00000000 --- a/src/main/java/org/distorted/objects/TwistyBandagedFused.java +++ /dev/null @@ -1,128 +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 android.content.res.Resources; - -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyBandagedFused extends TwistyBandagedAbstract -{ - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] tmp = {0,-1,0, 0,1,0, 0,2,0, 2,-1,0, 2,1,0, 2,2,0}; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - float[][] getPositions() - { - if( POSITIONS==null ) - { - POSITIONS = new float[][] - { - {-1.0f, -1.0f, +0.0f, - -1.0f, -1.0f, +1.0f, - -1.0f, 0.0f, +0.0f, - -1.0f, 0.0f, +1.0f, - 0.0f, -1.0f, +0.0f, - 0.0f, -1.0f, +1.0f, - 0.0f, 0.0f, +0.0f, - 0.0f, 0.0f, +1.0f}, - {-1.0f, +1.0f, +1.0f}, - {-1.0f, +1.0f, +0.0f}, - {-1.0f, +1.0f, -1.0f}, - { 0.0f, +1.0f, +1.0f}, - { 0.0f, +1.0f, +0.0f}, - { 0.0f, +1.0f, -1.0f}, - { 1.0f, +1.0f, +1.0f}, - { 1.0f, +1.0f, +0.0f}, - { 1.0f, +1.0f, -1.0f}, - { 1.0f, 0.0f, +1.0f}, - { 1.0f, 0.0f, +0.0f}, - { 1.0f, 0.0f, -1.0f}, - { 1.0f, -1.0f, +1.0f}, - { 1.0f, -1.0f, +0.0f}, - { 1.0f, -1.0f, -1.0f}, - {-1.0f, -1.0f, -1.0f}, - {-1.0f, 0.0f, -1.0f}, - { 0.0f, -1.0f, -1.0f}, - { 0.0f, 0.0f, -1.0f} - }; - } - return POSITIONS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int[] getQuatIndices() - { - if( QUAT_INDICES==null ) QUAT_INDICES = new int[] { 0 }; - return QUAT_INDICES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC APi - - public int getObjectName(int numLayers) - { - return R.string.bandaged_fused; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.bandaged_fused_inventor; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - return 8; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java deleted file mode 100644 index 8d01baae..00000000 --- a/src/main/java/org/distorted/objects/TwistyCube.java +++ /dev/null @@ -1,422 +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 static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyCube extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(1,0,0), - new Static3D(0,1,0), - new Static3D(0,0,1) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}}, - }; - - private ScrambleState[] mStates; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[] mBasicAngle; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int size = getNumLayers(); - int[][] m = new int[16][]; - for(int i=1; i<16; i++) m[i] = createEdges(size,i); - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ), // 0 - new ScrambleState( new int[][] { null, m[ 4], m[ 5] } ), // x - new ScrambleState( new int[][] { m[ 6], null, m[ 7] } ), // y - new ScrambleState( new int[][] { m[ 8], m[ 8], null } ), // z - new ScrambleState( new int[][] { m[10], null, m[ 7] } ), // xy - new ScrambleState( new int[][] { m[11], m[ 9], null } ), // xz - new ScrambleState( new int[][] { null, m[12], m[ 5] } ), // yx - new ScrambleState( new int[][] { m[ 8], m[13], null } ), // yz - new ScrambleState( new int[][] { null, m[ 4], m[14] } ), // zx - new ScrambleState( new int[][] { m[ 6], null, m[15] } ), // zy - new ScrambleState( new int[][] { null, null, m[ 5] } ), // xyx - new ScrambleState( new int[][] { null, m[ 4], null } ), // xzx - new ScrambleState( new int[][] { null, null, m[ 7] } ), // yxy - new ScrambleState( new int[][] { m[ 6], null, null } ), // yzy - new ScrambleState( new int[][] { null, m[ 9], null } ), // zxz - new ScrambleState( new int[][] { m[ 8], null, null } ), // zyz - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int[] createEdges(int size, int vertex) - { - int[] ret = new int[9*size]; - - for(int l=0; l1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1; - float[][] tmp = new float[numCubits][]; - - float diff = 0.5f*(numLayers-1); - int currentPosition = 0; - - for(int x = 0; x. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement8; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty8; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyDiamond extends Twisty8 -{ - // the four rotation axis of a Diamond. Must be normalized. - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ6/3,+SQ3/3, 0), - new Static3D(-SQ6/3,+SQ3/3, 0), - new Static3D( 0,-SQ3/3,-SQ6/3), - new Static3D( 0,-SQ3/3,+SQ6/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2,3}},{{1,2,3}},{{0,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,3}},{{0,1,2}},{{0,1,2}} - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private int[] mFaceMap; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private Static4D[] mQuats; - private int[] mTetraToFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - 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); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int size = getNumLayers(); - int[] tmp = new int[3*2*size]; - - for(int i=0; i<2*size; i++) - { - tmp[3*i ] = (i0; i--) - { - height += SQ2/2; - index = createOctaPositions(CENTERS,index,i,+height); - index = createOctaPositions(CENTERS,index,i,-height); - } - - height = SQ2/4; - - for(int i=layers; i>1; i--) - { - index = createTetraPositions(CENTERS,index,i,+height); - index = createTetraPositions(CENTERS,index,i,-height); - height += SQ2/2; - } - - return CENTERS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int retFaceTetraBelongsTo(int tetra, int numLayers) - { - if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4}; - - for(int i=numLayers-1; i>0; i--) - { - if( tetra < 8*i ) return mTetraToFaceMap[tetra/i]; - tetra -= 8*i; - } - - return -1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectShape getObjectShape(int cubit, int numLayers) - { - int variant = getCubitVariant(cubit,numLayers); - int N = numLayers>3 ? 5:6; - int E = numLayers>2 ? (numLayers>3 ? 0:1):2; - - if( variant==0 ) - { - double[][] vertices = new double[][] - { - { 0.5, 0.0, 0.5}, - { 0.5, 0.0,-0.5}, - {-0.5, 0.0,-0.5}, - {-0.5, 0.0, 0.5}, - { 0.0, SQ2/2, 0.0}, - { 0.0,-SQ2/2, 0.0} - }; - - int[][] vert_indices = new int[][] - { - {3,0,4}, - {0,1,4}, - {1,2,4}, - {2,3,4}, - {5,0,3}, - {5,1,0}, - {5,2,1}, - {5,3,2} - }; - - float[][] bands = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} }; - int[] bandIndices = new int[] { 0,0,0,0,0,0,0,0 }; - float[][] corners = new float[][] { {0.04f,0.20f} }; - int[] cornerIndices = new int[] { 0,0,0,0,0,0 }; - float[][] centers = new float[][] { {0.0f, 0.0f, 0.0f} }; - int[] centerIndices = new int[] { 0,0,0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else - { - double[][] vertices = new double[][] { {-0.5, SQ2/4, 0.0}, { 0.5, SQ2/4, 0.0}, { 0.0,-SQ2/4, 0.5}, { 0.0,-SQ2/4,-0.5} }; - int[][] vert_indices = new int[][] { {2,1,0}, {2,3,1}, {3,2,0}, {3,0,1} }; - float[][] bands = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} }; - int[] bandIndices = new int[] { 0,0,0,0 }; - float[][] corners = new float[][] { {0.08f,0.15f} }; - int[] cornerIndices = new int[] { 0,0,0,0 }; - float[][] centers = new float[][] { {0.0f, 0.0f, 0.0f} }; - int[] centerIndices = new int[] { 0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D getQuat(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int numO = getNumOctahedrons(numLayers); - - if( cubit0 ? NUM_TEXTURES : retFaceTetraBelongsTo(cubit-numO, size); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectSticker retSticker(int face) - { - if( mStickers==null ) - { - float[][] STICKERS = new float[][] { { -0.4330127f, -0.25f, 0.4330127f, -0.25f, 0.0f, 0.5f } }; - float radius = 0.06f; - float stroke = 0.07f; - float[] radii = new float[] {radius,radius,radius}; - mStickers = new ObjectSticker[STICKERS.length]; - mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke); - } - - return mStickers[face/NUM_FACE_COLORS]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public Static3D[] getRotationAxis() - { - return ROT_AXIS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public Movement getMovement() - { - if( mMovement==null ) - { - int numLayers = getNumLayers(); - if( mCuts==null ) getCuts(numLayers); - getLayerRotatable(numLayers); - mMovement = new Movement8(ROT_AXIS,mCuts,mLayerRotatable,numLayers,TYPE_NOT_SPLIT,ENABLED); - } - return mMovement; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getBasicAngle() - { - if( mBasicAngle ==null ) mBasicAngle = new int[] { 3,3,3,3 }; - return mBasicAngle; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getObjectName(int numLayers) - { - switch(numLayers) - { - case 2: return R.string.diam2; - case 3: return R.string.diam3; - case 4: return R.string.diam4; - } - - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - switch(numLayers) - { - case 2: return R.string.diam2_inventor; - case 3: return R.string.diam3_inventor; - case 4: return R.string.diam4_inventor; - } - - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - switch(numLayers) - { - case 2: return 4; - case 3: return 6; - case 4: return 8; - } - - return 0; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java deleted file mode 100644 index b4a8078b..00000000 --- a/src/main/java/org/distorted/objects/TwistyDino.java +++ /dev/null @@ -1,264 +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 static org.distorted.objectlib.Movement.TYPE_SPLIT_CORNER; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class TwistyDino extends Twisty6 -{ - // the four rotation axis of a RubikDino. Must be normalized. - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0,1},{3,1},{2,3},{0,2}}, - {{2,3},{3,1},{0,1},{0,2}}, - {{1,2},{0,1},{0,3},{2,3}}, - {{1,2},{2,3},{0,3},{0,1}}, - {{0,3},{0,2},{1,2},{1,3}}, - {{1,2},{0,2},{0,3},{1,3}}, - }; - - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private ObjectSticker[] mStickers; - private float[][] mCenters; - private Movement mMovement; - ScrambleState[] mStates; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistyDino(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth) - { - super(size, size, quat, texture, mesh, effects, moves, obj, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int size) - { - if( mCuts==null ) - { - float[] cut = new float[] { -SQ3/3, +SQ3/3 }; - mCuts = new float[][] { cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[] {true,false,true}; - mLayerRotatable = new boolean[numAxis][]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyDino4 extends TwistyDino -{ - private int[] mFaceMap; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyDino4(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) - { - super(size, quat, texture, mesh, effects, moves, ObjectList.DIN4, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{0,1,5,0,-1,5 },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ },{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{ },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ },{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{ },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{ } } ), - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - return null; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getFaceColor(int cubit, int cubitface, int size) - { - if( mFaceMap==null ) mFaceMap = new int[] { 4, 2, 2, 4, 0, 2, 1, 4, 0, 0, 1, 1 }; - return (cubitface==0 || cubitface==1) ? mFaceMap[cubit] : NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean shouldResetTextureMaps() - { - return true; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getObjectName(int numLayers) - { - return R.string.din43; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.din43_inventor; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyDino6.java b/src/main/java/org/distorted/objects/TwistyDino6.java deleted file mode 100644 index 8c752875..00000000 --- a/src/main/java/org/distorted/objects/TwistyDino6.java +++ /dev/null @@ -1,113 +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.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyDino6 extends TwistyDino -{ - private int[] mFaceMap; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyDino6(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) - { - super(size, quat, texture, mesh, effects, moves, ObjectList.DINO, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { {0,1,1,0,-1,1, 2,1,2,2,-1,2},{0,1,3,0,-1,3, 2,1,4,2,-1,4},{0,1,5,0,-1,5, 2,1,6,2,-1,6},{0,1,7,0,-1,7, 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ },{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{ },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ },{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{ },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{ } } ), - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - return null; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getFaceColor(int cubit, int cubitface, int size) - { - if( mFaceMap==null ) - { - mFaceMap = new int[] { 4,2, 0,4, 4,3, 1,4, 2,0, 3,0, 3,1, 2,1, 5,2, 0,5, 5,3, 1,5 }; - } - - switch(cubitface) - { - case 0 : return mFaceMap[2*cubit]; - case 1 : return mFaceMap[2*cubit+1]; - default: return NUM_TEXTURES; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getObjectName(int numLayers) - { - return R.string.dino3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.dino3_inventor; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java deleted file mode 100644 index 10eae53e..00000000 --- a/src/main/java/org/distorted/objects/TwistyHelicopter.java +++ /dev/null @@ -1,471 +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 static org.distorted.objectlib.Movement.TYPE_SPLIT_EDGE; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyHelicopter extends Twisty6 -{ - // the six rotation axis of a Helicopter. Must be normalized. - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D( 0, +SQ2/2, -SQ2/2), - new Static3D( 0, -SQ2/2, -SQ2/2), - new Static3D(+SQ2/2, 0, -SQ2/2), - new Static3D(-SQ2/2, 0, -SQ2/2), - new Static3D(+SQ2/2, -SQ2/2, 0), - new Static3D(-SQ2/2, -SQ2/2, 0) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{2,5},{2,4},{3,4},{3,5}}, - {{2,4},{2,5},{3,5},{3,4}}, - {{0,5},{1,5},{1,4},{0,4}}, - {{0,4},{1,4},{1,5},{0,5}}, - {{1,3},{0,3},{0,2},{1,2}}, - {{0,3},{1,3},{1,2},{0,2}}, - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private float[][] mCenters; - private int[] mQuatIndices; - private int[][] mFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyHelicopter(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.HELI, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { {0,1,1,2,1,2},{0,1,3,2,1,4},{0,1,5,2,1,6},{0,1,7,2,1,8},{0,1,9,2,1,10},{0,1,11,2,1,12} } ), - new ScrambleState( new int[][] { { },{ },{0,1,5 },{0,1,7 },{ 2,1,10},{ 2,1,12} } ), - new ScrambleState( new int[][] { { },{ },{ 2,1,6},{ 2,1,8},{0,1,9 },{0,1,11 } } ), - new ScrambleState( new int[][] { { },{ },{0,1,5 },{0,1,7 },{0,1,9 },{0,1,11 } } ), - new ScrambleState( new int[][] { { },{ },{ 2,1,6},{ 2,1,8},{ 2,1,10},{ 2,1,12} } ), - new ScrambleState( new int[][] { {0,1,1 },{0,1,3 },{ },{ },{0,1,9 },{ 2,1,12} } ), - new ScrambleState( new int[][] { { 2,1,2},{ 2,1,4},{ },{ },{ 2,1,10},{0,1,11 } } ), - new ScrambleState( new int[][] { {0,1,1 },{0,1,3 },{ },{ },{ 2,1,10},{0,1,11 } } ), - new ScrambleState( new int[][] { { 2,1,2},{ 2,1,4},{ },{ },{0,1,9 },{ 2,1,12} } ), - new ScrambleState( new int[][] { { 2,1,2},{0,1,3 },{0,1,5 },{ 2,1,8},{ },{ } } ), - new ScrambleState( new int[][] { {0,1,1 },{ 2,1,4},{ 2,1,6},{0,1,7 },{ },{ } } ), - new ScrambleState( new int[][] { { 2,1,2},{0,1,3 },{ 2,1,6},{0,1,7 },{ },{ } } ), - new ScrambleState( new int[][] { {0,1,1 },{ 2,1,4},{0,1,5 },{ 2,1,8},{ },{ } } ), - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.00f, 0.00f, 0.00f, 1.00f ), - new Static4D( 1.00f, 0.00f, 0.00f, 0.00f ), - new Static4D( 0.00f, 1.00f, 0.00f, 0.00f ), - new Static4D( 0.00f, 0.00f, 1.00f, 0.00f ), - - new Static4D( SQ2/2, SQ2/2, 0.00f, 0.00f ), - new Static4D( SQ2/2, -SQ2/2, 0.00f, 0.00f ), - new Static4D( SQ2/2, 0.00f, SQ2/2, 0.00f ), - new Static4D( SQ2/2, 0.00f, -SQ2/2, 0.00f ), - new Static4D( SQ2/2, 0.00f, 0.00f, SQ2/2 ), - new Static4D( SQ2/2, 0.00f, 0.00f, -SQ2/2 ), - new Static4D( 0.00f, SQ2/2, SQ2/2, 0.00f ), - new Static4D( 0.00f, SQ2/2, -SQ2/2, 0.00f ), - new Static4D( 0.00f, SQ2/2, 0.00f, SQ2/2 ), - new Static4D( 0.00f, SQ2/2, 0.00f, -SQ2/2 ), - new Static4D( 0.00f, 0.00f, SQ2/2, SQ2/2 ), - new Static4D( 0.00f, 0.00f, SQ2/2, -SQ2/2 ), - - new Static4D( 0.50f, 0.50f, 0.50f, 0.50f ), - new Static4D( 0.50f, 0.50f, 0.50f, -0.50f ), - new Static4D( 0.50f, 0.50f, -0.50f, 0.50f ), - new Static4D( 0.50f, 0.50f, -0.50f, -0.50f ), - new Static4D( 0.50f, -0.50f, 0.50f, 0.50f ), - new Static4D( 0.50f, -0.50f, 0.50f, -0.50f ), - new Static4D( 0.50f, -0.50f, -0.50f, 0.50f ), - new Static4D( 0.50f, -0.50f, -0.50f, -0.50f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int size) - { - if( mCuts==null ) - { - float[] cut = new float[] { -3*SQ2/4, +3*SQ2/4 }; - mCuts = new float[][] { cut,cut,cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[] {true,false,true}; - mLayerRotatable = new boolean[numAxis][]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_SPLIT_CORNER; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyIvy extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0},{3},{3},{0}}, - {{2},{1},{1},{2}}, - {{2},{0},{0},{2}}, - {{1},{3},{3},{1}}, - {{0},{0},{1},{1}}, - {{2},{2},{3},{3}}, - }; - - private static final int NUM_STICKERS = 2; - public static final float IVY_D = 0.006f; - private static final int IVY_N = 8; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[][] mFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyIvy(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.IVY, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,0 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return NUM_STICKERS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - if( mCuts==null ) - { - float[] cut = new float[] {0.0f}; - mCuts = new float[][] { cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[numLayers]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement4; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty4; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyJing extends Twisty4 -{ - static final Static3D[] ROT_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), - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}} - }; - - static final float F = 0.48f; // length of the edge of the corner cubit. Keep<0.5 - // Assuming the length of the edge of the whole - // tetrahedron is 2.0 (ie standard, equal to numLayers - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private int[] mRotQuat; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private float[][] mCenters; - private int[][] mFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyJing(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.JING, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,0 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f), - new Static4D( SQ2/2, 0.5f, 0.0f, 0.5f), - new Static4D(-SQ2/2, 0.5f, 0.0f, 0.5f), - new Static4D( 0.0f, -0.5f, -SQ2/2, 0.5f), - new Static4D( 0.0f, -0.5f, SQ2/2, 0.5f), - new Static4D( SQ2/2, 0.5f, 0.0f, -0.5f), - new Static4D(-SQ2/2, 0.5f, 0.0f, -0.5f), - new Static4D( 0.0f, -0.5f, -SQ2/2, -0.5f), - new Static4D( 0.0f, -0.5f, SQ2/2, -0.5f), - new Static4D( SQ2/2, 0.0f, SQ2/2, 0.0f), - new Static4D(-SQ2/2, 0.0f, SQ2/2, 0.0f) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement4.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCubitPositions(int size) - { - if( mCenters==null ) - { - mCenters = new float[][] - { - { 0.000f, -SQ2/2, 1.000f }, - { 0.000f, -SQ2/2,-1.000f }, - {-1.000f, SQ2/2, 0.000f }, - { 1.000f, SQ2/2, 0.000f }, - - { 0.000f, -SQ2/2, 0.000f }, - {-0.500f, 0.000f, 0.500f }, - { 0.500f, 0.000f, 0.500f }, - {-0.500f, 0.000f,-0.500f }, - { 0.500f, 0.000f,-0.500f }, - { 0.000f, SQ2/2, 0.000f }, - - { 0.000f, SQ2/6, 1.0f/3 }, - { 0.000f, SQ2/6,-1.0f/3 }, - {-1.0f/3, -SQ2/6, 0.000f }, - { 1.0f/3, -SQ2/6, 0.000f }, - }; - } - - return mCenters; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int size) - { - if( mCuts==null ) - { - float[] cut = { (F-0.5f)*(SQ6/3) }; - mCuts = new float[][] { cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[numLayers]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement12.COS54; -import static org.distorted.objectlib.Movement12.SIN54; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.QuatHelper; -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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyKilominx extends TwistyMinx -{ - private int[] mCenterFaceMap; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyKilominx(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.KILO, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeCenterFaceMap() - { - mCenterFaceMap = new int[] - { - 0,0,0,0,1, - 1,0,1,1,0, - 2,0,1,1,0, - 2,2,1,0,2, - 2,1,0,0,1, - 1,2,0,1,0, - 0,1,0,1,1, - 0,1,0,2,0, - 2,1,2,2,2, - 1,0,2,1,2, - 2,1,0,1,2, - 2,2,2,2,2 - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int numCubitsPerCorner(int numLayers) - { - return 3*((numLayers-3)/2)*((numLayers-5)/2) + (numLayers<5 ? 0:1); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int numCubitsPerEdge(int numLayers) - { - return numLayers<5 ? 0 : 2*(numLayers-4); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return numLayers<5 ? 1 : numLayers/2 + 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - return genericGetCuts(numLayers,0.5f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Fill out mCurrCorner{X,Y,Z} by applying appropriate Quat to mBasicCorner{X,Y,Z} -// Appropriate one: QUATS[QUAT_INDICES[corner]]. - - private void computeBasicCornerVectors(int corner) - { - if( mQuatCornerIndices==null ) initializeQuatIndices(); - if( mQuats==null ) initializeQuats(); - if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV(); - - Static4D quat = mQuats[mQuatCornerIndices[corner]]; - - mCurrCornerV[0] = QuatHelper.rotateVectorByQuat(mBasicCornerV[0],quat); - mCurrCornerV[1] = QuatHelper.rotateVectorByQuat(mBasicCornerV[1],quat); - mCurrCornerV[2] = QuatHelper.rotateVectorByQuat(mBasicCornerV[2],quat); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeCorner(int numCubitsPerCorner, int numLayers, int corner, int part) - { - if( mCorners==null ) initializeCorners(); - if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV(); - - float D = numLayers/3.0f; - float[] corn = mCorners[corner]; - - if( part==0 ) - { - return new float[] { corn[0]*D, corn[1]*D, corn[2]*D }; - } - else - { - float E = D/(0.5f*(numLayers-1)); // ?? maybe 0.5* - int N = (numCubitsPerCorner-1)/3; - int block = (part-1) % N; - int index = (part-1) / N; - Static4D pri = mCurrCornerV[index]; - Static4D sec = mCurrCornerV[(index+2)%3]; - - int layers= (numLayers-5)/2; - int multP = (block % layers) + 1; - int multS = (block / layers); - - return new float[] { - corn[0]*D + (pri.get0()*multP + sec.get0()*multS)*E, - corn[1]*D + (pri.get1()*multP + sec.get1()*multS)*E, - corn[2]*D + (pri.get2()*multP + sec.get2()*multS)*E - }; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeCenter(int numLayers, int center, int part) - { - if( mCenterCoords==null ) initializeCenterCoords(); - if( mCorners ==null ) initializeCorners(); - if( mCenterMap ==null ) initializeCenterMap(); - - int corner = mCenterMap[center][part]; - float[] cent = mCenterCoords[center]; - float[] corn = mCorners[corner]; - float D = numLayers/3.0f; - float F = 1.0f - (2.0f*numLayers-6.0f)/(numLayers-1)*COS54*COS54; - - return new float[] - { - D * ( cent[0] + (corn[0]-cent[0])*F), - D * ( cent[1] + (corn[1]-cent[1])*F), - D * ( cent[2] + (corn[2]-cent[2])*F) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int computeEdgeType(int cubit, int numCubitsPerCorner, int numCubitsPerEdge) - { - int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge; - return part - 2*(part/4); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeEdge(int numLayers, int edge, int part) - { - if( mCenterCoords==null ) initializeCenterCoords(); - if( mCorners==null ) initializeCorners(); - if( mEdgeMap==null ) initializeEdgeMap(); - - float D = numLayers/3.0f; - float[] c1 = mCorners[ mEdgeMap[edge][0] ]; - float[] c2 = mCorners[ mEdgeMap[edge][1] ]; - - int leftRight = 2*(part%2) -1; - part /= 2; - - if( part==0 ) - { - float T = 0.5f + leftRight/(numLayers-1.0f); - float x = D * (T*c1[0]+(1.0f-T)*c2[0]); - float y = D * (T*c1[1]+(1.0f-T)*c2[1]); - float z = D * (T*c1[2]+(1.0f-T)*c2[2]); - - return new float[] { x, y, z }; - } - else - { - int mult = (part+1)/2; - int dir = (part+1)%2; - float[] center = mCenterCoords[ mEdgeMap[edge][dir+2] ]; - float x = 0.5f * D * (c1[0]+c2[0]); - float y = 0.5f * D * (c1[1]+c2[1]); - float z = 0.5f * D * (c1[2]+c2[2]); - - float vX = D*center[0] - x; - float vY = D*center[1] - y; - float vZ = D*center[2] - z; - - float T = 0.5f + leftRight*(mult*SIN18 + 1.0f)/(numLayers-1); - - x = D * (T*c1[0]+(1.0f-T)*c2[0]); - y = D * (T*c1[1]+(1.0f-T)*c2[1]); - z = D * (T*c1[2]+(1.0f-T)*c2[2]); - - float H = mult*D*COS18/(numLayers-1); - H /= (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ); - - return new float[] { x + H*vX, y + H*vY, z + H*vZ }; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCubitPositions(int numLayers) - { - if( mCorners==null ) initializeCorners(); - if( numLayers<5 ) return mCorners; - - int numCubitsPerCorner = numCubitsPerCorner(numLayers); - int numCubitsPerEdge = numCubitsPerEdge(numLayers); - int numCubitsPerCenter = 5; - int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS*numCubitsPerCenter; - int index=0; - - final float[][] CENTERS = new float[numCubits][]; - - for(int corner=0; corner2 ) return NUM_TEXTURES; - - int part = cubit % numCubitsPerCorner; - int corner= cubit / numCubitsPerCorner; - - if( part==0 ) - { - return mCornerFaceMap[corner][cubitface]; - } - else - { - int N = (numCubitsPerCorner-1)/3; - int block = (part-1) % N; - int index = (part-1) / N; - - if( block< (numLayers-3)/2 ) - { - switch(index) - { - case 0: return cubitface==1 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - case 1: return cubitface==0 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - case 2: return cubitface==2 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - } - } - else - { - switch(index) - { - case 0: return cubitface==0 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - case 1: return cubitface==2 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - case 2: return cubitface==1 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - } - } - } - - return NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getEdgeColor(int edge, int cubitface, int numCubitsPerEdge) - { - if( cubitface<0 || cubitface>1 ) return NUM_TEXTURES; - - int part = edge % numCubitsPerEdge; - int variant = edge / numCubitsPerEdge; - if( mEdgeMap==null ) initializeEdgeMap(); - - part /=2; - - return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACE_COLORS : NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getCenterColor(int center, int cubitface, int numLayers) - { - if( mCenterFaceMap==null ) initializeCenterFaceMap(); - if( mCornerFaceMap==null ) initializeCornerFaceMap(); - - if( numLayers==3 ) - { - return cubitface>=0 && cubitface<3 ? mCornerFaceMap[center][cubitface] : NUM_TEXTURES; - } - - return cubitface==mCenterFaceMap[center] ? center/5 + NUM_FACE_COLORS*(numLayers-1)/2 : NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getFaceColor(int cubit, int cubitface, int numLayers) - { - int numCubitsPerCorner = numCubitsPerCorner(numLayers); - int numCubitsPerEdge = numCubitsPerEdge(numLayers); - - if( cubit < NUM_CORNERS*numCubitsPerCorner ) - { - return getCornerColor(cubit,cubitface,numLayers,numCubitsPerCorner); - } - else if( cubit. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement12.COS54; -import static org.distorted.objectlib.Movement12.SIN54; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.QuatHelper; -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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyMegaminx extends TwistyMinx -{ - static final float MEGA_D = 0.04f; - private int[] mQuatCenterIndices; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyMegaminx(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.MEGA, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeCenterIndices() - { - mQuatCenterIndices = new int[] { 16, 18, 22, 1, 20, 13, 14, 15, 0, 12, 2, 3 }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int numCubitsPerCorner(int numLayers) - { - return 3*((numLayers-1)/2)*((numLayers-3)/2) + 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int numCubitsPerEdge(int numLayers) - { - return numLayers-2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return (numLayers+3)/2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - return genericGetCuts(numLayers,0.5f-MEGA_D); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeCenter(int center, int numLayers) - { - if( mCenterCoords==null ) initializeCenterCoords(); - float[] coords = mCenterCoords[center]; - float A = 0.33f*numLayers; - - return new float[] { A*coords[0], A*coords[1], A*coords[2] }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Fill out mCurrCorner{X,Y,Z} by applying appropriate Quat to mBasicCorner{X,Y,Z} -// Appropriate one: QUATS[QUAT_INDICES[corner]]. - - private void computeBasicCornerVectors(int corner) - { - if( mQuatCornerIndices==null ) initializeQuatIndices(); - if( mQuats==null ) initializeQuats(); - if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV(); - - Static4D quat = mQuats[mQuatCornerIndices[corner]]; - - mCurrCornerV[0] = QuatHelper.rotateVectorByQuat(mBasicCornerV[0],quat); - mCurrCornerV[1] = QuatHelper.rotateVectorByQuat(mBasicCornerV[1],quat); - mCurrCornerV[2] = QuatHelper.rotateVectorByQuat(mBasicCornerV[2],quat); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeCorner(int numCubitsPerCorner, int numLayers, int corner, int part) - { - if( mCorners==null ) initializeCorners(); - if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV(); - - float D = numLayers/3.0f; - float[] corn = mCorners[corner]; - - if( part==0 ) - { - return new float[] { corn[0]*D, corn[1]*D, corn[2]*D }; - } - else - { - float E = 2.0f*D*(0.5f-MEGA_D)/(0.5f*(numLayers-1)); - int N = (numCubitsPerCorner-1)/3; - int block = (part-1) % N; - int index = (part-1) / N; - Static4D pri = mCurrCornerV[index]; - Static4D sec = mCurrCornerV[(index+2)%3]; - - int layers= (numLayers-3)/2; - int multP = (block % layers) + 1; - int multS = (block / layers); - - return new float[] { - corn[0]*D + (pri.get0()*multP + sec.get0()*multS)*E, - corn[1]*D + (pri.get1()*multP + sec.get1()*multS)*E, - corn[2]*D + (pri.get2()*multP + sec.get2()*multS)*E - }; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int computeEdgeType(int cubit, int numCubitsPerCorner, int numCubitsPerEdge) - { - int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge; - return (part+1)/2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float[] computeEdge(int numLayers, int edge, int part) - { - if( mCenterCoords==null ) initializeCenterCoords(); - if( mCorners==null ) initializeCorners(); - if( mEdgeMap==null ) initializeEdgeMap(); - - float D = numLayers/3.0f; - float[] c1 = mCorners[ mEdgeMap[edge][0] ]; - float[] c2 = mCorners[ mEdgeMap[edge][1] ]; - float x = D * (c1[0]+c2[0]) / 2; - float y = D * (c1[1]+c2[1]) / 2; - float z = D * (c1[2]+c2[2]) / 2; - - if( part==0 ) - { - return new float[] { x, y, z }; - } - else - { - int mult = (part+1)/2; - int dir = (part+1)%2; - float[] center = mCenterCoords[ mEdgeMap[edge][dir+2] ]; - - float vX = D*center[0] - x; - float vY = D*center[1] - y; - float vZ = D*center[2] - z; - - float A = 3*mult*D*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f); - A /= (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ); - - return new float[] { x+A*vX, y+A*vY, z+A*vZ }; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCubitPositions(int numLayers) - { - int numCubitsPerCorner = numCubitsPerCorner(numLayers); - int numCubitsPerEdge = numCubitsPerEdge(numLayers); - int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS; - int index=0; - - final float[][] CENTERS = new float[numCubits][]; - - for(int corner=0; corner2 ) return NUM_TEXTURES; - - int part = cubit % numCubitsPerCorner; - int corner= cubit / numCubitsPerCorner; - - if( part==0 ) - { - return mCornerFaceMap[corner][cubitface]; - } - else - { - int N = (numCubitsPerCorner-1)/3; - int block = (part-1) % N; - int index = (part-1) / N; - - if( block< (numLayers-3)/2 ) - { - switch(index) - { - case 0: return cubitface==1 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - case 1: return cubitface==0 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - case 2: return cubitface==2 ? NUM_TEXTURES : mCornerFaceMap[corner][cubitface]; - } - } - else - { - switch(index) - { - case 0: return cubitface==0 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - case 1: return cubitface==2 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - case 2: return cubitface==1 ? mCornerFaceMap[corner][cubitface] : NUM_TEXTURES; - } - } - } - - return NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getEdgeColor(int edge, int cubitface, int numCubitsPerEdge) - { - if( cubitface<0 || cubitface>1 ) return NUM_TEXTURES; - - int part = edge % numCubitsPerEdge; - int variant = edge / numCubitsPerEdge; - if( mEdgeMap==null ) initializeEdgeMap(); - - return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACE_COLORS : NUM_TEXTURES; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getCenterColor(int center, int cubitface, int numLayers) - { - return cubitface>0 ? NUM_TEXTURES : center + NUM_FACE_COLORS*(numLayers+1)/2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getFaceColor(int cubit, int cubitface, int numLayers) - { - int numCubitsPerCorner = numCubitsPerCorner(numLayers); - int numCubitsPerEdge = numCubitsPerEdge(numLayers); - - if( cubit < NUM_CORNERS*numCubitsPerCorner ) - { - return getCornerColor(cubit,cubitface,numLayers,numCubitsPerCorner); - } - else if( cubit. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_SPLIT_EDGE; -import static org.distorted.objectlib.Movement12.C2; -import static org.distorted.objectlib.Movement12.LEN; -import static org.distorted.objectlib.Movement12.SIN54; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement12; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty12; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class TwistyMinx extends Twisty12 -{ - static final int NUM_CORNERS = 20; - static final int NUM_CENTERS = 12; - static final int NUM_EDGES = 30; - - static final float SIN18 = (SQ5-1)/4; - static final float COS18 = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5)); - static final float COS_HALFD= (float)(Math.sqrt(0.5f-0.1f*SQ5)); // cos(half the dihedral angle) - static final float SIN_HALFD= (float)(Math.sqrt(0.5f+0.1f*SQ5)); // sin(half the dihedral angle) - - // the six rotation axis of a Minx. Must be normalized. - static final Static3D[] ROT_AXIS = new Static3D[] - { - 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( SIN54/LEN, 0 , C2/LEN ), - new Static3D( SIN54/LEN, 0 , -C2/LEN ) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{2,3},{3,5},{1,5},{1,4},{2,4}}, - {{0,5},{2,5},{2,3},{3,4},{0,4}}, - {{2,3},{2,5},{0,5},{0,4},{3,4}}, - {{1,5},{3,5},{2,3},{2,4},{1,4}}, - {{0,3},{0,4},{4,5},{1,5},{1,3}}, - {{1,2},{1,4},{4,5},{0,5},{0,2}}, - {{4,5},{1,4},{1,2},{0,2},{0,5}}, - {{4,5},{0,4},{0,3},{1,3},{1,5}}, - {{0,2},{0,1},{1,3},{3,5},{2,5}}, - {{3,4},{2,4},{1,2},{0,1},{0,3}}, - {{2,4},{3,4},{0,3},{0,1},{1,2}}, - {{1,3},{0,1},{0,2},{2,5},{3,5}}, - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private int[] mFaceMap; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private Movement mMovement; - Static4D[] mQuats; - float[][] mCenterCoords; - float[][] mCorners; - int[][] mCornerFaceMap; - int[] mQuatEdgeIndices; - int[] mQuatCornerIndices; - int[][] mEdgeMap; - int[][] mCenterMap; - Static4D[] mBasicCornerV, mCurrCornerV; - ObjectSticker[] mStickers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistyMinx(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth) - { - super(numLayers, realSize, quat, texture, mesh, effects, moves, obj, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int numLayers = getNumLayers(); - initializeScrambleStates(numLayers); - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeCornerV() - { - mBasicCornerV = new Static4D[3]; - mCurrCornerV = new Static4D[3]; - - mBasicCornerV[0] = new Static4D( (SQ5+1)*0.375f, (SQ5-1)*0.375f, -0.750f, 0.0f ); - mBasicCornerV[1] = new Static4D(-(SQ5+1)*0.375f, (SQ5-1)*0.375f, -0.750f, 0.0f ); - mBasicCornerV[2] = new Static4D( 0, -1.500f, 0.0f, 0.0f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// the five vertices that form a given face. Order: the same as colors of the faces in TwistyMinx. - - void initializeCenterMap() - { - mCenterMap = new int[][] - { - { 0, 12, 4, 14, 2}, - { 0, 2, 18, 6, 16}, - { 6, 18, 11, 19, 7}, - { 3, 15, 9, 11, 19}, - { 4, 5, 15, 9, 14}, - { 1, 13, 5, 15, 3}, - { 1, 3, 19, 7, 17}, - {10, 16, 6, 7, 17}, - { 0, 12, 8, 10, 16}, - { 8, 13, 5, 4, 12}, - { 1, 13, 8, 10, 17}, - { 2, 14, 9, 11, 18}, - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// the quadruple ( corner1, corner2, face1, face2 ) defining an edge. -// In fact the 2 corners already define it, the faces only provide easy -// way to get to know the colors. Order: arbitrary. Face1 arbitrarily on -// the 'left' or right of vector corner1 --> corner2, according to Quat. - - void initializeEdgeMap() - { - mEdgeMap = new int[][] - { - { 0, 12, 0, 8}, //0 - { 12, 4, 0, 9}, - { 4, 14, 0, 4}, - { 14, 2, 0, 11}, - { 2, 0, 0, 1}, - { 14, 9, 11, 4}, //5 - { 9, 11, 11, 3}, - { 11, 18, 11, 2}, - { 18, 2, 11, 1}, - { 18, 6, 1, 2}, - { 6, 16, 1, 7}, //10 - { 16, 0, 1, 8}, - { 16, 10, 8, 7}, - { 10, 8, 8, 10}, - { 8, 12, 8, 9}, - { 8, 13, 9, 10}, //15 - { 13, 5, 9, 5}, - { 5, 4, 9, 4}, - { 5, 15, 4, 5}, - { 15, 9, 4, 3}, - { 11, 19, 2, 3}, //20 - { 19, 7, 2, 6}, - { 7, 6, 2, 7}, - { 7, 17, 7, 6}, - { 17, 10, 7, 10}, - { 17, 1, 10, 6}, //25 - { 1, 3, 5, 6}, - { 3, 19, 3, 6}, - { 1, 13, 10, 5}, - { 3, 15, 5, 3}, - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeQuatIndices() - { - mQuatEdgeIndices = new int[] - { - 56, 40, 43, 59, 0, 19, 9, 54, 58, 49, - 48, 24, 52, 4, 16, 32, 20, 11, 21, 35, - 37, 30, 8, 28, 36, 44, 1, 46, 12, 47 - }; - mQuatCornerIndices = new int[] - { - 0, 2, 3, 1, 40, 31, 41, 30, 39, 35, - 36, 34, 56, 32, 43, 21, 48, 28, 42, 23 - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeCornerFaceMap() - { - mCornerFaceMap = new int[][] - { - { 0, 1, 8 }, - { 6, 5,10 }, - { 1, 0,11 }, - { 5, 6, 3 }, - { 0, 9, 4 }, - { 5, 4, 9 }, - { 7, 1, 2 }, - { 2, 6, 7 }, - { 10, 9, 8 }, - { 4, 3,11 }, - { 7,10, 8 }, - { 3, 2,11 }, - { 0, 8, 9 }, - { 9,10, 5 }, - { 0, 4,11 }, - { 4, 5, 3 }, - { 1, 7, 8 }, - { 7, 6,10 }, - { 2, 1,11 }, - { 6, 2, 3 }, - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), //0 - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), //4 - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( -0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( -0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( -0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( -0.5f, -0.5f, -0.5f, 0.5f ), - - new Static4D( 0.5f, SIN54, SIN18, 0.0f ), // 12 - new Static4D( 0.5f, SIN54,-SIN18, 0.0f ), - new Static4D( 0.5f,-SIN54, SIN18, 0.0f ), - new Static4D( 0.5f,-SIN54,-SIN18, 0.0f ), - new Static4D( SIN18, 0.5f, SIN54, 0.0f ), - new Static4D( SIN18, 0.5f,-SIN54, 0.0f ), - new Static4D(-SIN18, 0.5f, SIN54, 0.0f ), - new Static4D(-SIN18, 0.5f,-SIN54, 0.0f ), - new Static4D( SIN54, SIN18, 0.5f, 0.0f ), - new Static4D( SIN54,-SIN18, 0.5f, 0.0f ), - new Static4D(-SIN54, SIN18, 0.5f, 0.0f ), - new Static4D(-SIN54,-SIN18, 0.5f, 0.0f ), - - new Static4D( 0.0f, SIN18, SIN54, 0.5f ), //24 - new Static4D( 0.0f, SIN18,-SIN54, 0.5f ), - new Static4D( 0.0f,-SIN18, SIN54, 0.5f ), - new Static4D( 0.0f,-SIN18,-SIN54, 0.5f ), - new Static4D( SIN18, SIN54, 0.0f, 0.5f ), - new Static4D( SIN18,-SIN54, 0.0f, 0.5f ), - new Static4D(-SIN18, SIN54, 0.0f, 0.5f ), - new Static4D(-SIN18,-SIN54, 0.0f, 0.5f ), - new Static4D( SIN54, 0.0f, SIN18, 0.5f ), - new Static4D( SIN54, 0.0f,-SIN18, 0.5f ), - new Static4D(-SIN54, 0.0f, SIN18, 0.5f ), - new Static4D(-SIN54, 0.0f,-SIN18, 0.5f ), - - new Static4D( 0.0f, SIN54, 0.5f, SIN18 ), //36 - new Static4D( 0.0f, SIN54, -0.5f, SIN18 ), - new Static4D( 0.0f,-SIN54, 0.5f, SIN18 ), - new Static4D( 0.0f,-SIN54, -0.5f, SIN18 ), - new Static4D( 0.5f, 0.0f, SIN54, SIN18 ), - new Static4D( 0.5f, 0.0f,-SIN54, SIN18 ), - new Static4D( -0.5f, 0.0f, SIN54, SIN18 ), - new Static4D( -0.5f, 0.0f,-SIN54, SIN18 ), - new Static4D( SIN54, 0.5f, 0.0f, SIN18 ), - new Static4D( SIN54, -0.5f, 0.0f, SIN18 ), - new Static4D(-SIN54, 0.5f, 0.0f, SIN18 ), - new Static4D(-SIN54, -0.5f, 0.0f, SIN18 ), - - new Static4D( 0.0f, 0.5f, SIN18, SIN54 ), //48 - new Static4D( 0.0f, 0.5f,-SIN18, SIN54 ), - new Static4D( 0.0f, -0.5f, SIN18, SIN54 ), - new Static4D( 0.0f, -0.5f,-SIN18, SIN54 ), - new Static4D( 0.5f, SIN18, 0.0f, SIN54 ), - new Static4D( 0.5f,-SIN18, 0.0f, SIN54 ), - new Static4D( -0.5f, SIN18, 0.0f, SIN54 ), - new Static4D( -0.5f,-SIN18, 0.0f, SIN54 ), - new Static4D( SIN18, 0.0f, 0.5f, SIN54 ), - new Static4D( SIN18, 0.0f, -0.5f, SIN54 ), - new Static4D(-SIN18, 0.0f, 0.5f, SIN54 ), - new Static4D(-SIN18, 0.0f, -0.5f, SIN54 ), - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Coordinates of all 20 corners of a Minx - - void initializeCorners() - { - float cA = 1.5f; - float cB = 3*C2; - float cC = 3*SIN54; - - mCorners = new float[][] - { - { 0, cA, cB}, - { 0, cA,-cB}, - { 0,-cA, cB}, - { 0,-cA,-cB}, - { cB, 0, cA}, - { cB, 0,-cA}, - {-cB, 0, cA}, - {-cB, 0,-cA}, - { cA, cB, 0}, - { cA,-cB, 0}, - {-cA, cB, 0}, - {-cA,-cB, 0}, - { cC, cC, cC}, - { cC, cC,-cC}, - { cC,-cC, cC}, - { cC,-cC,-cC}, - {-cC, cC, cC}, - {-cC, cC,-cC}, - {-cC,-cC, cC}, - {-cC,-cC,-cC}, - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeCenterCoords() - { - if( mCorners==null ) initializeCorners(); - if( mCenterMap==null ) initializeCenterMap(); - - mCenterCoords = new float[NUM_CENTERS][3]; - - for(int center=0; center. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyMirror extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(1,0,0), - new Static3D(0,1,0), - new Static3D(0,0,1) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}}, - }; - - private static final int[] FACE_COLORS = new int[] { COLOR_WHITE }; - private static final float DX = 0.10f; - private static final float DY = 0.25f; - private static final float DZ = 0.40f; - - private ScrambleState[] mStates; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[] mBasicAngle; - private ObjectSticker[] mStickers; - private float[][] mPositions; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyMirror(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.MIRR, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int size = getNumLayers(); - int[][] m = new int[16][]; - for(int i=1; i<16; i++) m[i] = createEdges(size,i); - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ), // 0 - new ScrambleState( new int[][] { null, m[ 4], m[ 5] } ), // x - new ScrambleState( new int[][] { m[ 6], null, m[ 7] } ), // y - new ScrambleState( new int[][] { m[ 8], m[ 8], null } ), // z - new ScrambleState( new int[][] { m[10], null, m[ 7] } ), // xy - new ScrambleState( new int[][] { m[11], m[ 9], null } ), // xz - new ScrambleState( new int[][] { null, m[12], m[ 5] } ), // yx - new ScrambleState( new int[][] { m[ 8], m[13], null } ), // yz - new ScrambleState( new int[][] { null, m[ 4], m[14] } ), // zx - new ScrambleState( new int[][] { m[ 6], null, m[15] } ), // zy - new ScrambleState( new int[][] { null, null, m[ 5] } ), // xyx - new ScrambleState( new int[][] { null, m[ 4], null } ), // xzx - new ScrambleState( new int[][] { null, null, m[ 7] } ), // yxy - new ScrambleState( new int[][] { m[ 6], null, null } ), // yzy - new ScrambleState( new int[][] { null, m[ 9], null } ), // zxz - new ScrambleState( new int[][] { m[ 8], null, null } ), // zyz - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int[] createEdges(int size, int vertex) - { - int[] ret = new int[9*size]; - - for(int l=0; l1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1; - mPositions = new float[numCubits][]; - - float diff = 0.5f*(numLayers-1); - int currentPosition = 0; - - for(int x = 0; x. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement4; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty4; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyPyraminx extends Twisty4 -{ - static final Static3D[] ROT_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), - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}} - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyPyraminx(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.PYRA, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int numLayers = getNumLayers(); - initializeScrambleStates(numLayers); - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f), - new Static4D( SQ2/2, 0.5f, 0.0f, 0.5f), - new Static4D(-SQ2/2, 0.5f, 0.0f, 0.5f), - new Static4D( 0.0f, -0.5f, -SQ2/2, 0.5f), - new Static4D( 0.0f, -0.5f, SQ2/2, 0.5f), - new Static4D( SQ2/2, 0.5f, 0.0f, -0.5f), - new Static4D(-SQ2/2, 0.5f, 0.0f, -0.5f), - new Static4D( 0.0f, -0.5f, -SQ2/2, -0.5f), - new Static4D( 0.0f, -0.5f, SQ2/2, -0.5f), - new Static4D( SQ2/2, 0.0f, SQ2/2, 0.0f), - new Static4D(-SQ2/2, 0.0f, SQ2/2, 0.0f) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int[][] generateState(int start, int end) - { - int len = end-start+1; - int[] tmp = new int[6*len]; - - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_SPLIT_CORNER; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyRedi extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0,1},{3,1},{2,3},{0,2}}, - {{2,3},{3,1},{0,1},{0,2}}, - {{1,2},{0,1},{0,3},{2,3}}, - {{1,2},{2,3},{0,3},{0,1}}, - {{0,3},{0,2},{1,2},{1,3}}, - {{1,2},{0,2},{0,3},{1,3}}, - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private float[][] mCenters; - private int[][] mFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyRedi(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.REDI, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { {0,1,1,0,-1,1, 2,1,2,2,-1,2},{0,1,3,0,-1,3, 2,1,4,2,-1,4},{0,1,5,0,-1,5, 2,1,6,2,-1,6},{0,1,7,0,-1,7, 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ },{ 2,1,6,2,-1,6},{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{ },{0,1,5,0,-1,5, },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ },{0,1,7,0,-1,7 } } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{ },{ 2,1,8,2,-1,8} } ), - new ScrambleState( new int[][] { { 2,1,2,2,-1,2},{0,1,3,0,-1,3 },{0,1,5,0,-1,5, },{ } } ), - new ScrambleState( new int[][] { {0,1,1,0,-1,1 },{ 2,1,4,2,-1,4},{ 2,1,6,2,-1,6},{ } } ), - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return 2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int size) - { - if( mCuts==null ) - { - float C = +SQ3/3 +0.05f; - float[] cut = new float[] {-C,+C}; - mCuts = new float[][] { cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[] {true,false,true}; - mLayerRotatable = new boolean[numAxis][]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_SPLIT_CORNER; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyRex extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0,1},{3,1},{2,3},{0,2}}, - {{2,3},{3,1},{0,1},{0,2}}, - {{1,2},{0,1},{0,3},{2,3}}, - {{1,2},{2,3},{0,3},{0,1}}, - {{0,3},{0,2},{1,2},{1,3}}, - {{1,2},{0,2},{0,3},{1,3}}, - }; - - public static final float REX_D = 0.2f; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[][] mFaceMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyRex(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.REX, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] tmp = {0,-1,0, 0,1,0, 2,-1,0, 2,1,0 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - if( mCuts==null ) - { - float C = SQ3*0.45f; // bit less than 1/2 of the length of the main diagonal - float[] cut = new float[] {-C,+C}; - mCuts = new float[][] { cut,cut,cut,cut }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = new boolean[] {true,false,true}; - mLayerRotatable = new boolean[numAxis][]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_SPLIT_CORNER; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistySkewb extends Twisty6 -{ - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), - new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0,1},{3,1},{2,3},{0,2}}, - {{2,3},{3,1},{0,1},{0,2}}, - {{1,2},{0,1},{0,3},{2,3}}, - {{1,2},{2,3},{0,3},{0,1}}, - {{0,3},{0,2},{1,2},{1,3}}, - {{1,2},{0,2},{0,3},{1,3}}, - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[][] mCornerMap,mEdgeMap,mCenterMap; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistySkewb(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) - { - super(size, 2*size-2, quat, texture, mesh, effects, moves, ObjectList.SKEW, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int size = getNumLayers(); - int[] tmp = {0,-1,0, 0,1,0, size-1,-1,0, size-1,1,0 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - - new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), - new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int getNumCorners() - { - return 8; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int getNumEdges(int layers) - { - return (layers-2)*12; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int getNumCentersPerFace(int layers) - { - return ((layers-2)*(layers-2) + (layers-1)*(layers-1)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getSolvedFunctionIndex() - { - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumStickerTypes(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - if( mCuts==null ) - { - float[] c = numLayers==2 ? (new float[] {0.0f}) : (new float[] {-SQ3/6,+SQ3/6}); - mCuts = new float[][] {c,c,c,c}; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - int numAxis = ROT_AXIS.length; - boolean[] tmp = numLayers==2 ? (new boolean[] {true,true}) : (new boolean[] {true,false,true}); - mLayerRotatable = new boolean[numAxis][]; - for(int i=0; i. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -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.Static3D; -import org.distorted.library.type.Static4D; -import org.distorted.objectlib.Movement; -import org.distorted.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty6; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -abstract class TwistySquare extends Twisty6 -{ - static final float COS15 = (SQ6+SQ2)/4; - static final float SIN15 = (SQ6-SQ2)/4; - static final float X = 3*(2-SQ3)/2; - - // The third, artificial axis is for the generic scrambling algorithm. - // Otherwise it wouldn't be possible to rotate the LO and UP layers - // consecutively. - - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D(0,+1,0), - new Static3D(COS15,0,SIN15), - new Static3D(0,-1,0), - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{0}},{{0}},{{1}},{{1}},{{0,1}},{{0,1}} - }; - - private int[] mBasicAngle; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private Movement mMovement; - Static4D[] mQuats; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - TwistySquare(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth) - { - super(size, size, quat, texture, mesh, effects, moves, obj, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D( 0.0f, SIN15, 0.0f, COS15 ), - new Static4D( 0.0f, 0.5f, 0.0f, SQ3/2 ), - new Static4D( 0.0f, SQ2/2, 0.0f, SQ2/2 ), - new Static4D( 0.0f, SQ3/2, 0.0f, 0.5f ), - new Static4D( 0.0f, COS15, 0.0f, SIN15 ), - new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), - new Static4D( 0.0f, COS15, 0.0f,-SIN15 ), - new Static4D( 0.0f, SQ3/2, 0.0f, -0.5f ), - new Static4D( 0.0f, SQ2/2, 0.0f,-SQ2/2 ), - new Static4D( 0.0f, 0.5f, 0.0f,-SQ3/2 ), - new Static4D( 0.0f, SIN15, 0.0f,-COS15 ), - - new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), - new Static4D( COS15, 0.0f, SIN15, 0.0f ), - new Static4D( SQ3/2, 0.0f, 0.5f, 0.0f ), - new Static4D( SQ2/2, 0.0f, SQ2/2, 0.0f ), - new Static4D( 0.5f, 0.0f, SQ3/2, 0.0f ), - new Static4D( SIN15, 0.0f, COS15, 0.0f ), - new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), - new Static4D(-SIN15, 0.0f, COS15, 0.0f ), - new Static4D( -0.5f, 0.0f, SQ3/2, 0.0f ), - new Static4D(-SQ2/2, 0.0f, SQ2/2, 0.0f ), - new Static4D(-SQ3/2, 0.0f, 0.5f, 0.0f ), - new Static4D(-COS15, 0.0f, SIN15, 0.0f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initializeBasicAngle() - { - mBasicAngle = new int[] {12,2,12}; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D[] getQuats() - { - if( mQuats==null ) initializeQuats(); - return mQuats; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumCubitFaces() - { - return 6; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCuts(int numLayers) - { - if( mCuts==null ) - { - mCuts = new float[][] { {-0.5f,+0.5f}, {0.0f}, {-0.5f,+0.5f} }; - } - - return mCuts; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void getLayerRotatable(int numLayers) - { - if( mLayerRotatable==null ) - { - mLayerRotatable = new boolean[][] { {true,false,true}, {true,true}, {true,false,true} }; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public Static3D[] getRotationAxis() - { - return ROT_AXIS; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public Movement getMovement() - { - if( mMovement==null ) - { - int numLayers = getNumLayers(); - if( mCuts==null ) getCuts(numLayers); - getLayerRotatable(numLayers); - mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers,TYPE_NOT_SPLIT,ENABLED); - } - return mMovement; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int[] getBasicAngle() - { - if( mBasicAngle ==null ) initializeBasicAngle(); - return mBasicAngle; - } -} diff --git a/src/main/java/org/distorted/objects/TwistySquare1.java b/src/main/java/org/distorted/objects/TwistySquare1.java deleted file mode 100644 index 3fae438e..00000000 --- a/src/main/java/org/distorted/objects/TwistySquare1.java +++ /dev/null @@ -1,363 +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 android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement6; -import org.distorted.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistySquare1 extends TwistySquare -{ - private static final int NUM_STICKERS = 6; - - private ObjectSticker[] mStickers; - private int[] mQuatNumber; - private float[][] mCenters; - private int[][] mStickerColor; - private int[][] mStickerType; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistySquare1(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) - { - super(size, quat, texture, mesh, effects, moves, ObjectList.SQU1, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - return null; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getScrambleType() - { - return 1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement6.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectShape getObjectShape(int cubit, int numLayers) - { - int variant = getCubitVariant(cubit,numLayers); - - if( variant==0 ) - { - double[][] vertices = new double[][] - { - { -1.5-X, 0.5, 1.5 }, - { 0.0, 0.5, 1.5 }, - { 0.0, 0.5,-1.5 }, - { -1.5+X, 0.5,-1.5 }, - { -1.5-X,-0.5, 1.5 }, - { 0.0,-0.5, 1.5 }, - { 0.0,-0.5,-1.5 }, - { -1.5+X,-0.5,-1.5 } - }; - - int[][] vert_indices = new int[][] - { - {0,1,2,3}, - {4,5,6,7}, - {4,5,1,0}, - {5,6,2,1}, - {6,7,3,2}, - {7,4,0,3} - }; - - float[][] bands = new float[][] { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} }; - int[] bandIndices = new int[] { 2,2,1,1,0,2 }; - float[][] corners = new float[][] { {0.03f,0.05f} }; - int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - float[][] centers = new float[][] { { -0.75f, 0.0f, 0.0f} }; - int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else if( variant==1 ) - { - double[][] vertices = new double[][] - { - { -X, 0.5, 0.0 }, - { +X, 0.5, 0.0 }, - {0.0, 0.5,-1.5 }, - { -X,-0.5, 0.0 }, - { +X,-0.5, 0.0 }, - {0.0,-0.5,-1.5 }, - }; - - int[][] vert_indices = new int[][] - { - {0,1,2}, - {3,4,5}, - {3,4,1,0}, - {4,5,2,1}, - {5,3,0,2} - }; - - float[][] bands = new float[][] { {0.038f,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} }; - int[] bandIndices = new int[] { 0,1,0,1,1 }; - float[][] corners = new float[][] { {0.04f,0.15f} }; - int[] cornerIndices = new int[] { 0,0,-1,0,0,-1 }; - float[][] centers = new float[][] { { 0.0f, 0.0f,-0.5f} }; - int[] centerIndices = new int[] { 0,0,-1,0,0,-1 }; - - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else - { - double[][] vertices = new double[][] - { - { X-1.5, 0.5, 0.0 }, - { 0.0, 0.5, 0.0 }, - { 0.0, 0.5,X-1.5 }, - { -1.5, 0.5, -1.5 }, - { X-1.5,-0.5, 0.0 }, - { 0.0,-0.5, 0.0 }, - { 0.0,-0.5,X-1.5 }, - { -1.5,-0.5, -1.5 } - }; - int[][] vert_indices = new int[][] - { - {0,1,2,3}, - {4,5,6,7}, - {4,5,1,0}, - {5,6,2,1}, - {7,4,0,3}, - {6,7,3,2} - }; - - float[][] bands = new float[][] { {0.038f,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} }; - int[] bandIndices = new int[] { 0,1,0,0,1,1 }; - float[][] corners = new float[][] { {0.05f,0.13f} }; - int[] cornerIndices = new int[] { 0,0,0,-1,0,0,0,-1 }; - float[][] centers = new float[][] { { -0.5f, 0.0f,-0.5f} }; - int[] centerIndices = new int[] { -1,0,-1,-1,-1,0,-1,-1 }; - - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D getQuat(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - if( mQuatNumber ==null ) - { - mQuatNumber = new int[] - { - 0, 6, - 0, 9, 6, 3, 18, 15, 12, 21, - 0, 9, 6, 3, 15, 12, 21, 18 - }; - } - - return mQuats[mQuatNumber[cubit]]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumCubitVariants(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getCubitVariant(int cubit, int numLayers) - { - return cubit<2 ? 0 : (cubit<10 ? 1:2); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectSticker retSticker(int face) - { - if( mStickers==null ) - { - float[][] STICKERS = new float[][] - { - { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front - { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right - { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back - { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f }, // edge top - { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face - { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top - }; - - final float R1 = 0.06f; - final float R2 = 0.04f; - final float R3 = 0.11f; - final float R4 = 0.03f; - final float R5 = 0.11f; - final float R6 = 0.08f; - final float[][] radii = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6,R6} }; - final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.08f }; - - mStickers = new ObjectSticker[NUM_STICKERS]; - - for(int s=0; s. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.ObjectList; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistySquare2 extends TwistySquare -{ - private static final int NUM_STICKERS = 6; - - private ScrambleState[] mStates; - private int[] mQuatNumber; - private float[][] mCenters; - private int[][] mStickerColor; - private int[][] mStickerType; - private ObjectSticker[] mStickers; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistySquare2(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, - DistortedEffects effects, int[][] moves, Resources res, int scrWidth) - { - super(size, quat, texture, mesh, effects, moves, ObjectList.SQU2, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] SL_6 = new int[] { 0,1,1, 1,1,1, 0,1,1, 1,1,1, 0,1,1, 1,1,1, 0,1,1, 1,1,1, 0,1,1, 1,1,1, 0,1,1, 1,1,1}; - int[] SL_1 = new int[] { 0,1,1, 1,1,1 }; - int[] LO_2 = new int[] { 0,-5,2, 0,-4,2, 0,-3,2, 0,-2,2, 0,-1,2, 0,1,2, 0,2,2, 0,3,2, 0,4,2, 0,5,2, 0,5,2 }; - int[] LO_3 = new int[] { 0,-5,3, 0,-4,3, 0,-3,3, 0,-2,3, 0,-1,3, 0,1,3, 0,2,3, 0,3,3, 0,4,3, 0,5,3, 0,5,3 }; - int[] LO_4 = new int[] { 0,-5,4, 0,-4,4, 0,-3,4, 0,-2,4, 0,-1,4, 0,1,4, 0,2,4, 0,3,4, 0,4,4, 0,5,4, 0,5,4 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] { LO_2, SL_6, LO_3 } ), // 0 - new ScrambleState( new int[][] { LO_2, null, LO_3 } ), // SL - new ScrambleState( new int[][] { null, SL_1, LO_4 } ), // LO - new ScrambleState( new int[][] { LO_4, SL_1, null } ), // UP - new ScrambleState( new int[][] { null, SL_1, null } ), // UL - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - return null; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectShape getObjectShape(int cubit, int numLayers) - { - int variant = getCubitVariant(cubit,numLayers); - - if( variant==0 ) - { - double[][] vertices = new double[][] - { - { -1.5-X, 0.5, 1.5 }, - { 0.0, 0.5, 1.5 }, - { 0.0, 0.5,-1.5 }, - { -1.5+X, 0.5,-1.5 }, - { -1.5-X,-0.5, 1.5 }, - { 0.0,-0.5, 1.5 }, - { 0.0,-0.5,-1.5 }, - { -1.5+X,-0.5,-1.5 } - }; - - int[][] vert_indices = new int[][] - { - {0,1,2,3}, - {4,5,6,7}, - {4,5,1,0}, - {5,6,2,1}, - {6,7,3,2}, - {7,4,0,3} - }; - - float[][] bands = new float[][] { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} }; - int[] bandIndices = new int[] { 2,2,1,1,0,2 }; - float[][] corners = new float[][] { {0.03f,0.05f} }; - int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - float[][] centers = new float[][] { { -0.75f, 0.0f, 0.0f} }; - int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else if( variant==1 ) - { - double[][] vertices = new double[][] - { - { -X, 0.5, 0.0 }, - { +X, 0.5, 0.0 }, - {0.0, 0.5,-1.5 }, - { -X,-0.5, 0.0 }, - { +X,-0.5, 0.0 }, - {0.0,-0.5,-1.5 }, - }; - - int[][] vert_indices = new int[][] - { - {0,1,2}, - {3,4,5}, - {3,4,1,0}, - {4,5,2,1}, - {5,3,0,2} - }; - - float[][] bands = new float[][] { {0.038f,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} }; - int[] bandIndices = new int[] { 0,1,0,1,1 }; - float[][] corners = new float[][] { {0.04f,0.15f} }; - int[] cornerIndices = new int[] { 0,0,-1,0,0,-1 }; - float[][] centers = new float[][] { { 0.0f, 0.0f,-0.5f} }; - int[] centerIndices = new int[] { 0,0,-1,0,0,-1 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else - { - double[][] vertices = new double[][] - { - {-0.75f+X/2, 0.5, 0.0 }, - { 0.75f-X/2, 0.5, 0.0 }, - {-0.75f-X/2, 0.5, -1.5 }, - {-0.75f+X/2,-0.5, 0.0 }, - { 0.75f-X/2,-0.5, 0.0 }, - {-0.75f-X/2,-0.5, -1.5 } - }; - int[][] vert_indices = new int[][] - { - {0,1,2}, - {5,4,3}, - {3,4,1,0}, - {4,5,2,1}, - {5,3,0,2} - }; - - float[][] bands = new float[][] { {0.030f,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} }; - int[] bandIndices = new int[] { 0,0,0,1,1 }; - float[][] corners = new float[][] { {0.05f,0.13f} }; - int[] cornerIndices = new int[] { 0,0,-1,0,0,-1 }; - float[][] centers = new float[][] { { 0.0f, 0.0f,-0.5f} }; - int[] centerIndices = new int[] { 0,0,-1,0,0,-1 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D getQuat(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - - if( mQuatNumber ==null ) - { - mQuatNumber = new int[] - { - 0, 6, - 0, 9, 6, 3, 18, 15, 12, 21, - 0, 9, 6, 3, 0, 9, 6, 3, - 15, 12, 21, 18, 15, 12, 21, 18 - }; - } - - return mQuats[mQuatNumber[cubit]]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumCubitVariants(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getCubitVariant(int cubit, int numLayers) - { - return cubit<2 ? 0 : (cubit<10 ? 1:2); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectSticker retSticker(int face) - { - if( mStickers==null ) - { - float[][] STICKERS = new float[][] - { - { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front - { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right - { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back - { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f }, // edge top - { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face - { -0.11602539f, -0.25f, 0.4330127f, -0.25f, -0.3169873f, 0.5f } // corner top - }; - - final float R1 = 0.06f; - final float R2 = 0.04f; - final float R3 = 0.11f; - final float R4 = 0.03f; - final float R5 = 0.11f; - final float R6 = 0.025f; - final float[][] radii = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6} }; - final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.06f }; - - mStickers = new ObjectSticker[NUM_STICKERS]; - - for(int s=0; s13 && cubit<22 ) type = 3; - else type = 2; - - return 6*mStickerType[type][cubitface] + mStickerColor[cubit][cubitface]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API - - public int getObjectName(int numLayers) - { - return R.string.squa2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getInventor(int numLayers) - { - return R.string.squa2_inventor; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public int getComplexity(int numLayers) - { - return 7; - } -} diff --git a/src/main/java/org/distorted/objects/TwistyUltimate.java b/src/main/java/org/distorted/objects/TwistyUltimate.java deleted file mode 100644 index 47f766c9..00000000 --- a/src/main/java/org/distorted/objects/TwistyUltimate.java +++ /dev/null @@ -1,456 +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 static org.distorted.objectlib.Movement.TYPE_NOT_SPLIT; - -import android.content.res.Resources; - -import org.distorted.objectlib.ObjectShape; -import org.distorted.objectlib.ObjectSticker; -import org.distorted.objectlib.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.objectlib.Movement; -import org.distorted.objectlib.Movement12; -import org.distorted.objectlib.ObjectList; -import org.distorted.objectlib.Twisty12; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public class TwistyUltimate extends Twisty12 -{ - private static final float A = (float)Math.sqrt(21*SQ5+47); - private static final float B = SQ6*(5*SQ5+11)/(6*A); - private static final float C = SQ6*( SQ5+ 2)/(3*A); - private static final float D = SQ3/3; - private static final float E = (SQ5+1)/4; - private static final float F = (SQ5-1)/4; - private static final float G = (SQ5+3)/4; - - static final Static3D[] ROT_AXIS = new Static3D[] - { - new Static3D( B,0,C ), - new Static3D( C,B,0 ), - new Static3D(-D,D,D ), - new Static3D( 0,C,-B) - }; - - private static final int[][][] ENABLED = new int[][][] - { - {{2,3}},{{1,3}},{{1,3}},{{2,3}},{{0,3}},{{0,2}},{{0,2}},{{0,3}},{{1,2}},{{0,1}},{{0,1}},{{1,2}} - }; - - private ScrambleState[] mStates; - private int[] mBasicAngle; - private Static4D[] mQuats; - private float[][] mCuts; - private boolean[][] mLayerRotatable; - private int[][] mFaceMap; - private float[][] mCenters; - private int[] mQuatIndex; - private ObjectSticker[] mStickers; - private Movement mMovement; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public TwistyUltimate(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.ULTI, res, scrWidth); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ScrambleState[] getScrambleStates() - { - if( mStates==null ) - { - int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,0 }; - - mStates = new ScrambleState[] - { - new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} ) - }; - } - - return mStates; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void initializeQuats() - { - mQuats = new Static4D[] - { - new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), - new Static4D(-0.5f, 0.5f, 0.5f, 0.5f ), - new Static4D( 0.5f,-0.5f,-0.5f, 0.5f ), - new Static4D( 0.0f, F, -E, 0.5f ), - new Static4D( 0.0f, -F, E, 0.5f ), - new Static4D( E, 0.0f, F, 0.5f ), - new Static4D( -E, 0.0f, -F, 0.5f ), - new Static4D( F, E, 0.0f, 0.5f ), - new Static4D( -F, -E, 0.0f, 0.5f ), - new Static4D( E, F,-0.5f, 0.0f ), - new Static4D( 0.5f, -E, F, 0.0f ), - new Static4D( F, 0.5f, E, 0.0f ) - }; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int[] getSolvedQuats(int cubit, int numLayers) - { - if( mQuats==null ) initializeQuats(); - int status = retCubitSolvedStatus(cubit,numLayers); - return status<0 ? null : buildSolvedQuats(Movement12.FACE_AXIS[status],mQuats); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectShape getObjectShape(int cubit, int numLayers) - { - int variant = getCubitVariant(cubit,numLayers); - - if( variant==0 ) - { - double[][] vertices = new double[][] - { - { 0.0 , 0.0 , 0.0 }, - { -E , E+0.5, -0.5 }, - {-0.5 , -E , -E-0.5}, - { E+0.5, 0.5 , -E }, - { 0.0 , 1 , -2*E-1}, - { 0.0 , 1 , 0.0 }, - { -E ,-E+0.5, -0.5 }, - { E ,-E+0.5, -0.5 } - }; - int[][] vert_indices = new int[][] - { - {6,0,5,1}, - {0,7,3,5}, - {0,6,2,7}, - {4,3,5,1}, - {4,2,7,3}, - {4,1,6,2}, - }; - - float[][] bands = new float[][] { {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} }; - int[] bandIndices = new int[] { 0,0,0,1,1,1 }; - float[][] corners = new float[][] { { 0.013f, 0.16f } }; - int[] cornerIndices = new int[] { 0, 0, 0, 0,-1, 0, 0, 0 }; - float[][] centers = new float[][] { { 0.0f,-1.0f, -(SQ5+3)/2 } }; - int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else if( variant==1 ) - { - double[][] vertices = new double[][] - { - { 0.00, 0.00, 0.00}, - { - 0.50,-SQ5/4 - 0.25,-SQ5/4 - 0.75}, - { SQ5/4 + 0.25,-SQ5/4 - 0.75, + 0.50}, - { SQ5/4 + 0.75, + 0.50,-SQ5/4 - 0.25}, - { SQ5/2 + 0.50,-SQ5/2 - 0.50,-SQ5/2 - 0.50}, - { SQ5/4 - 0.25, + 0.50,-SQ5/4 - 0.25}, - { - 0.50,-SQ5/4 - 0.25,-SQ5/4 + 0.25}, - { SQ5/4 + 0.25,-SQ5/4 + 0.25, + 0.50} - }; - int[][] vert_indices = new int[][] - { - {6,0,5,1}, - {0,7,3,5}, - {0,6,2,7}, - {1,5,3,4}, - {3,7,2,4}, - {2,6,1,4}, - }; - - float[][] bands = new float[][] { {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} }; - int[] bandIndices = new int[] { 0,0,0,1,1,1 }; - float[][] corners = new float[][] { { 0.013f, 0.16f } }; - int[] cornerIndices = new int[] { 0, 0, 0, 0,-1, 0, 0, 0 }; - float[][] centers = new float[][] { { 0.0f,-1.0f, -(SQ5+3)/2 } }; - int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - else - { - double[][] vertices = new double[][] - { - { -E ,-E+0.5, 0.5}, - { E , E-0.5, -0.5}, - {-2*E , 0.0, 0.0}, - { 0.5, E , -E-0.5}, - { -E ,-E-0.5, 0.5}, - { E+0.5, -0.5, -E }, - {-2*E , -1.0, 0.0}, - { 1.0, 0.0,-2*E }, - {-2*E+0.5, E , -E-0.5}, - { 0.5,-E-1.0, -E+0.5}, - { -E ,-E-0.5,-2*E-0.5} - }; - int[][] vert_indices = new int[][] - { - {0,1,3,8,2}, // counterclockwise! - {0,4,9,5,1}, - { 0,2,6,4}, - { 1,5,7,3}, - {10,9,4,6}, - {10,9,5,7}, - {10,8,3,7}, - {10,8,2,6} - }; - - float[][] bands = new float[][] { {0.04f,17,0.5f,0.2f,5,2,2}, {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} }; - int[] bandIndices = new int[] { 0,0,1,1,2,2,2,2 }; - float[][] corners = new float[][] { { 0.013f, 0.16f } }; - int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0,0,0,-1 }; - float[][] centers = new float[][] { { -(SQ5+1)/4, 0.5f, -(SQ5+5)/4 } }; - int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0,0,0,0 }; - return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Static4D getQuat(int cubit, int numLayers) - { - if( mQuats ==null ) initializeQuats(); - if( mQuatIndex ==null ) mQuatIndex = new int[] { 0,6,1,2,0,4,6,5,0,1,4,9,5,2 }; - return mQuats[mQuatIndex[cubit]]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getNumCubitVariants(int numLayers) - { - return 3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getCubitVariant(int cubit, int numLayers) - { - return cubit<4 ? 0 : (cubit<8 ? 1:2); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected float[][] getCubitPositions(int numLayers) - { - if( mCenters==null ) - { - mCenters = new float[][] - { - { 0, -1, 2*G }, - { 2*E,-2*E,-2*E }, - {-2*G, 0, -1 }, - { 1, 2*G, 0 }, - - {-2*E, 2*E, 2*E }, - { 2*G, 0, 1 }, - { -1, -2*G, 0 }, - { 0, 1,-2*G }, - - { E, (E+0.5f), (E+G) }, - { -(E+G), -E, (E+0.5f) }, - { (E+0.5f), -(E+G), E }, - { -E,-(E+0.5f), -(E+G) }, - { (E+G), E,-(E+0.5f) }, - {-(E+0.5f), (E+G), -E } - }; - } - - return mCenters; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected int getFaceColor(int cubit, int cubitface, int size) - { - if( mFaceMap==null ) - { - mFaceMap = new int[][] - { - { 25,24,35, 36,36,36,36,36 }, - { 27,28,29, 36,36,36,36,36 }, - { 31,26,30, 36,36,36,36,36 }, - { 32,34,33, 36,36,36,36,36 }, - - { 31,32,25, 36,36,36,36,36 }, - { 33,28,24, 36,36,36,36,36 }, - { 26,35,27, 36,36,36,36,36 }, - { 30,29,34, 36,36,36,36,36 }, - - { 8, 0,13,21, 36,36,36,36 }, - { 1, 2,19,23, 36,36,36,36 }, - { 4,11,12,15, 36,36,36,36 }, - { 3, 6,14,17, 36,36,36,36 }, - { 5, 9,22,16, 36,36,36,36 }, - { 7,10,20,18, 36,36,36,36 } - }; - } - - return mFaceMap[cubit][cubitface]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected ObjectSticker retSticker(int face) - { - if( mStickers==null ) - { - float[][] STICKERS = new float[][] - { - { -0.14400357f, -0.47894150f, 0.50000000f,-0.011045523f, 0.37700626f, 0.36749030f,-0.26699730f, 0.36749026f, -0.46600536f, -0.24499352f }, // Big cubit 1st - { 0.36327127f, 0.26393202f,-0.36327127f, 0.500000000f,-0.36327127f,-0.26393202f, 0.36327127f,-0.50000000f }, // Big cubit 2nd - { -0.29389262f, -0.50000000f, 0.29389262f,-0.309017000f, 0.29389262f, 0.30901700f,-0.29389262f, 0.50000000f }, // Small cubit 1st - }; - - final float R1 = 0.08f; - final float R2 = 0.13f; - final float R3 = 0.11f; - final float[][] radii = { {R1,R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3} }; - final float[] strokes = { 0.07f, 0.09f, 0.08f }; - - mStickers = new ObjectSticker[STICKERS.length]; - - for(int s=0; s -#include -#include - -#define SQUARE - -#define SQ2 1.41421356237f -#define SQ3 1.73205080757f -#define SQ5 2.23606797750f -#define PI 3.14159265358f -#define NUM_QUATS 200 - -#ifdef PYRA -int basic[] = { 3,3,3,3 }; - -float axis[][3] = { { SQ2*SQ3/3, SQ3/3, 0 } , - {-SQ2*SQ3/3, SQ3/3, 0 } , - { 0, -SQ3/3, -SQ2*SQ3/3 } , - { 0, -SQ3/3, SQ2*SQ3/3 } }; -#endif - -#ifdef CUBE -int basic[] = { 4,4,4 }; - -float axis[][3] = { { 1,0,0 } , - { 0,1,0 } , - { 0,0,1 } }; -#endif - -#ifdef DINO -int basic[] = { 3,3,3,3 }; - -float axis[][3] = { {+SQ3/3,+SQ3/3,+SQ3/3} , - {+SQ3/3,+SQ3/3,-SQ3/3} , - {+SQ3/3,-SQ3/3,+SQ3/3} , - {+SQ3/3,-SQ3/3,-SQ3/3} }; -#endif - -#ifdef DIAM -int basic[] = { 3,3,3,3 }; - -float axis[][3] = { {+SQ3*SQ2/3,+SQ3/3, 0} , - {-SQ3*SQ2/3,+SQ3/3, 0} , - { 0,+SQ3/3,+SQ3*SQ2/3} , - { 0,+SQ3/3,-SQ3*SQ2/3} }; -#endif - -#ifdef HELI -int basic[] = { 2,2,2,2,2,2 }; - -float axis[][3] = { { 0, +SQ2/2, -SQ2/2} , - { 0, -SQ2/2, -SQ2/2} , - {+SQ2/2, 0, -SQ2/2} , - {-SQ2/2, 0, -SQ2/2} , - {+SQ2/2, -SQ2/2, 0} , - {-SQ2/2, -SQ2/2, 0} }; - -#endif - -#ifdef ULTI -int basic[] = { 3,3,3,3 }; - -float axis[][3] = { { 5*SQ5/16 + 11.0f/16, 0.0f , SQ5/8 + 1.0f/4 } , - { SQ5/8 + 1.0f/4 , 5*SQ5/16 + 11.0f/16, 0.0f } , - {-3*SQ5/16 - 7.0f/16, 3*SQ5/16 + 7.0f/16, 3*SQ5/16 + 7.0f/16} , - { 0.0f , SQ5/4 + 1.0f/2 , -5*SQ5/8 -11.0f/8 } }; - -#endif - -#ifdef SQUARE -#define COS15 (0.25f*SQ2*(SQ3+1)) -#define SIN15 (0.25f*SQ2*(SQ3-1)) - -int basic[] = { 12, 2 }; - -float axis[][3] = { { 0, 1, 0 } , - { COS15, 0, SIN15 } }; -#endif - -int inserted=0; - -/////////////////////////////////////////////////////////////////// -// q1*q2 - -void multiply_quats( float* q1, float* q2, float* output) - { - output[0] = q2[3]*q1[0] - q2[2]*q1[1] + q2[1]*q1[2] + q2[0]*q1[3]; - output[1] = q2[3]*q1[1] + q2[2]*q1[0] + q2[1]*q1[3] - q2[0]*q1[2]; - output[2] = q2[3]*q1[2] + q2[2]*q1[3] - q2[1]*q1[0] + q2[0]*q1[1]; - output[3] = q2[3]*q1[3] - q2[2]*q1[2] - q2[1]*q1[1] - q2[0]*q1[0]; - } - -/////////////////////////////////////////////////////////////////// -// sin(A/2)*x, sin(A/2)*y, sin(A/2)*z, cos(A/2) - -void create_quat(float* axis, float angle, float* output) - { - float cosAngle = cos(angle/2); - float sinAngle = sin(angle/2); - - output[0] = sinAngle*axis[0]; - output[1] = sinAngle*axis[1]; - output[2] = sinAngle*axis[2]; - output[3] = cosAngle; - } - -/////////////////////////////////////////////////////////////////// -// double cover, so q == -q - -int is_the_same(float* q1, float* q2) - { - const float MAX = 0.01f; - - float d0 = q1[0]-q2[0]; - float d1 = q1[1]-q2[1]; - float d2 = q1[2]-q2[2]; - float d3 = q1[3]-q2[3]; - - if( d0-MAX && - d1-MAX && - d2-MAX && - d3-MAX ) return 1; - - d0 = q1[0]+q2[0]; - d1 = q1[1]+q2[1]; - d2 = q1[2]+q2[2]; - d3 = q1[3]+q2[3]; - - if( d0-MAX && - d1-MAX && - d2-MAX && - d3-MAX ) return 1; - - return 0; - } - -/////////////////////////////////////////////////////////////////// - -int getIndexInTable(float* quat, float* table) - { - for(int i=0; i%1$d/%2$d %1$2d. - Pocket Cube - Rubik Cube - Rubik\'s Revenge - Professor\'s Cube - Pyraminx - Master Pyraminx - Professor\'s Pyraminx - Skewb - Master Skewb - Skewb Diamond - Face Turning Octahedron - Master Face Turning Octahedron - Redi Cube - Helicopter Cube - Ivy Cube - Rex Cube - Dino Cube (6 color) - Dino Cube (4 color) - Kilominx - Megaminx - Master Kilominx - Gigaminx - Skewb Ultimate - Square-1 - Square-2 - Jing Pyraminx - Mirror Cube - Pocket Mirror - - Fused Cube - 2Bar Cube - 3Plate Cube - Evil Cube - - Larry Nichols, 1970 - Ernő Rubik, 1974 - Péter Sebestény, 1981 - Udo Krell, 1981 - Uwe Meffert, 1970 - Katsuhiko Okamoto, 2002 - Timur Evbatyrov, 2011 - Tony Durham, 1982 - Katsuhiko Okamoto, 2003 - Uwe Meffert, 1984 - David Pitcher, 2003 - Timur Evbatyrov, 2011 - Oskar van Deventer, 2009 - Adam G. Cowan, 2006 - Eitan Cher, 2009 - Andrew Cormier, 2009 - Robert Webb, 1985 - Robert Webb, 1985 - Thomas de Bruin, 2008 - Ferenc Szlivka, 1982 - David Gugl, 2010 - Tyler Fox, 2006 - Tony Fisher, 2000 - Vojtech Kopsky, Harel Hrsel, 1999 - David Litwin, 1995 - Tony Fisher, 1991 - Thomas de Bruin, 2007 - Hidetoshi Takeji, 2006 - - who knows - who knows - who knows - who knows -