TwistyPuzzleLib

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

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.scrambling;

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

import org.distorted.objectlib.helpers.ObjectSignature;

  public static final int AXIS_X = 0;

  public static final int AXIS_Y = 1;

  public static final int AXIS_Z = 2;

  private final ObjectSignature mSignature;

  private final int[] mLayer, mTurns;

  private final int mNumMoves;

  private final int mStartX, mStartY, mStartZ;

  private final boolean[][] mIsUnblocked;

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

    mTurns = new int[3];

    mIsUnblocked = new boolean[3][MAX_SUPPORTED_SIZE];

    mLayer[0] = x;

    mLayer[1] = y;

    mLayer[2] = z;

    mTurns[0] = mLayer[1]==mLayer[2] ? 3:1;

    mTurns[1] = mLayer[0]==mLayer[2] ? 3:1;

    mTurns[2] = mLayer[0]==mLayer[1] ? 3:1;

    int xMoves = mLayer[0]>1 ? mTurns[0]*mLayer[0] : 0;

    int yMoves = mLayer[1]>1 ? mTurns[1]*mLayer[1] : 0;

    int zMoves = mLayer[2]>1 ? mTurns[2]*mLayer[2] : 0;

    mNumMoves = xMoves + yMoves + zMoves;

    mStartX = 0;

    mStartY = xMoves;

    mStartZ = xMoves + yMoves;

    mSignature = signature;

    mMoves = createMoves();

android.util.Log.d("D", "sig: "+mSignature.getString() );

printMoves();

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

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

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

      if( signature.isEqual(mMoves[m]) ) mMoves[m]=null;

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

    int num = 0;

    for(int y=mStartY; y<mStartZ  ; y++) if( mMoves[y]!=null ) { num++; break; }

    for(int z=mStartZ; z<mNumMoves; z++) if( mMoves[z]!=null ) { num++; break; }

    return num;

    }

  private int numXMoves()

    {

    int num=0;

    }

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

  private int numYMoves()

    {

    int num=0;

    }

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

  private int numZMoves()

    {

    int num=0;

    }

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

  public int numMoves()

    {

    return numXMoves()+numYMoves()+numZMoves();

    }

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

  public int numMoves(int excludedAxis)

    {

    switch(excludedAxis)

      {

      case AXIS_X: return numYMoves()+numZMoves();

      case AXIS_Y: return numXMoves()+numZMoves();

      case AXIS_Z: return numXMoves()+numYMoves();

      }

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

  public int getNthMove(int n, int excludedAxis)

    {

    int num = 0;

        if( mMoves[m]!=null )

          num++;

      }

        if( mMoves[m]!=null )

          num++;

        if( mMoves[m]!=null )

          num++;

      }

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

    for(int axis=0; axis<3; axis++)

        }

      if( mLayer[axis]>1 )

        for(int turn=0; turn<mTurns[axis]; turn++)

          for(int layer=0; layer<mLayer[axis]; layer++)

            {

            if( mIsUnblocked[axis][layer] )

              {

              if( layer>0 ) allLayersLocked = false;

              ret[index] = mSignature.turn(axis,layer,turn);

              }

            else

              {

              ret[index] = ret[index-1].turn(axis,layer,turn);

              ret[index-1] = null;

              }

            index++;

            }

          if( allLayersLocked ) ret[index-1] = null;

    return ret;

    }

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

    boolean first = true;

        {

        String num = (i<10 ? " "+i : ""+i);

        if( first ) { ret += num; first=false; }

        else          ret += (","+num);

        }

}