TwistyPuzzleLib

import org.distorted.objectlib.main.TwistyObject;

  private int getAlgorithmIndex(int ax, int layer, int angle)

    int numAlgs = mAlgorithms.length;

    for(int alg=0; alg<numAlgs; alg++)

      {

      int[] algorithm = mAlgorithms[alg];

      if( algorithm.length>=3 && algorithm[0]==ax && algorithm[1]==layer && algorithm[2]==angle ) return alg;

      }

    return -1;

    }

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

  private int[] produceEdge(int[][] scramblingData)

    {

    int index=0, length=0;

    int numAxis = scramblingData.length;

    for (int[] scramblingDatum : scramblingData) length += scramblingDatum.length;

    int[] ret = new int[2*length/3];

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

      int[] data = scramblingData[ax];

      int num = data.length/3;

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

        int layer = data[3*j];

        int angle = data[3*j+1];

        int state = data[3*j+2];

        ret[2*index  ] = getAlgorithmIndex(ax,layer,angle);

        ret[2*index+1] = state;

        index++;

      }

    return ret;

    }

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

  private void parseScrambling6(JSONObject object) throws JSONException

    {

    JSONArray jsonStates = object.getJSONArray("scrambleStates");

    int numStates = jsonStates.length();

    int[][][] scramblingData = new int[numStates][][];

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

      {

      JSONArray jsonState = jsonStates.getJSONArray(i);

      int numAxis = jsonState.length();

      scramblingData[i] = new int[numAxis][];

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

        JSONArray jsonData = jsonState.getJSONArray(j);

        int numData = jsonData.length();

        scramblingData[i][j] = new int[numData];

        for(int k=0; k<numData; k++) scramblingData[i][j][k] = jsonData.getInt(k);

    mAlgorithms = TwistyObject.staticGetAlgorithms(mBasicAngle);

    mEdges = new int[numStates][];

    for(int i=0; i<numStates; i++) mEdges[i] = produceEdge(scramblingData[i]);

    }

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

  private void parseScrambling7orMore(JSONObject object) throws JSONException

    {

    JSONArray jsonAlgorithms = object.getJSONArray("algorithms");

    int numAlgs = jsonAlgorithms.length();

    mAlgorithms = new int[numAlgs][];

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

      {

      JSONArray jsonAlg = jsonAlgorithms.getJSONArray(i);

      int numEntries = jsonAlg.length();

      mAlgorithms[i] = new int[numEntries];

      for(int j=0; j<numEntries; j++) mAlgorithms[i][j] = jsonAlg.getInt(j);

      }

    JSONArray jsonEdges = object.getJSONArray("edges");

    int numEdges = jsonEdges.length();

    mEdges = new int[numEdges][];

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

      {

      JSONArray jsonEdge = jsonEdges.getJSONArray(i);

      int numEntries = jsonEdge.length();

      mEdges[i] = new int[numEntries];

      for(int j=0; j<numEntries; j++) mEdges[i][j] = jsonEdge.getInt(j);

      }

    }

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

  private void parseScrambling(JSONObject object, int major) throws JSONException

    {

    mScrambleType = object.getInt("scrambleType");

    if( mScrambleType==0 )

      {

      if( major==6 ) parseScrambling6(object);

      else           parseScrambling7orMore(object);

      }

  private void parseFile(JSONObject object, int major) throws JSONException

    parseScrambling(scrambling,major);

      parseFile(object,major);

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

  public static int[][] staticGetAlgorithms(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 i=0; i<numAxis; i++)

      {

      int numLayers = basicAngles[i].length;

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

        {

        int N = basicAngles[i][j];

        int NEG = (1-N)/2;

        int POS = N/2;

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

          {

          ret[index][0] = i;

          ret[index][1] = j;

          ret[index][2] = k;

          index++;

          }

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

          {

          ret[index][0] = i;

          ret[index][1] = j;

          ret[index][2] = k;

          index++;

          }

        }

      }

    return ret;

    }

    return staticGetAlgorithms(mBasicAngles);