Magic Cube

package org.distorted.solvers.cube3;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//Cube on the facelet level

class FaceCube {

	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.<br>

	// 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 =

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

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

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

            { Facelet.D7, Facelet.B9, Facelet.L7 }, { Facelet.D9, Facelet.R9, Facelet.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.<br>

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

	final static int[][] edgeFacelet =

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

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

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

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

	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	// Map the corner positions to facelet colors.

	final static int[][] cornerColor =

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

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

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

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

	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	// Map the edge positions to facelet colors.

	final static int[][] edgeColor =

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

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

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

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

	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	FaceCube()

      {

	  String s = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";

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

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

	  }

	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	// Construct a facelet cube from a string

	FaceCube(String cubeString)

      {

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

	    f[i] = Color.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 += Color.toString(f[i]);

          return s;

	  }

	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	// Gives CubieCube representation of a faceletcube

	CubieCube toCubieCube()

          {

	  byte ori;

	  CubieCube ccRet = new CubieCube();

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

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

	  int col1, col2;

	  for ( int i=Corner.URF; i<=Corner.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]] == Color.U || f[cornerFacelet[i][ori]] == Color.D)

		break;

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

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

	    for ( int j=Corner.URF; j<=Corner.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=Edge.UR; i<=Edge.BR; i++)

            {

	    for ( int j=Edge.UR; j<=Edge.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;

	};

}