TwistyPuzzleLib

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

// Copyright 2021 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.scrambling;

import java.util.Random;

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

public class ScrambleState

{

  private final int mTotal, mNumAxis, mNumNonZero;

  private final int[] mNum;

  private final int[] mInfo;

  private final int[] mTmp;

  private final int[][] mOrigAxis;

  private final int LEN = 4;

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

  public ScrambleState(int[][] axis)

    {

    mOrigAxis = axis;

    mTmp = new int[LEN];

    mNumAxis = axis.length;

    mNum = new int[mNumAxis];

    int nonzero=0, total =0;

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

      {

      mNum[i] = axis[i]==null ? 0 : axis[i].length/(LEN-1);

      total += mNum[i];

      }

    for(int i=0; i<mNumAxis; i++) if( mNum[i]>0 ) nonzero++;

    mNumNonZero = nonzero;

    mTotal = total;

    mInfo = new int[LEN*total];

    int start = 0;

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

      {

      for(int j=0; j<mNum[i]; j++)

        {

        mInfo[LEN*j   + start] = i;

        mInfo[LEN*j+1 + start] = axis[i][(LEN-1)*j  ];

        mInfo[LEN*j+2 + start] = axis[i][(LEN-1)*j+1];

        mInfo[LEN*j+3 + start] = axis[i][(LEN-1)*j+2];

        }

      start += LEN*mNum[i];

      }

    }

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

  private int getIndex(int num, int indexExcluded)

    {

    int current= -1;

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

      if( mInfo[LEN*i]!=indexExcluded && ++current==num ) return i;

    return -1;

    }

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

  public int[] getRandom(Random rnd, int indexExcluded, int[][] scrambleTable, int[] numOccurences)

    {

    int num=0, total=0, max=0, ax, layer;

    if( mNumNonZero<2 ) indexExcluded=-1;

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

      {

      ax = mInfo[LEN*i];

      if( ax!=indexExcluded )

        {

        layer = mInfo[LEN*i+1];

        int value = scrambleTable[ax][layer];

        if( value>max ) max=value;

        }

      }

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

      {

      ax = mInfo[LEN*i];

      if( ax!=indexExcluded )

        {

        layer = mInfo[LEN*i+1];

        int value = scrambleTable[ax][layer];

        numOccurences[total] = 1 + max - value + (total==0 ? 0 : numOccurences[total-1]);

        total++;

        }

      }

    float random= rnd.nextFloat()*numOccurences[total-1];

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

      {

      if( random <= numOccurences[i] )

        {

        num=i;

        break;

        }

      }

    int index = getIndex(num,indexExcluded);

    mTmp[0] = mInfo[LEN*index  ];   // axis

    mTmp[1] = mInfo[LEN*index+1];   // row

    mTmp[2] = mInfo[LEN*index+2];   // angle

    mTmp[3] = mInfo[LEN*index+3];   // next state

    scrambleTable[mTmp[0]][mTmp[1]]++;

    return mTmp;

    }

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

  public int getNumAxis()

    {

    return mNumAxis;

    }

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

  public int[] getAx(int numAx)

    {

    return (numAx>=0 && numAx<mNumAxis) ? mOrigAxis[numAx] : null;

    }

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

  public int getTotal(int indexExcluded)

    {

    return ( indexExcluded>=0 && indexExcluded<mNumAxis ) ? mTotal-mNum[indexExcluded] : mTotal;

    }

}