TwistyPuzzleLib

/*

 * Herbert Kociemba

 *

 * BSD-licensed. See https://opensource.org/licenses/BSD-3-Clause

 */

package org.distorted.objectlib.kociemba;

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

class SolverFaceCube

{

	public int[] f = new int[54];

	// Map the corner positions to facelet positions. cornerFacelet[URF.ordinal()][0] e.g. gives the position of the

	// facelet in the URF corner position, which defines the orientation.

	// cornerFacelet[URF.ordinal()][1] and cornerFacelet[URF.ordinal()][2] give the position of the other two facelets

	// of the URF corner (clockwise).

	final static int[][] cornerFacelet =

          { { SolverFacelet.U9, SolverFacelet.R1, SolverFacelet.F3 }, { SolverFacelet.U7, SolverFacelet.F1, SolverFacelet.L3 },

            { SolverFacelet.U1, SolverFacelet.L1, SolverFacelet.B3 }, { SolverFacelet.U3, SolverFacelet.B1, SolverFacelet.R3 },

	          { SolverFacelet.D3, SolverFacelet.F9, SolverFacelet.R7 }, { SolverFacelet.D1, SolverFacelet.L9, SolverFacelet.F7 },

            { SolverFacelet.D7, SolverFacelet.B9, SolverFacelet.L7 }, { SolverFacelet.D9, SolverFacelet.R9, SolverFacelet.B7 } };

	// Map the edge positions to facelet positions. edgeFacelet[UR.ordinal()][0] e.g. gives the position of the facelet in

	// the UR edge position, which defines the orientation.

	// edgeFacelet[UR.ordinal()][1] gives the position of the other facelet

	final static int[][] edgeFacelet =

          { { SolverFacelet.U6, SolverFacelet.R2 }, { SolverFacelet.U8, SolverFacelet.F2 }, { SolverFacelet.U4, SolverFacelet.L2 },

            { SolverFacelet.U2, SolverFacelet.B2 }, { SolverFacelet.D6, SolverFacelet.R8 }, { SolverFacelet.D2, SolverFacelet.F8 },

	          { SolverFacelet.D4, SolverFacelet.L8 }, { SolverFacelet.D8, SolverFacelet.B8 }, { SolverFacelet.F6, SolverFacelet.R4 },

            { SolverFacelet.F4, SolverFacelet.L6 }, { SolverFacelet.B6, SolverFacelet.L4 }, { SolverFacelet.B4, SolverFacelet.R6 } };

	// Map the corner positions to facelet colors.

	final static int[][] cornerColor =

          { { SolverColor.U, SolverColor.R, SolverColor.F }, { SolverColor.U, SolverColor.F, SolverColor.L },

            { SolverColor.U, SolverColor.L, SolverColor.B }, { SolverColor.U, SolverColor.B, SolverColor.R },

            { SolverColor.D, SolverColor.F, SolverColor.R }, { SolverColor.D, SolverColor.L, SolverColor.F },

	          { SolverColor.D, SolverColor.B, SolverColor.L }, { SolverColor.D, SolverColor.R, SolverColor.B } };

	// Map the edge positions to facelet colors.

	final static int[][] edgeColor =

          { { SolverColor.U, SolverColor.R }, { SolverColor.U, SolverColor.F }, { SolverColor.U, SolverColor.L },

            { SolverColor.U, SolverColor.B }, { SolverColor.D, SolverColor.R }, { SolverColor.D, SolverColor.F },

            { SolverColor.D, SolverColor.L }, { SolverColor.D, SolverColor.B }, { SolverColor.F, SolverColor.R },

            { SolverColor.F, SolverColor.L }, { SolverColor.B, SolverColor.L }, { SolverColor.B, SolverColor.R } };

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

	SolverFaceCube()

    {

	  String s = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";

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

	    f[i] = SolverColor.toInt(s.substring(i, i + 1));

	  }

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

// Construct a facelet cube from a string

	SolverFaceCube(String cubeString)

    {

	  for( int i=0; i<cubeString.length(); i++)

	    f[i] = SolverColor.toInt(cubeString.substring(i, i + 1));

	  }

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

// Gives string representation of a facelet cube

	String to_String()

    {

	  String s = "";

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

	    s += SolverColor.toString(f[i]);

    return s;

	  }

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

// Gives CubieCube representation of a faceletcube

	SolverCubieCube toCubieCube()

    {

	  byte ori;

	  SolverCubieCube ccRet = new SolverCubieCube();

      for( int i=0; i< 8; i++) ccRet.cp[i] = SolverCorner.URF; // invalidate corners

	  for( int i=0; i<12; i++) ccRet.ep[i] = SolverEdge.UR;    // and edges

	  int col1, col2;

	  for(int i = SolverCorner.URF; i<= SolverCorner.DRB; i++)

      {

	    // get the colors of the cubie at corner i, starting with U/D

	    for (ori = 0; ori < 3; ori++)

	      if (f[cornerFacelet[i][ori]] == SolverColor.U || f[cornerFacelet[i][ori]] == SolverColor.D)

		      break;

	    col1 = f[cornerFacelet[i][(ori+1)%3]];

	    col2 = f[cornerFacelet[i][(ori+2)%3]];

	    for(int j = SolverCorner.URF; j<= SolverCorner.DRB; j++)

        {

	      if( col1==cornerColor[j][1] && col2==cornerColor[j][2])

          {

		      // in cornerposition i we have cornercubie j

		      ccRet.cp[i] = j;

		      ccRet.co[i] = (byte) (ori % 3);

		      break;

		      }

	      }

	    }

    for(int i = SolverEdge.UR; i<= SolverEdge.BR; i++)

      {

	    for(int j = SolverEdge.UR; j<= SolverEdge.BR; j++)

        {

        if( f[edgeFacelet[i][0]]==edgeColor[j][0] && f[edgeFacelet[i][1]]==edgeColor[j][1])

          {

		      ccRet.ep[i] = j;

		      ccRet.eo[i] = 0;

		      break;

		      }

        if( f[edgeFacelet[i][0]]==edgeColor[j][1] && f[edgeFacelet[i][1]]==edgeColor[j][0])

          {

		      ccRet.ep[i] = j;

		      ccRet.eo[i] = 1;

		      break;

          }

	      }

	    }

	return ccRet;

	}

}