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;

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

public class ScrambleEdgeGenerator

  {

  private static void insertSection(int[] table, int startIndex, int size, int startAlg, int state)

    {

    int num = size/2;

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

      {

      table[2*(i+startIndex)  ] = startAlg +i;

      table[2*(i+startIndex)+1] = state;

      }

    }

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

  private static int[] createEdge(int sizeX, int sizeY, int sizeZ, int stateX, int stateY, int stateZ)

    {

    int num = 0;

    int consX = ((sizeY!=sizeZ) ? 2:6)*sizeX;

    int consY = ((sizeX!=sizeZ) ? 2:6)*sizeY;

    int consZ = ((sizeX!=sizeY) ? 2:6)*sizeZ;

    if( stateX>=0 ) num += consX;

    if( stateY>=0 ) num += consY;

    if( stateZ>=0 ) num += consZ;

    int[] ret = new int[num];

    int index = 0;

    int algor = 0;

    if( stateX>=0 ) { insertSection(ret,index,consX,algor,stateX); index += consX/2; }

    algor += consX/2;

    if( stateY>=0 ) { insertSection(ret,index,consY,algor,stateY); index += consY/2; }

    algor += consY/2;

    if( stateZ>=0 ) { insertSection(ret,index,consZ,algor,stateZ);                   }

    return ret;

    }

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

  public static int[][] getScrambleEdgesCuboid(int X, int Y, int Z)

    {

    return new int[][]

      {

      createEdge(X,Y,Z, 1, 2, 3), // 0 0

      createEdge(X,Y,Z,-1, 4, 5), // 1 x

      createEdge(X,Y,Z, 6,-1, 7), // 2 y

      createEdge(X,Y,Z, 8, 9,-1), // 3 z

      createEdge(X,Y,Z,10,-1, 7), // 4 xy

      createEdge(X,Y,Z,11, 9,-1), // 5 xz

      createEdge(X,Y,Z,-1,12, 5), // 6 yx

      createEdge(X,Y,Z, 8,13,-1), // 7 yz

      createEdge(X,Y,Z,-1, 4,14), // 8 zx

      createEdge(X,Y,Z, 6,-1,15), // 9 zy

      createEdge(X,Y,Z,-1,-1, 5), // 10 xyx

      createEdge(X,Y,Z,-1, 4,-1), // 11 xzx

      createEdge(X,Y,Z,-1,-1, 7), // 12 yxy

      createEdge(X,Y,Z, 6,-1,-1), // 13 yzy

      createEdge(X,Y,Z,-1, 9,-1), // 14 zxz

      createEdge(X,Y,Z, 8,-1,-1), // 15 zyz

      };

    }

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

  public static int[][] getScrambleEdgesSingle(int[][] basicAngle)

    {

    int size=0;

    for (int[] basic : basicAngle)

      for (int i : basic) size += (i-1);

    int[] edge = new int[2*size];

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

      {

      edge[2*i  ] = i;

      edge[2*i+1] = 0;

      }

    return new int[][] { edge };

    }

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

  public static int[][] getScrambleEdgesSingle(int[][] basicAngles, boolean[][] rotatable)

    {

    int num=0;

    int numAxis= basicAngles.length;

    for(int a=0; a<numAxis; a++)

      {

      int[] angles = basicAngles[a];

      int numLayers = angles.length;

      for(int l=0; l<numLayers; l++)

        if( rotatable[a][l] )

          num += (angles[l]-1);

      }

    int[] edge = new int[2*num];

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

      {

      edge[2*i  ] = i;

      edge[2*i+1] = 0;

      }

    return new int[][] { edge };

    }

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

  public static int[][] getScramblingAlgorithms(int[][] basicAngles)

    {

    int numAxis= basicAngles.length;

    int num=0;

    for (int[] basic : basicAngles)

      for (int i : basic) num += (i-1);

    int[][] ret = new int[num][3];

    int index = 0;

    for(int a=0; a<numAxis; a++)

      {

      int numLayers = basicAngles[a].length;

      for(int l=0; l<numLayers; l++)

        {

        int N = basicAngles[a][l];

        int NEG = (1-N)/2;

        int POS = N/2;

        int layerBmp = (1<<l);

        for(int k=NEG; k<=-1; k++)

          {

          ret[index][0] = a;

          ret[index][1] = layerBmp;

          ret[index][2] = k;

          index++;

          }

        for(int k=1; k<=POS; k++)

          {

          ret[index][0] = a;

          ret[index][1] = layerBmp;

          ret[index][2] = k;

          index++;

          }

        }

      }

    return ret;

    }

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

  public static int[][] getScramblingAlgorithms(int[][] basicAngles, boolean[][] rotatable)

    {

    int numAxis= basicAngles.length;

    int num=0;

    for(int a=0; a<numAxis; a++)

      {

      int[] angles = basicAngles[a];

      int numLayers = angles.length;

      for(int l=0; l<numLayers; l++)

        if( rotatable[a][l] )

          num += (angles[l]-1);

      }

    int[][] ret = new int[num][3];

    int index = 0;

    for(int a=0; a<numAxis; a++)

      {

      int numLayers = basicAngles[a].length;

      for(int l=0; l<numLayers; l++)

        {

        if( rotatable[a][l] )

          {

          int N = basicAngles[a][l];

          int NEG = (1-N)/2;

          int POS = N/2;

          int layerBmp = (1<<l);

          for(int k=NEG; k<=-1; k++)

            {

            ret[index][0] = a;

            ret[index][1] = layerBmp;

            ret[index][2] = k;

            index++;

            }

          for(int k=1; k<=POS; k++)

            {

            ret[index][0] = a;

            ret[index][1] = layerBmp;

            ret[index][2] = k;

            index++;

            }

          }

        }

      }

    return ret;

    }

  }