TwistyPuzzleLib

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

// Copyright 2024 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.algsolvers.implemented;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.algsolvers.MoveProviderAlgs;

import org.distorted.objectlib.algsolvers.MoveProviderAll;

import org.distorted.objectlib.algsolvers.Phase;

import org.distorted.objectlib.algsolvers.PhaseMitm;

import org.distorted.objectlib.algsolvers.SolvedObject;

import org.distorted.objectlib.algsolvers.TargetProvider;

import org.distorted.objectlib.algsolvers.TargetProviderAll;

import org.distorted.objectlib.algsolvers.TargetProviderOrie;

import org.distorted.objectlib.algsolvers.TargetProviderPerm;

import org.distorted.objectlib.objects.TwistyDodecahedron;

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

public class SolverKilominx extends SolverAbstract

{

  @Override

  SolvedObject createObject()

    {

    float[][] pos = TwistyDodecahedron.initializeCorners();

    Static3D[] axis = TwistyDodecahedron.ROT_AXIS;

    int[] a = new int[] {5,5,5};

    int[][] angles  = new int[][] { a,a,a,a,a,a };

    float[][] cuts = TwistyDodecahedron.genericGetCuts(3,0.5f);

    boolean[] r = {true,false,true};

    boolean[][] rot = {r,r,r,r,r,r};

    return new SolvedObject(pos,axis,angles,cuts,rot);

    }

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

  @Override

  Phase[] createPhases(SolvedObject object)

    {

    int[][] whiteFace = new int[][]{ {12,13,16,17} };

    MoveProviderAll all = new MoveProviderAll(object);

    TargetProvider wcr = new TargetProviderAll(whiteFace);

    return new Phase[]

      {

      new PhaseMitm( object, all, wcr, "White Face"),

      };

    }

}

    if( mCuts==null )

      {

      int param = getMetadata().getParam();

      int size = numLayers[0];

      float dist = (param==KILOMINX3 || param==KILOMINX5) ? 0.5f : 0.5f-MEGA_D;

      mCuts = genericGetCuts(size,dist);

      }

    return mCuts;

  static final float SIN18     = (SQ5-1)/4;

  static final float COS18     = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5));

  public static final Static3D[] ROT_AXIS = new Static3D[]

  protected float[][] mCuts;

  public static float[][] genericGetCuts(int numLayers, float dist)

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

    float D = numLayers* TouchControlDodecahedron.DIST3D;

    float X = 2*D/(2+SIN18);  // height of the 'upper' part of a dodecahedron, i.e. put it on a table,

                              // its height is then 2D, it has one 'lower' part of height X, one

                              // 'middle' part of height Y and one upper part of height X again.

    int num = (numLayers-1)/2;

    float G = X*dist/num;     // height of one Layer

    for(int i=0; i<num; i++)

      float cut = -D + (i+0.85f)*G;  // 0.85? not fully correct; attempt to make it

      int j = 2*num-1-i;

      cuts[0][i] =  cut;

      cuts[0][j] = -cut;

      cuts[1][i] =  cut;

      cuts[1][j] = -cut;

      cuts[2][i] =  cut;

      cuts[2][j] = -cut;

      cuts[3][i] =  cut;

      cuts[3][j] = -cut;

      cuts[4][i] =  cut;

      cuts[4][j] = -cut;

      cuts[5][i] =  cut;

      cuts[5][j] = -cut;

  return cuts;

  }

    if( mCuts==null ) mCuts = genericGetCuts(numLayers[0],0.5f);

    return mCuts;

    if( mCuts==null ) mCuts = genericGetCuts(numLayers[0],0.5f-MEGA_D);

    return mCuts;