import lejos.nxt.*;
import lejos.nxt.comm.*;
/**
* Solve Rubik's Cube By CFOP
* @author ChenWu http://www.diy-robots.com
* @see CFOP
*/
public class CFOP
{
static String SideColors[] = {
"orgorwwoo",
"oyggbobrg",
"yyrgowwbw",
"yrybgybbo",
"gwwyybror",
"bgrwwrbgy"
};
public static void main (String[] aArg) throws Exception
{
Steps.Clear();
if(Rubik.ImportColor(SideColors)=="")
{
TopCross();
TopCorner();
SecondLayer();
BottomCross();
BottomCorner();
ThirdLayerCorner();
ThirdLayerCornerSnap();
ThirdLayerBorderSnap();
}
//Now the steps are saved in Steps Object
for(int i=0;i<Steps.Count;i++)
{
Steps.Index=i;
//int c = Steps.Color(); //Color
//bool ColockWise = Steps.ClockWise(); //Rotate direction
//int Quarter = Steps.Quarter(); //Number of quarter be rotated
}
}
public static void TopCross() throws Exception
{
int GetPos=0;
int[] c=new int[5];
int CurrentStep=Steps.Count;
c[0]=Rubik.Sides[0][1][1];
c[1]=Rubik.Sides[1][1][1];
c[2]=Rubik.Sides[5][1][1];
c[3]=Rubik.Sides[3][1][1];
c[4]=Rubik.Sides[4][1][1];
for(int i=1;i<5;i++)
{
CurrentStep=Steps.Count;
Rubik.ChangeViewToColor(c[0]);
Rubik.ChangeViewFromTopByNextColor(c[i]);
GetPos=Rubik.FindBorderCell(c[0],c[i]);
switch(GetPos)
{
case 101:
//Already fixed
break;
case 110:
Steps.AddStep(1, false, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, false, 1);
break;
case 140:
Steps.AddStep(4, true, 1);
Steps.AddStep(1, true, 1);
break;
case 104:
Steps.AddStep(4, true, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, false, 1);
break;
case 130:
Steps.AddStep(3, true, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(0, false, 1);
break;
case 103:
Steps.AddStep(3, true, 1);
Steps.AddStep(0, true, 2);
Steps.AddStep(3, false, 1);
Steps.AddStep(0, false, 2);
break;
case 150:
Steps.AddStep(5, false, 1);
Steps.AddStep(1, false, 1);
break;
case 105:
Steps.AddStep(5, false, 1);
Steps.AddStep(0, false, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(0, true, 1);
break;
case 241:
Steps.AddStep(1, true, 1);
break;
case 214:
Steps.AddStep(0, true, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, false, 1);
break;
case 243:
Steps.AddStep(4, true, 2);
Steps.AddStep(1, true, 1);
Steps.AddStep(4, true, 2);
break;
case 234:
Steps.AddStep(0, true, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(0, false, 1);
break;
case 253:
Steps.AddStep(5, true, 2);
Steps.AddStep(1, false, 1);
Steps.AddStep(5, true, 2);
break;
case 235:
Steps.AddStep(0, false, 1);
Steps.AddStep(5, false, 1);
Steps.AddStep(0, true, 1);
break;
case 251:
Steps.AddStep(1, false, 1);
break;
case 215:
Steps.AddStep(0, false, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(0, true, 1);
break;
case 312:
Steps.AddStep(2,true,1);
Steps.AddStep(5,true,1);
Steps.AddStep(1,false,1);
Steps.AddStep(5,false,1);
break;
case 321:
Steps.AddStep(1,true,2);
break;
case 342:
Steps.AddStep(4,false,1);
Steps.AddStep(1,true,1);
Steps.AddStep(4,true,1);
break;
case 324:
Steps.AddStep(2,true,1);
Steps.AddStep(1,true,2);
break;
case 352:
Steps.AddStep(5,true,1);
Steps.AddStep(1,false,1);
Steps.AddStep(5,false,1);
break;
case 325:
Steps.AddStep(2,false,1);
Steps.AddStep(1,true,2);
break;
case 332:
Steps.AddStep(2,true,1);
Steps.AddStep(4,false,1);
Steps.AddStep(1,true,1);
Steps.AddStep(4,true,1);
break;
case 323:
Steps.AddStep(2,true,2);
Steps.AddStep(1,true,2);
break;
default:
//Do nothing
break;
}
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c[0]);
}
}
public static void TopCorner() throws Exception
{
int CurrentStep=Steps.Count;
int GetPos=0;
int[] c=new int[5];
int nTopPos=0;
int nOtherPos=0;
int nSum=0;
boolean bFlag=false;
c[0]=Rubik.Sides[0][1][1];
c[1]=Rubik.Sides[1][1][1];
c[2]=Rubik.Sides[5][1][1];
c[3]=Rubik.Sides[3][1][1];
c[4]=Rubik.Sides[4][1][1];
for(int i=1;i<5;i++)
{
Rubik.ChangeViewToColor(c[0]);
Rubik.ChangeViewFromTopByNextColor(c[i]);
int j=i+1;
if(j==5) j=1;
GetPos=Rubik.FindCornerCell(c[0],c[i],c[j]);
if(GetPos!=1015)
{
//1015 means already fixed
if(GetPos<2000)
{
//In top layer, move to bottom first
CurrentStep=Steps.Count;
nTopPos=GetBit(GetPos,3);
nSum=GetSum(GetPos)-1;
nOtherPos=(nTopPos==0?GetBit(GetPos,1):(nSum-nTopPos));
if(nOtherPos==5 && nSum==6) bFlag=false;
if(nOtherPos==5 && nSum==8) bFlag=true;
if(nOtherPos==3 && nSum==8) bFlag=false;
if(nOtherPos==3 && nSum==7) bFlag=true;
if(nOtherPos==4 && nSum==7) bFlag=false;
if(nOtherPos==4 && nSum==5) bFlag=true;
if(nOtherPos==1 && nSum==5) bFlag=false;
if(nOtherPos==1 && nSum==6) bFlag=true;
Steps.AddStep(nOtherPos, bFlag, 1);
Steps.AddStep(2, !bFlag, 1);
Steps.AddStep(nOtherPos, !bFlag, 1);
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c[0]);
Rubik.ChangeViewFromTopByNextColor(c[i]);
GetPos=Rubik.FindCornerCell(c[0],c[i],c[j]);
}
//Now the block has move to bottom, or alreay at bottom
CurrentStep=Steps.Count;
nSum=GetSum(GetPos)-2-2; //1st"2":Bottom; 2nd"2":Layer
if(nSum==8) Steps.AddStep(2, false, 1);
if(nSum==7) Steps.AddStep(2, true, 2);
if(nSum==5) Steps.AddStep(2, true, 1);
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
//Now the block is just under the bottom of current corner
CurrentStep=Steps.Count;
Rubik.ChangeViewToColor(c[0]);
Rubik.ChangeViewFromTopByNextColor(c[i]);
GetPos=Rubik.FindCornerCell(c[0],c[i],c[j]);
nTopPos=GetBit(GetPos,3);
nSum=GetSum(GetPos)-2-2;
if(nSum!=6)
{
//Error
return;
}
if(nTopPos==1)
{
Steps.AddStep(1, true, 1);
Steps.AddStep(2, true, 1);
Steps.AddStep(1, false, 1);
}
if(nTopPos==5)
{
Steps.AddStep(5, false, 1);
Steps.AddStep(2, false, 1);
Steps.AddStep(5, true, 1);
}
if(nTopPos==2)
{
Steps.AddStep(1, true, 1);
Steps.AddStep(2, false,1);
Steps.AddStep(1, false, 1);
Steps.AddStep(5, false, 1);
Steps.AddStep(2, true, 2);
Steps.AddStep(5, true, 1);
}
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
}
}
Rubik.ChangeViewToColor(c[0]);
}
public static void SecondLayer() throws Exception
{
int CurrentStep=Steps.Count;
int GetPos=0, cu=0,cb=0; //CU:color on under side; CB: color on back side
int Center1=0, Center2=0; //Center1, the rotate center; center2, theother center besides it
int ErrC1=0,ErrC2=0; //ErrC1 and Errc2, the border need to be fixed
int[] c=new int[6];
boolean bFlag=true, bClockWise=false;
c[0]=Rubik.Sides[0][1][1];
c[1]=Rubik.Sides[1][1][1];
c[2]=Rubik.Sides[5][1][1];
c[3]=Rubik.Sides[3][1][1];
c[4]=Rubik.Sides[4][1][1];
c[5]=Rubik.Sides[2][1][1];
//select from the buttom to move to second layer
while(bFlag)
{
bFlag=false;
ErrC1=0;
for(int i=1;i<5;i++)
{
Rubik.ChangeViewToColor(c[0]);
Rubik.ChangeViewFromTopByNextColor(c[i]);
cu=Rubik.Sides[2][1][0];
cb=Rubik.Sides[1][1][2];
if(cu!=c[5] && cb!=c[5])
{
//This one can be moved to second layer
CurrentStep=Steps.Count;
bFlag=true;
Center1=Rubik.FindCenter(cu);
Center2=Rubik.FindCenter(cb);
//Move to the opposite
if(Center1==1) Steps.AddStep(2, true, 2);
if(Center1==5) Steps.AddStep(2, false, 1);
if(Center1==4) Steps.AddStep(2, true, 1);
//Set the direction of rotate
if(Center1==1 && Center2==5) bClockWise=true;
if(Center1==1 && Center2==4) bClockWise=false;
if(Center1==5 && Center2==3) bClockWise=true;
if(Center1==5 && Center2==1) bClockWise=false;
if(Center1==3 && Center2==4) bClockWise=true;
if(Center1==3 && Center2==5) bClockWise=false;
if(Center1==4 && Center2==1) bClockWise=true;
if(Center1==4 && Center2==3) bClockWise=false;
//Start rotate
Steps.AddStep(Center1, bClockWise, 1);
Steps.AddStep(2, !bClockWise, 1);
Steps.AddStep(Center1, !bClockWise, 1);
Steps.AddStep(2, !bClockWise, 1);
Steps.AddStep(Center2, !bClockWise, 1);
Steps.AddStep(2, bClockWise, 1);
Steps.AddStep(Center2, bClockWise, 1);
//Actions
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c[0]);
break;
}
//Check if the sencond layer is ok
if(!bFlag && ErrC1==0)
{
if(Rubik.Sides[1][1][1]!=Rubik.Sides[1][0][1] || Rubik.Sides[5][1][1]!=Rubik.Sides[5][1][2])
{
ErrC1=Rubik.Sides[1][1][1];
ErrC2=Rubik.Sides[5][1][1];
}
}
}
}
//Now All the blocks in bottom has been moved to second layer
if(ErrC1>0)
{
//if there are still error blocks in second layer, move to bottom first
Rubik.RotateRealSide(ErrC1, true, 1);
Rubik.RotateRealSide(c[5], false, 1);
Rubik.RotateRealSide(ErrC1, false, 1);
Rubik.RotateRealSide(c[5], false, 1);
Rubik.RotateRealSide(ErrC2, false, 1);
Rubik.RotateRealSide(c[5], true, 1);
Rubik.RotateRealSide(ErrC2, true, 1);
Rubik.ChangeViewToColor(c[0]);
SecondLayer();
}
}
public static void BottomCross() throws Exception
{
int CurrentStep=Steps.Count;
//Change view to the bottom
int c=Rubik.Sides[2][1][1];
int b[]=new int[4];
int d[]={5,3,4,1};
Rubik.ChangeViewToColor(c);
int nSum=0, nPos=0;
b[0]=Rubik.Sides[0][0][1];
b[1]=Rubik.Sides[0][1][0];
b[2]=Rubik.Sides[0][2][1];
b[3]=Rubik.Sides[0][1][2];
for(int i=0;i<4;i++)
{
if(b[i]==c)
{
nSum++;
nPos+=d[i];
}
}
if(nSum==4) return;
if(nSum==0)
{
CurrentStep=Steps.Count;
Steps.AddStep(1, false, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, false, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(1, true, 1);
Steps.AddStep(3, false, 1);
Steps.AddStep(0, false, 1);
Steps.AddStep(5, false, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(3, true, 1);
}
if(nSum==2)
{
CurrentStep=Steps.Count;
if(nPos==4) Rubik.ChangeViewFromTop(true);
if(nPos==4 || nPos==9)
{
Steps.AddStep(1, false, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, false, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(1, true, 1);
}
else
{
if(nPos==6) Rubik.ChangeViewFromTop(false);
if(nPos==7) Rubik.ChangeViewFromTop(true);
if(nPos==5)
{
Rubik.ChangeViewFromTop(true);
Rubik.ChangeViewFromTop(true);
}
Steps.AddStep(1, false, 1);
Steps.AddStep(0, false, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(0, true, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(1, true, 1);
}
}
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c);
}
public static void BottomCorner() throws Exception
{
int CurrentStep=Steps.Count;
int c=Rubik.Sides[0][1][1];
int b[]=new int[4];
int d[]={5,3,4,1};
int Pos2[]={-1,-1};
int nSum=0, nPos=0, nFirst=0, nSecond=0;
boolean bDirect=true, bMoreTime=false;
b[0]=Rubik.Sides[0][0][2];
b[1]=Rubik.Sides[0][0][0];
b[2]=Rubik.Sides[0][2][0];
b[3]=Rubik.Sides[0][2][2];
for(int i=0;i<4;i++)
{
if(b[i]==c)
{
nSum++;
nPos=d[i];
}
else
{
if(Pos2[0]==-1) Pos2[0]=i;
else Pos2[1]=i;
}
}
if(nSum==4) return;
if(nSum==1)
{
Rubik.ChangeViewFromTopByNextColor(Rubik.Sides[nPos][1][1]);
bDirect=(Rubik.Sides[1][0][0]==c);
if(bDirect) nFirst=5;
else nFirst=3;
Steps.Clear();
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(0, bDirect, 2);
Steps.AddStep(nFirst, !bDirect, 1);
}
if(nSum==2)
{
for(int i=0;i<Pos2[0];i++) Rubik.ChangeViewFromTop(true);
bDirect=(Rubik.Sides[1][0][0]==c);
nFirst=bDirect?5:1;
nSecond=6-nFirst;
Steps.Clear();
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(nSecond, !bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
Steps.AddStep(nSecond, bDirect, 1);
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(nSecond, !bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
Steps.AddStep(nSecond, bDirect, 1);
Steps.AddStep(0, true, Pos2[1]-Pos2[0]);
Steps.AddStep(nSecond, !bDirect, 1);
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(nSecond, bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
Steps.AddStep(nSecond, !bDirect, 1);
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(nSecond, bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
}
if(nSum==0)
{
bMoreTime=true;
for(int i=0;i<4;i++)
{
if(Rubik.Sides[1][0][0]==c && Rubik.Sides[1][2][0]==c) break;
Rubik.ChangeViewFromTop(true);
}
nFirst=3;
bDirect=false;
Steps.Clear();
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(nFirst, !bDirect, 1);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(nFirst, bDirect, 1);
Steps.AddStep(0, bDirect, 2);
Steps.AddStep(nFirst, !bDirect, 1);
}
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c);
if(bMoreTime) BottomCorner();
}
public static void ThirdLayerCorner() throws Exception
{
int CurrentStep=Steps.Count;
int c=Rubik.Sides[0][1][1];
boolean bMoreTime=true;
for(int i=0;i<4;i++)
{
if(Rubik.Sides[1][0][0] == Rubik.Sides[1][2][0])
{
if(Rubik.Sides[5][2][0] == Rubik.Sides[5][2][2]) return;
else
{
bMoreTime=false;
break;
}
}
Rubik.ChangeViewFromTop(true);
}
Steps.AddStep(5, true, 1);
Steps.AddStep(3, false, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(1, true, 2);
Steps.AddStep(5, false, 1);
Steps.AddStep(3, true, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(1, true, 2);
Steps.AddStep(5, true, 2);
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c);
if(bMoreTime) ThirdLayerCorner();
}
public static void ThirdLayerCornerSnap() throws Exception
{
int c=Rubik.Sides[0][1][1];
int nBorderColor=Rubik.Sides[1][0][0];
int nCenter=Rubik.FindCenter(nBorderColor);
int CurrentStep=Steps.Count;
if(nCenter==5) Steps.AddStep(0, false, 1);
if(nCenter==3) Steps.AddStep(0, false, 2);
if(nCenter==4) Steps.AddStep(0, true, 1);
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c);
}
public static void ThirdLayerBorderSnap() throws Exception
{
int c=Rubik.Sides[0][1][1];
boolean bMoreTime=true;
boolean bDirect=true;
for(int i=0;i<4;i++)
{
if(Rubik.Sides[1][0][0] == Rubik.Sides[1][1][0])
{
if(Rubik.Sides[5][2][0] == Rubik.Sides[5][2][1]) return;
else
{
bDirect=(Rubik.Sides[5][2][1]==Rubik.Sides[4][1][1]);
bMoreTime=false;
break;
}
}
Rubik.ChangeViewFromTop(true);
}
int CurrentStep=Steps.Count;
Steps.AddStep(3, true, 2);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(4, false, 1);
Steps.AddStep(5, true, 1);
Steps.AddStep(3, true, 2);
Steps.AddStep(5, false, 1);
Steps.AddStep(4, true, 1);
Steps.AddStep(0, bDirect, 1);
Steps.AddStep(3, true, 2);
for(Steps.Index=CurrentStep;Steps.Index<Steps.Count;Steps.Index++)
{
Rubik.RotateRealSide(Steps.Color(), Steps.ClockWise(), Steps.Quarter());
}
Rubik.ChangeViewToColor(c);
if(bMoreTime) ThirdLayerBorderSnap();
}
public static int GetBit(int n, int m)
{
double nFilter=Math.pow(10.,m-1);
n=(int) Math.floor(n/nFilter);
return n%10;
}
public static int GetSum(int n)
{
int nReturn=0;
while(n>0)
{
nReturn+=n%10;
n=(n-n%10)/10;
}
return nReturn;
}
public static class Rubik
{
static int[][][] Sides=new int [7][3][3];
static int[] Position=new int[6];
public static String ImportColor(String[] SideColors)
{
try
{
int Check[]={0,0,0,0,0,0};
for(int i=0;i<6;i++)
{
String szColors=SideColors[i];
if(szColors.length()!=9) return "len(Side"+i+")="+szColors.length();
for(int j=0;j<9;j++)
{
int nColor=Color.Value(szColors.substring(j,j+1));
if(nColor==0) return "Side"+i+","+j+"="+szColors.substring(j,j+1);
int y=j%3;
int x=(j-y)/3;
Check[nColor-1]++;
Sides[i][x][y]=nColor;
if(j==4) Position[i]=nColor;
}
}
for(int i=0;i<6;i++)
{
if(Check[i]!=9) return "Check"+i+"="+Check[i];
}
return "";
}
catch(Exception e)
{
return e.getMessage();
}
}
public static void ChangeViewToColor(int nColor) throws Exception
{
int nNewCenter=-1;
for(int i=0;i<6;i++)
{
if(Sides[i][1][1]==nColor) nNewCenter=i;
}
if(nNewCenter==0) return;
if(nNewCenter==1)
{
CopyMatrics(0,6,0);
CopyMatrics(1,0,0);
CopyMatrics(2,1,0);
CopyMatrics(3,2,0);
CopyMatrics(6,3,0);
CopyMatrics(5,6,0);
CopyMatrics(6,5,1);
CopyMatrics(4,6,0);
CopyMatrics(6,4,2);
}
if(nNewCenter==2)
{
CopyMatrics(0,6,0);
CopyMatrics(2,0,0);
CopyMatrics(6,2,0);
CopyMatrics(1,6,0);
CopyMatrics(3,1,0);
CopyMatrics(6,3,0);
CopyMatrics(5,6,0);
CopyMatrics(6,5,3);
CopyMatrics(4,6,0);
CopyMatrics(6,4,3);
}
if(nNewCenter==3)
{
CopyMatrics(0,6,0);
CopyMatrics(3,0,0);
CopyMatrics(2,3,0);
CopyMatrics(1,2,0);
CopyMatrics(6,1,0);
CopyMatrics(5,6,0);
CopyMatrics(6,5,2);
CopyMatrics(4,6,0);
CopyMatrics(6,4,1);
}
if(nNewCenter==4)
{
CopyMatrics(0,6,0);
CopyMatrics(4,0,0);
CopyMatrics(2,4,3);
CopyMatrics(5,2,3);
CopyMatrics(6,5,0);
CopyMatrics(3,6,0);
CopyMatrics(6,3,2);
CopyMatrics(1,6,0);
CopyMatrics(6,1,1);
}
if(nNewCenter==5)
{
CopyMatrics(0,6,0);
CopyMatrics(5,0,0);
CopyMatrics(2,5,3);
CopyMatrics(4,2,3);
CopyMatrics(6,4,0);
CopyMatrics(3,6,0);
CopyMatrics(6,3,1);
CopyMatrics(1,6,0);
CopyMatrics(6,1,2);
}
}
public static void CopyMatrics(int A, int B, int n) throws Exception
{
//Copy from A to B
//n=0:DirectCopy 1:ClockWiseCopy 2:AntiClockCop 3:Reverse copy
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
if(n==0) Sides[B][i][j]=Sides[A][i][j];
if(n==1) Sides[B][j][2-i]=Sides[A][i][j];
if(n==2) Sides[B][2-j][i]=Sides[A][i][j];
if(n==3) Sides[B][i][j]=Sides[A][2-i][2-j];
}
}
}
public static void ChangeViewFromTopByNextColor(int nColor) throws Exception
{
int nNextColorCenter=-1;
for(int i=0;i<6;i++)
{
if(Sides[i][1][1]==nColor) nNextColorCenter=i;
}
if(nNextColorCenter==4) ChangeViewFromTop(false);
if(nNextColorCenter==5) ChangeViewFromTop(true);
if(nNextColorCenter==3)
{
ChangeViewFromTop(true);
ChangeViewFromTop(true);
}
}
public static void ChangeViewFromTop(boolean ClockWise) throws Exception
{
int Next1=3,Next2=1;
if(!ClockWise) {Next1=1;Next2=3;}
int nType=ClockWise?1:2;
CopyMatrics(0,6,0);
CopyMatrics(6,0,nType);
CopyMatrics(5,6,0);
CopyMatrics(Next1,5,nType);
CopyMatrics(4,Next1,nType);
CopyMatrics(Next2,4,nType);
CopyMatrics(6,Next2,nType);
CopyMatrics(2,6,0);
CopyMatrics(6,2,3-nType);
}
public static void RotateBottomSide(boolean ClockWise) throws Exception
{
int temp=0;
int i;
CopyMatrics(2,6,ClockWise?2:1); //Bottom ClockWise = Top Anti-ClockWise
CopyMatrics(6,2,0);
if(ClockWise)
{
for(i=0;i<3;i++)
{
temp=Sides[5][0][i];
Sides[5][0][i]=Sides[3][2-i][0];
Sides[3][2-i][0]=Sides[4][2][2-i];
Sides[4][2][2-i]=Sides[1][i][2];
Sides[1][i][2]=temp;
}
}
else
{
for(i=0;i<3;i++)
{
temp=Sides[5][0][i];
Sides[5][0][i]=Sides[1][i][2];
Sides[1][i][2]=Sides[4][2][2-i];
Sides[4][2][2-i]=Sides[3][2-i][0];
Sides[3][2-i][0]=temp;
}
}
}
public static void RotateRealSide(int nColor, boolean ClockWise, int nQuarter) throws Exception
{
//ClockWise means AntiClockWise from Top, and nCount>0 in Robot Class
int nCenter=-1;
int[] arOpposite={2,3,0,1,5,4};
for(int i=0;i<6;i++)
{
if(Position[i]==nColor) nCenter=i;
}
int nOppositeColor=Position[arOpposite[nCenter]];
if(nCenter==2)
{
//Do Nothing
}
if(nCenter==1)
{
RotatePaw();
}
if(nCenter==0)
{
RotatePaw();
RotatePaw();
}
if(nCenter==3)
{
RotateBottom(false);
RotateBottom(false);
RotatePaw();
}
if(nCenter==4)
{
RotateBottom(false);
RotatePaw();
}
if(nCenter==5)
{
RotateBottom(true);
RotatePaw();
}
ChangeViewToColor(nOppositeColor);
for(int i=0;i<nQuarter;i++)
{
RotateBottomSide(!ClockWise);
}
}
public static void RotateBottom(boolean ClockWise) throws Exception
{
if(ClockWise)
{
int n=Position[5];
Position[5]=Position[3];
Position[3]=Position[4];
Position[4]=Position[1];
Position[1]=n;
}
else
{
int n=Position[5];
Position[5]=Position[1];
Position[1]=Position[4];
Position[4]=Position[3];
Position[3]=n;
}
}
public static void RotatePaw() throws Exception
{
//Only can move forward
int n=Position[0];
Position[0]=Position[3];
Position[3]=Position[2];
Position[2]=Position[1];
Position[1]=n;
}
public static int FindCenter(int nColor) throws Exception
{
int nCenter=-1;
for(int i=0;i<6;i++)
{
if(Sides[i][1][1]==nColor) nCenter=i;
}
return nCenter;
}
public static int FindCornerCell(int Color1, int Color2, int Color3)
{
//return value=nLayer*1000+nFirstColorCenter*100+nSecondColorCenter*10+nThirdCenter
int nReturn=0;
int nCheck=Color1*100+Color2*10+Color3;
//First Layer
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[0][0][2],Sides[5][2][2],Sides[1][0][0],0,5,1);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[0][0][0],Sides[5][2][0],Sides[3][0][2],0,5,3);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[0][2][0],Sides[4][0][0],Sides[3][2][2],0,4,3);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[0][2][2],Sides[4][0][2],Sides[1][2][0],0,4,1);
if(nReturn>0) return 1000+nReturn;
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[2][0][0],Sides[5][0][2],Sides[1][0][2],2,5,1);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[2][0][2],Sides[5][0][0],Sides[3][0][0],2,5,3);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[2][2][2],Sides[4][2][0],Sides[3][2][0],2,4,3);
if(nReturn==0) nReturn=CheckCorner(nCheck,Sides[2][2][0],Sides[4][2][2],Sides[1][2][2],2,4,1);
if(nReturn>0) return 2000+nReturn;
return 0;
}
public static int CheckCorner(int CheckValue, int c1, int c2, int c3, int p1, int p2, int p3)
{
if(c1*100+c2*10+c3 == CheckValue) return p1*100+p2*10+p3;
if(c1*100+c3*10+c2 == CheckValue) return p1*100+p3*10+p2;
if(c2*100+c1*10+c3 == CheckValue) return p2*100+p1*10+p3;
if(c2*100+c3*10+c1 == CheckValue) return p2*100+p3*10+p1;
if(c3*100+c1*10+c2 == CheckValue) return p3*100+p1*10+p2;
if(c3*100+c2*10+c1 == CheckValue) return p3*100+p2*10+p1;
return 0;
}
public static int FindBorderCell(int Color1, int Color2)
{
//return value=nLayer*100+nFirstColorCenter*10+nSecondColorCenter
int nReturn=0;
int c1=0,c2=0;
//First layer
c1=Sides[0][0][1]; c2=Sides[5][2][1];
if(c1==Color1 && c2==Color2) return 105;
if(c1==Color2 && c2==Color1) return 150;
c1=Sides[0][1][0]; c2=Sides[3][1][2];
if(c1==Color1 && c2==Color2) return 103;
if(c1==Color2 && c2==Color1) return 130;
c1=Sides[0][2][1]; c2=Sides[4][0][1];
if(c1==Color1 && c2==Color2) return 104;
if(c1==Color2 && c2==Color1) return 140;
c1=Sides[0][1][2]; c2=Sides[1][1][0];
if(c1==Color1 && c2==Color2) return 101;
if(c1==Color2 && c2==Color1) return 110;
//Seconde Layer
c1=Sides[4][1][2]; c2=Sides[1][2][1];
if(c1==Color1 && c2==Color2) return 241;
if(c1==Color2 && c2==Color1) return 214;
c1=Sides[4][1][0]; c2=Sides[3][2][1];
if(c1==Color1 && c2==Color2) return 243;
if(c1==Color2 && c2==Color1) return 234;
c1=Sides[5][1][0]; c2=Sides[3][0][1];
if(c1==Color1 && c2==Color2) return 253;
if(c1==Color2 && c2==Color1) return 235;
c1=Sides[5][1][2]; c2=Sides[1][0][1];
if(c1==Color1 && c2==Color2) return 251;
if(c1==Color2 && c2==Color1) return 215;
//Third Layer
c1=Sides[4][2][1]; c2=Sides[2][2][1];
if(c1==Color1 && c2==Color2) return 342;
if(c1==Color2 && c2==Color1) return 324;
c1=Sides[1][1][2]; c2=Sides[2][1][0];
if(c1==Color1 && c2==Color2) return 312;
if(c1==Color2 && c2==Color1) return 321;
c1=Sides[5][0][1]; c2=Sides[2][0][1];
if(c1==Color1 && c2==Color2) return 352;
if(c1==Color2 && c2==Color1) return 325;
c1=Sides[3][1][0]; c2=Sides[2][1][2];
if(c1==Color1 && c2==Color2) return 332;
if(c1==Color2 && c2==Color1) return 323;
return 0;
}
}
public static class Steps
{
public static int Count=0;
public static int Index=-1;
private static int[] arColor=new int[200];
private static boolean[] arClockWise=new boolean[200];
private static int[] arQuarter=new int[200];
public static void Clear()
{
Count=0;
Index=-1;
}
public static void AddStep(int SideNum, boolean ClockWise, int Quarter)
{
arColor[Count]=Rubik.Sides[SideNum][1][1];
arClockWise[Count]=ClockWise;
arQuarter[Count]=Quarter;
Count++;
}
public static int Color()
{
return arColor[Index];
}
public static boolean ClockWise()
{
return arClockWise[Index];
}
public static int Quarter()
{
return arQuarter[Index];
}
}
public static class Color
{
public static int Y=1;
public static int B=2;
public static int R=3;
public static int W=4;
public static int O=5;
public static int G=6;
public static String Text(int n)
{
switch(n)
{
case 1:
return "Y";
case 2:
return "B";
case 3:
return "R";
case 4:
return "W";
case 5:
return "O";
case 6:
return "G";
default:
return n+"";
}
}
public static int Value(String c)
{
if(c.equals("Y")||c.equals("y")) return 1;
if(c.equals("B")||c.equals("b")) return 2;
if(c.equals("R")||c.equals("r")) return 3;
if(c.equals("W")||c.equals("w")) return 4;
if(c.equals("O")||c.equals("o")) return 5;
if(c.equals("G")||c.equals("g")) return 6;
return 0;
}
}
}
代码
