def deface_unsolved_faced_corner(cube, facetosolve, ccolor): cornerrowcells = jbrik_cube.get_cornercell_rowcells_for_face(facetosolve) for cornerrowcell in cornerrowcells: if cube.get_cell_val_by_rowcell( cornerrowcell) == ccolor and not is_crosscorner_solved( (cube, cornerrowcell)): log_utils.log(cornerrowcell + " is faced but not solved") defacemovestrset = jbrik_cube.get_solveface_corner_oppfaceorbit_trans( cornerrowcell) defacemove = defacemovestrset.split(" ")[0] defaceunwindmove = jbrik_solver_move_lib.reversetransition( defacemove) o2move = defacemovestrset.split(" ")[1] log_utils.log("Moving: " + defacemove + " to move " + cornerrowcell + " off solve face.") cube = jbrik_solver_move_lib.perform_rotation_str(defacemove, cube) log_utils.log("Moving: " + o2move + " to move " + cornerrowcell + " out of unwind move") cube = jbrik_solver_move_lib.perform_rotation_str(o2move, cube) log_utils.log("Moving: " + defaceunwindmove) cube = jbrik_solver_move_lib.perform_rotation_str( defaceunwindmove, cube) break return cube
def move_solveface_orbitcells_to_oppface(cube, solveface, ccolor): solvefaceorbits = jbrik_cube.FACEORBITS[solveface] for orbitrowcell in solvefaceorbits: log_utils.log("Checking solveface orbit rowcell: " + orbitrowcell + " for needed transitions.") if cube.get_cell_val_by_rowcell(orbitrowcell) == ccolor: rotfacedir = jbrik_cube.get_solvefacefaceorbit_o2_trans( orbitrowcell) rotface = rotfacedir[0] rotdir = rotfacedir[1:3] rotstr = rotfacedir + "1" unwindmove = jbrik_solver_move_lib.reversetransition(rotstr) log_utils.log("Rotate face: " + rotface.__str__() + " " + rotdir + " to move it to opposite solve face.") cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) oppface = jbrik_cube.OPPOSITEFACES[solveface] rotstr = oppface.__str__() + "CW1" log_utils.log("Rotate oppface: " + rotstr + " to move target cell<???> out of the way of unwind") cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) log_utils.log("Performing unwind: " + unwindmove) cube = jbrik_solver_move_lib.perform_rotation_str(unwindmove, cube) break return cube
def solvecrosscorner_o2(cube, solverowcell, oppface): log_utils.log("Performing 2nd order crosscorner solve for: " + solverowcell) rotmstrset = jbrik_cube.get_oppfaceorbit_o2_trans(solverowcell) rotstr1 = rotmstrset.split(" ")[0] rotstr2 = rotmstrset.split(" ")[1] log_utils.log("Rotate face: " + rotstr1 + " to put " + solverowcell + " into position to align with solveface.") cube = jbrik_solver_move_lib.perform_rotation_str(rotstr1, cube) unwindmove1 = jbrik_solver_move_lib.reversetransition(rotstr1) log_utils.log("Rotate face: " + rotstr2 + " to put " + solverowcell + " to align with solveface.") cube = jbrik_solver_move_lib.perform_rotation_str(rotstr2, cube) unwindmove2 = jbrik_solver_move_lib.reversetransition(rotstr2) log_utils.log("Rotate face: " + unwindmove1 + " to unwind first transition") cube = jbrik_solver_move_lib.perform_rotation_str(unwindmove1, cube) log_utils.log("Rotate face: " + unwindmove2 + " to unwind second transition") cube = jbrik_solver_move_lib.perform_rotation_str(unwindmove2, cube) return cube
def facecross_o1(cube, ccolor, facetosolve, atomic=False): startsolvelen = -1 while cube.get_current_solve_move_list().__len__() != startsolvelen: startsolvelen = cube.get_current_solve_move_list().__len__() log_utils.log("Checking for 1st order face transitions for face: " + facetosolve.__str__()) # check for first order moves for rowcell in jbrik_cube.get_cross_rowcell_for_face(facetosolve): log_utils.log("Checking state of " + rowcell) if cube.get_cell_val_by_rowcell(rowcell) == ccolor: log_utils.log(rowcell + " is faced.\n") continue #can replace some of this solvestr = get_facestr_for_cross_rowcell(rowcell, ccolor, cube) if solvestr != "" and solvestr is not None: log_utils.log(rowcell + " is solved by: " + solvestr) log_utils.log("Solve move list: " + cube.get_current_solve_move_list().__str__()) cube = jbrik_solver_move_lib.perform_rotation_str( solvestr, cube) if atomic: return cube else: log_utils.log("No first order solution for " + rowcell + "\n") log_utils.log("Start solve length: " + startsolvelen.__str__() + " solvelist length: " + cube.get_current_solve_move_list().__len__().__str__() + "\n") cube.print_cube("", True) return cube
def perform_lr_solve_on_cross_rowcell(facetosolve, crossrowcell, cube): crossrowcellcolor = cube.get_cell_val_by_rowcell(crossrowcell) adjrowcell = jbrik_cube.get_adjrowccell_for_rowcell(crossrowcell) adjrowcellcolor = cube.get_cell_val_by_rowcell(adjrowcell) adjrowcellcolorccolor = cube.get_center_color_for_rowcell(adjrowcell) # if this rowcell is already aligned with adjacent color same as center color if adjrowcellcolor == adjrowcellcolorccolor: adjrowcell = jbrik_cube.get_adjrowccell_for_rowcell(crossrowcell) lrrowcells = jbrik_cube.get_oppface_centerrowcell_lr_middle_destcells( crossrowcell) lcrossrowcell = lrrowcells.split(" ")[0] rcrossrowcell = lrrowcells.split(" ")[1] lcrossccolor = cube.get_center_color_for_rowcell(lcrossrowcell) rcrossccolor = cube.get_center_color_for_rowcell(rcrossrowcell) if crossrowcellcolor == lcrossccolor: log_utils.log("Perform an L cross solve on: " + crossrowcell) solutionlist = get_lrcross_solution_list(facetosolve, lcrossrowcell, adjrowcell, "L") for lmove in solutionlist: cube = jbrik_solver_move_lib.perform_rotation_str(lmove, cube) if not is_middle_rowcell_solved(lcrossrowcell, cube): cube = swap_backwards_oriented_mid_rowcell( facetosolve, lcrossrowcell, "swap", cube) elif crossrowcellcolor == rcrossccolor: log_utils.log("Perform a R cross solve on: " + crossrowcell) solutionlist = get_lrcross_solution_list(facetosolve, rcrossrowcell, adjrowcell, "R") for rmove in solutionlist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) if not is_middle_rowcell_solved(rcrossrowcell, cube): cube = swap_backwards_oriented_mid_rowcell( facetosolve, rcrossrowcell, "swap", cube) return cube
def swap_backwards_oriented_mid_rowcell(facetosolve, rowcell, swaptype, cube): rowcellcolor = cube.get_cell_val_by_rowcell(rowcell) rowcellccolor = cube.get_center_color_for_rowcell(rowcell) adjrowcell = jbrik_cube.get_adjrowccell_for_rowcell(rowcell) adjrowcellcolor = cube.get_cell_val_by_rowcell(adjrowcell) adjrowcellccolor = cube.get_center_color_for_rowcell(adjrowcell) # check orientation if rowcellcolor == adjrowcellccolor and adjrowcellcolor == rowcellccolor: log_utils.log("Rowcell: " + rowcell + " is backwards oriented, swapping.") if jbrik_cube.FIVESIXMIDROWCROSSROWCELLS_L.__contains__(rowcell): # its a leftswap #movestrlist = get_leftcross_solution_list(facetosolve, adjrowcell, rowcell) movestrlist = get_lrcross_solution_list(facetosolve, adjrowcell, rowcell, "L") log_utils.log("leftswap " + swaptype + " rowcell: " + rowcell + " of color: " + rowcellccolor + " and adjacent cell: " + adjrowcell + " with color: " + adjrowcellcolor) else: # its a rightswap #movestrlist = get_rightcross_solution_list(facetosolve, adjrowcell, rowcell) movestrlist = get_lrcross_solution_list(facetosolve, adjrowcell, rowcell, "R") log_utils.log("Rightswap " + swaptype + " rowcell: " + rowcell + " of color: " + rowcellccolor + " and adjacent cell: " + adjrowcell + " with color: " + adjrowcellcolor) for rmove in movestrlist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) cube = jbrik_solver_move_lib.perform_rotation_str("3CW2", cube) if swaptype != "back": for rmove in movestrlist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) return cube
def facecross_o2(cube, ccolor, facetosolve): log_utils.log("Checking for 2nd order face transitions for face: " + facetosolve.__str__()) opptosolveface = jbrik_cube.OPPOSITEFACES[facetosolve] log_utils.log("Face: " + opptosolveface.__str__() + " is opposite to the solving face.") o2inposition = False for rowcell in jbrik_cube.get_cross_rowcell_for_face(opptosolveface): if cube.get_cell_val_by_rowcell(rowcell) == ccolor: log_utils.log(rowcell + " is a second order facing transition.") #identify the first cell that isn't faced for facecell in jbrik_cube.get_cross_rowcell_for_face(facetosolve): log_utils.log("Checking state of " + facecell) if cube.get_cell_val_by_rowcell(facecell) != ccolor: log_utils.log(facecell + " is not faced, move " + rowcell + " here.\n") for crosscell in jbrik_cube.get_cross_rowcell_for_face( opptosolveface): adjfaceforrowcell = jbrik_cube.get_adj_face_for_rowcell( crosscell) if adjfaceforrowcell == jbrik_cube.get_adj_face_for_rowcell( facecell): log_utils.log("Rotate face: " + opptosolveface.__str__() + " until " + crosscell + " is " + ccolor) break rotcount = 0 while cube.get_cell_val_by_rowcell(crosscell) != ccolor: rotcount = rotcount + 1 cube = jbrik_solver_move_lib.perform_rotation_str( opptosolveface.__str__() + "CW1", cube, False) if rotcount > 0: movestr = opptosolveface.__str__( ) + "CW" + rotcount.__str__() log_utils.log("Perform transition: " + movestr) cube.get_current_solve_move_list().append(movestr) cube.print_cube() o2inposition = True break cube = facecross_o1(cube, ccolor, facetosolve) if o2inposition: break log_utils.log("No more second order transitions for face: " + facetosolve.__str__()) return cube
def face_oppface_cross(cube): log_utils.log("Positioning opposite face cross.") facetosolve = 3 ccolor = cube.get_center_color_for_facenum(facetosolve) faced = False while not faced: #determine count of faced crosscells facedcelllist = [] crosscells = jbrik_cube.get_cross_rowcell_for_face(facetosolve) for crosscell in crosscells: if cube.get_cell_val_by_rowcell(crosscell) == ccolor: facedcelllist.append(crosscell) if facedcelllist.__len__() == 4: faced = True break alignmenttype = "0" tface = facetosolve.__str__() fface = "6" rface = "4" if facedcelllist.__len__() > 1: facedcelllist.sort() log_utils.log("Solved cells: " + facedcelllist.__str__()) solvedcells = facedcelllist[0] + " " + facedcelllist[1] facemap = jbrik_cube.OPPFACECELL_RFACE_CENTER_ALIGN_MAP[solvedcells] alignmenttype = facemap.split(" ")[0] tface = facetosolve.__str__() fface = facemap.split(" ")[1].__str__() rface = facemap.split(" ")[2].__str__() # start anywhere with 0 or line if alignmenttype != "V": log_utils.log("Performing line movelist.") # F R U R' U' F' movelist = [fface + "CW1", rface + "CW1", tface + "CW1", rface + "CC1", tface + "CC1", fface + "CC1"] else: # align v to left/top for frontface log_utils.log("Performing shortcut V movelist.") # F U R U' R' F' movelist = [fface + "CW1", tface + "CW1", rface + "CW1", tface + "CC1", rface + "CC1", fface + "CC1"] for rmove in movelist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) cube.finalize_solve_phase(4,) log_utils.log("Opposite face cross positioned") return cube
def swap_non_oriented_mid_rowcells_to_top(facetosolve, cube): # change this to get all mid row cells for rowcell in jbrik_cube.MIDDLE_ROWCCELLS: rowcellcolor = cube.get_cell_val_by_rowcell(rowcell) rowcellccolor = cube.get_center_color_for_rowcell(rowcell) adjrowcell = jbrik_cube.get_adjrowccell_for_rowcell(rowcell) adjrowcellcolor = cube.get_cell_val_by_rowcell(adjrowcell) adjrowcellccolor = cube.get_center_color_for_rowcell(adjrowcell) ccolor = cube.get_center_color_for_facenum(facetosolve) if (rowcellcolor != rowcellccolor and adjrowcellcolor != adjrowcellccolor and rowcellcolor != ccolor and adjrowcellcolor != ccolor) \ or (rowcellcolor == rowcellccolor and adjrowcellcolor == ccolor): log_utils.log( "Rowcell: " + rowcell + " is either a total missalign or solved by an LR swap, with " "cell color: " + rowcellcolor + " and adjacent color: " + adjrowcellcolor) movedir = jbrik_cube.get_centerrow_orbit_trans_dir(rowcell) # get middle cell in the direction of movement and if it's solved skip this transition midlrs = jbrik_cube.MIDDLE_ROWCCELLS_LR_ADJ[rowcell] movestrlist = "" if movedir == "L": if is_middle_rowcell_solved(midlrs.split(" ")[0], cube): return cube movestrlist = get_lrcross_solution_list( facetosolve, adjrowcell, rowcell, "L") else: if is_middle_rowcell_solved(midlrs.split(" ")[1], cube): return cube movestrlist = get_lrcross_solution_list( facetosolve, adjrowcell, rowcell, "R") movestrlist.append(facetosolve.__str__() + "CW2") # one time put is in the right place but reverse for i in range(0, 3): for rmove in movestrlist: cube = jbrik_solver_move_lib.perform_rotation_str( rmove, cube) return cube return cube
def align_oppface_crossrowcell_to_adj_ccolor(facetosolve, cube): oppfacecrossrowcells = jbrik_cube.get_cross_rowcell_for_face(facetosolve) for crossrowcell in oppfacecrossrowcells: ccolor = cube.get_center_color_for_facenum(facetosolve) rowcellcolor = cube.get_cell_val_by_rowcell(crossrowcell) adjrowcell = jbrik_cube.get_adjrowccell_for_rowcell(crossrowcell) adjrowcellcolor = cube.get_cell_val_by_rowcell(adjrowcell) adjrowcellccolor = cube.get_center_color_for_rowcell(adjrowcell) # will be an issue here if all adjcell have ccolor if adjrowcellcolor == ccolor or rowcellcolor == ccolor: continue # if crossrowcellcolor is not facetosolve ccolor then it must be one of the adj ccolors testrowcell = adjrowcell testrowcellccolor = adjrowcellccolor rotcount = 0 while adjrowcellcolor != testrowcellccolor: if rotcount > 3: log_utils.log("No solveface alignment.") return cube log_utils.log( "Rotate face: " + facetosolve.__str__() + " CW1 and check for match to adjacent face center color.") rotcount = rotcount + 1 testrowcell = jbrik_cube.get_dest_pos_for_face_rotation( testrowcell, facetosolve.__str__() + "CW1") testrowcellccolor = cube.get_center_color_for_rowcell(testrowcell) # we've idetified a match, rotate here if rotcount > 0: rotstr = facetosolve.__str__() + "CW" + rotcount.__str__() log_utils.log("Perform transition: " + rotstr) cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) adjtestrowcell = jbrik_cube.get_adjrowccell_for_rowcell( testrowcell) log_utils.log("Solveface orbit rowcell: " + adjtestrowcell + " of color: " + adjrowcellcolor + " is aligned for LR check.") cube = perform_lr_solve_on_cross_rowcell(facetosolve, adjtestrowcell, cube) return cube return cube
def position_oppface_corners(cube): log_utils.log("Positioning oppface corners.") facetosolve = 3 solved = False while not solved: positionedrowcell = "" cornercelladjfacelist = [] # identify a corner thats positioned correctly, 3 face colors sorted = 3 center colors sorted for cornerrowcell in jbrik_cube.get_cornercell_rowcells_for_face(facetosolve): if is_corner_positioned(cornerrowcell, cube): log_utils.log("Rowcell: " + cornerrowcell + " is positioned correctly.") positionedrowcell = cornerrowcell break # orient so that this corner is front top right, we can map this, # nothing is positioned do algo on any random corner cornercelladjfacelist = jbrik_cube.OPPFACE_CELL_FACE_MAP.get("7.1") if positionedrowcell != "": # otherwise do it the positioned corner cornercelladjfacelist = jbrik_cube.OPPFACE_CELL_FACE_MAP[positionedrowcell] log_utils.log("Adjacent faces for " + positionedrowcell + ": " + cornercelladjfacelist.__str__()) # if 7.1 f=2, t=3, l=5, r=6 tface = facetosolve.__str__() fface = cornercelladjfacelist[0].__str__() lface = cornercelladjfacelist[2].__str__() rface = cornercelladjfacelist[3].__str__() # perform this algorith # URU'L'UR'U'L movelist = [tface + "CW1", rface + "CW1", tface + "CC1", lface + "CC1", tface + "CW1", rface + "CC1", tface + "CC1", lface + "CW1"] log_utils.log("Constructed movelist: " + movelist.__str__()) for rmove in movelist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) # will only take 3 cycles because only 2 possible states # no corner positioned = 2 cycles # 1 corner positioned = 1 cycles # 4 corners positioned = no cycles if are_all_corners_positioned(facetosolve, cube): solved = True cube.finalize_solve_phase(6,) log_utils.log("Opposite face corners positioned") return cube
def move_oppfaceorbit_rowcells_into_o2_and_solve(cube, oppface, ccolor): oppfaceorbit = jbrik_cube.FACEORBITS[oppface] # identify first, if any rowcells are solvable on oppface orbit log_utils.log("Looking for " + ccolor + " rowcell on opp face orbit") for rowcell in oppfaceorbit: if cube.get_cell_val_by_rowcell(rowcell) == ccolor: log_utils.log(rowcell + " is on opp face orbit and is " + ccolor) rotstr = get_movestr_to_move_rowcell_to_o2_solve_pos( cube, rowcell, oppface) destrowcell = rowcell if rotstr != "": destradjowcell = jbrik_cube.get_non_oppface_adj_rowcell_for_corner( destrowcell, oppface) destrowcell = jbrik_cube.get_dest_pos_for_face_rotation( destradjowcell, rotstr) destradjowcell = jbrik_cube.get_non_oppface_adj_rowcell_for_corner( destrowcell, oppface) cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) log_utils.log(destradjowcell + " is in 2nd order solve position.") cube = solvecrosscorner_o2(cube, destradjowcell, oppface) else: log_utils.log(destrowcell + " is in 2nd order solve position.") cube = solvecrosscorner_o2(cube, destrowcell, oppface) # recurse cube = move_oppfaceorbit_rowcells_into_o2_and_solve( cube, oppface, ccolor) return cube
def solve_oppface_corners(cube): log_utils.log("Solving opposite face corners.") facetosolve = 3 ccolor = cube.get_center_color_for_facenum(facetosolve) solved = False while not solved: unsolvedcornerlist = [] for cornerrowcell in jbrik_cube.get_cornercell_rowcells_for_face( facetosolve): if not is_corner_solved(cornerrowcell, ccolor, cube): unsolvedcornerlist.append(cornerrowcell) if unsolvedcornerlist.__len__() != 0: unsolvedcornerlist.sort() if unsolvedcornerlist.__len__() == 4: unsolvedcorners = unsolvedcornerlist[ 0] + " " + unsolvedcornerlist[1] + " " + unsolvedcornerlist[ 2] + " " + unsolvedcornerlist[3] elif unsolvedcornerlist.__len__() == 3: unsolvedcorners = unsolvedcornerlist[ 0] + " " + unsolvedcornerlist[ 1] + " " + unsolvedcornerlist[2] elif unsolvedcornerlist.__len__() == 2: unsolvedcorners = unsolvedcornerlist[ 0] + " " + unsolvedcornerlist[1] elif unsolvedcornerlist.__len__() == 1: print("investigate this case") # orient so that (top) oppface front right corner is unsolved (as well as the front left corner) if you can get both # find right hand face for solved rowcell combo tface = facetosolve.__str__() bface = "1" rface = jbrik_cube.OPPFACECELL_RFACE_CORNER_ALIGN_MAP[ unsolvedcorners].split(" ")[0].__str__() cornertosolve = jbrik_cube.OPPFACECELL_RFACE_CORNER_ALIGN_MAP[ unsolvedcorners].split(" ")[1] # special case where solved rows are opposites if unsolvedcorners == "7.1 9.3" or unsolvedcorners == "7.3 9.1": # rotate once to move unsolved corner into top/front/right cube = jbrik_solver_move_lib.perform_rotation_str( tface + "CW1", cube) # do this algo 2, check for solve # if not solved, 2 more times # rotate top until next unsolved corner is in front top right # (R' D' R D) x2/4 + u inbetween and after movelist = [ rface + "CC1", bface + "CC1", rface + "CW1", bface + "CW1" ] for i in range(0, unsolvedcornerlist.__len__()): # after 2 check for solve, attemptcount = 0 while not is_corner_solved(cornertosolve, ccolor, cube) and attemptcount < 2: cube = attempt_corner_solve(movelist, cube) attemptcount += 1 if are_all_corners_solved(cube, facetosolve): # final rotation cube = jbrik_solver_move_lib.perform_rotation_str( tface + "CW1", cube) break # rotate until next unsolved is in top/front/right, never more than 2 turns attemptcount = 0 while is_corner_solved(cornertosolve, ccolor, cube) and attemptcount < 2: cube = jbrik_solver_move_lib.perform_rotation_str( tface + "CW1", cube) attemptcount += 1 else: solved = True cube.finalize_solve_phase(7, ) log_utils.log("Opposite face corners solved.") return cube
def facecross_o3(cube, ccolor, facetosolve): unwindlist = [] resultpos = "" # identify the next rowcell that needs to be faced for rowcelltoface in jbrik_cube.get_cross_rowcell_for_face(facetosolve): log_utils.log("Checking state of " + rowcelltoface) if cube.get_cell_val_by_rowcell(rowcelltoface) != ccolor: log_utils.log(rowcelltoface + " is the rowcell to face.\n") resultpos = rowcelltoface break if resultpos == "": log_utils.log("No more cross positions to face on face: " + facetosolve.__str__()) return cube # identify the first rowcell we can move into resultpos opptosolveface = jbrik_cube.OPPOSITEFACES[facetosolve] rowcelltomove = "" for facenum in range(1, 7): log_utils.log("Checking face: " + facenum.__str__() + " for cross cells that can face: " + resultpos) if facenum == facetosolve or facenum == opptosolveface: log_utils.log("Skipping solve/opp face: " + facenum.__str__()) continue rowcelltomove = get_centerrowcell_of_color_from_face( cube, facenum, ccolor) if rowcelltomove != "": break # rotate rowcell into middle row if needed by checking if CW rotation puts rowcelltomove adj oppface or solveface if rowcelltomove != "": rotdir = "CW" rotface = jbrik_cube.get_face_for_rowcell(rowcelltomove) nextpos = jbrik_cube.get_next_centerpos_for_face_rotation( rotface, rowcelltomove) resultposadjface = jbrik_cube.get_adj_face_for_rowcell(resultpos) # if nextpos is not adj to oppface or solveface we want to go there rowcelladjtonextpos = jbrik_cube.get_adjrowccell_for_rowcell(nextpos) nextposadjface = jbrik_cube.get_face_for_rowcell(rowcelladjtonextpos) if nextposadjface != opptosolveface and nextposadjface != facetosolve: # first align resultpos to to the face we want to rotate rotcount = 0 while cube.get_cell_val_by_rowcell(resultpos) == ccolor: rotcount = rotcount + 1 cube = jbrik_solver_move_lib.perform_rotation_str( facetosolve.__str__() + "CW1", cube, False) if rotcount > 0: movestr = facetosolve.__str__() + "CW" + rotcount.__str__() log_utils.log("Perform transition: " + movestr) cube.get_current_solve_move_list().append(movestr) rotface = jbrik_cube.get_face_for_rowcell(rowcelltomove) log_utils.log("Rotating face: " + rotface.__str__() + " " + "CW1 to move: " + rowcelltomove + " into position: " + nextpos + " for next rotation to opposite face.") movestr = rotface.__str__() + "CW1" cube = jbrik_solver_move_lib.perform_rotation_str(movestr, cube) rowcelltomove = nextpos # Were in the middle row at this point and in o1 position, either use an o1 transition or use a static move set to find face and move if nextposadjface == resultposadjface: log_utils.log("Rowcell: " + nextpos + " is in first order solve position for: " + resultpos) o1move = jbrik_cube.get_crosscenter_solvface_trans(nextpos) cube = jbrik_solver_move_lib.perform_rotation_str(o1move, cube) return cube # we're in o2 position (solveface rotation) but a non midrow because we're on a 4/6 face if jbrik_cube.FIVESIXMIDROWCROSSROWCELLS.__contains__(rowcelltomove): log_utils.log( rowcelltomove + " is an o2 position but non mid row because it on a 4/6 face") nextposmovestr = jbrik_cube.get_crosscenter_solvface_trans( rowcelltomove) resultpos = jbrik_cube.get_dest_pos_for_face_rotation( rowcelltomove, nextposmovestr) rotcount = 0 while cube.get_cell_val_by_rowcell(resultpos) == ccolor: rotcount = rotcount + 1 cube = jbrik_solver_move_lib.perform_rotation_str( facetosolve.__str__() + "CW1", cube, False) if rotcount > 0: movestr = facetosolve.__str__() + "CW" + rotcount.__str__() log_utils.log("Performed transition: " + movestr) cube.get_current_solve_move_list().append(movestr) # resultpos is now ready to be faced cube = jbrik_solver_move_lib.perform_rotation_str( nextposmovestr, cube) return cube # we're in a middle row but a non o1 position rotate a non face position into the dest cell for nextpos if rowcelltomove != opptosolveface and rowcelltomove != facetosolve: # identify the destination of the next nextpos rotation nextposmovestr = jbrik_cube.get_crosscenter_solvface_trans( rowcelltomove) resultpos = jbrik_cube.get_dest_pos_for_face_rotation( rowcelltomove, nextposmovestr) rotcount = 0 while cube.get_cell_val_by_rowcell(resultpos) == ccolor: rotcount = rotcount + 1 cube = jbrik_solver_move_lib.perform_rotation_str( facetosolve.__str__() + "CW1", cube, False) if rotcount > 0: movestr = facetosolve.__str__() + "CW" + rotcount.__str__() log_utils.log("Perform transition: " + movestr) cube.get_current_solve_move_list().append(movestr) # resultpos is now ready to be faced cube = jbrik_solver_move_lib.perform_rotation_str( nextposmovestr, cube) return cube # we're on the oppface orbit, # rotate solveface until rowcelltomove and rowcelltoface share an adjface # rotate the adjface until rowcelltoface is ccolor, might be a transition for this get_facetrans_to_resultin_rowcell(rowcelltomove) print(" if we made it this far nextpos is on oppface orbit??") print("should never get here eject") return cube
def solve_crossoppface_orbits(cube): facetosolve = 3 solved = False while not solved: crosscells = jbrik_cube.get_cross_rowcell_for_face(facetosolve) solvedcells = [] for crosscell in crosscells: if not is_rowcell_solved(facetosolve, crosscell, cube): tface = facetosolve.__str__() # a CW rotation is a leftshift if is_nextpos_solved_by_rowcell(facetosolve, crosscell, cube): log_utils.log("A leftshift of rowcell: " + crosscell + " solves the next pos.") # "0.0": ["f", "l", "r"], facemap = jbrik_cube.OPPFACE_CENTERCELL_FACEMAP[crosscell] rface = facemap[2].__str__() # R U R' U R U2 R' U movelist = [ rface + "CW1", tface + "CW1", rface + "CC1", tface + "CW1", rface + "CW1", tface + "CW2", rface + "CC1", tface + "CW1", ] for move in movelist: cube = jbrik_solver_move_lib.perform_rotation_str( move, cube) elif is_180pos_solved_by_rowcell(facetosolve, crosscell, cube): log_utils.log("A 180shift of rowcell: " + crosscell + " solves the 180 pos.") #destrowcell = jbrik_cube.get_oneeightydswap_targetcell(crosscell) destrowcell = jbrik_cube.get_ninetydswap_targetcell( crosscell, "CW") facemap = jbrik_cube.OPPFACE_CENTERCELL_FACEMAP[ destrowcell] rface = facemap[2].__str__() # first a CW1 before calculating faces cube = jbrik_solver_move_lib.perform_rotation_str( tface + "CW1", cube) movelist = [ rface + "CW1", tface + "CW1", rface + "CC1", tface + "CW1", rface + "CW1", tface + "CW2", rface + "CC1", tface + "CW1", ] for move in movelist: cube = jbrik_solver_move_lib.perform_rotation_str( move, cube) destrowcell = jbrik_cube.get_oneeightydswap_targetcell( destrowcell) facemap = jbrik_cube.OPPFACE_CENTERCELL_FACEMAP[ destrowcell] rface = facemap[2].__str__() movelist = [ rface + "CW1", tface + "CW1", rface + "CC1", tface + "CW1", rface + "CW1", tface + "CW2", rface + "CC1", tface + "CW1", ] for move in movelist: cube = jbrik_solver_move_lib.perform_rotation_str( move, cube) else: solvedcells.append(crosscell) if solvedcells.__len__() == 4: solved = True cube.finalize_solve_phase(5, ) log_utils.log("Opposite face cross solved") return cube
def move_oppface_corner_into_oppfaceorbit(cube, oppface, ccolor): # we know solveface is one because we're solving the cross, could dynamically figure out though using oppface solveface = 1 oppfaceorbit = jbrik_cube.FACEORBITS[oppface] oppfacecornerrowcells = jbrik_cube.get_cornercell_rowcells_for_face( oppface) solvefacecornerrowcells = jbrik_cube.get_cornercell_rowcells_for_face( solveface) unsolvedcorner = "" unsolvedadjfaces = [] # identify first unsolved corner on solveface for solverowcell in solvefacecornerrowcells: if not is_crosscorner_solved((cube, solverowcell)): log_utils.log(solverowcell + " is not solved") unsolvedcorner = solverowcell solverowcelladjcells = jbrik_cube.get_adjrowccell_for_rowcell( solverowcell) for solveadjrowcell in solverowcelladjcells: unsolvedadjfaces.append( jbrik_cube.get_face_for_rowcell(solveadjrowcell)) unsolvedadjfaces.sort() if unsolvedcorner != "": break # get first cccolor cell on oppface for rowcell in oppfacecornerrowcells: if cube.get_cell_val_by_rowcell(rowcell) == ccolor: log_utils.log("Move : " + rowcell + " to opposite face orbit.") adjcell = jbrik_cube.get_non_oppface_adj_rowcell_for_corner( rowcell, oppface) # before determining rotface move rowcell to under unsolved corner # rotate oppface unit rowcell shares the same adjfaces as solveadjrowcell for oppfacecornerrowcell in oppfacecornerrowcells: destrowcelladjfaces = [] destrowcelladjrowcells = jbrik_cube.get_adjrowccell_for_rowcell( oppfacecornerrowcell) for destrowcelladjrowcell in destrowcelladjrowcells: destrowcelladjfaces.append( jbrik_cube.get_face_for_rowcell(destrowcelladjrowcell)) destrowcelladjfaces.sort() if destrowcelladjfaces == unsolvedadjfaces: break log_utils.log("Rotate face: " + oppface.__str__() + " until " + oppfacecornerrowcell + " is color: " + ccolor) rotcount = 0 destrowcell = rowcell while destrowcell != oppfacecornerrowcell: destrowcell = jbrik_cube.get_next_pos_for_face_rotation( oppface, destrowcell) rotcount += 1 rotstr = oppface.__str__() + "CW" + rotcount.__str__() if rotcount > 0: cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) # pick a face to rotate, doesn't matter which because oppfacecornerrowcell is under an unsolved rowcell rotface = unsolvedadjfaces[0] # rotface need to be the face that puts the unsolved corner onto the orbit rotdir = "CW" # try CW rotation destrowcell = jbrik_cube.get_next_pos_for_face_rotation( rotface, oppfacecornerrowcell) if not oppfaceorbit.__contains__(destrowcell): rotdir = "CC" rotstr = rotface.__str__() + rotdir + "1" unwindmove = jbrik_solver_move_lib.reversetransition(rotstr) log_utils.log( "Rotate face: " + rotstr + " to put target<??> into position for 2nd order solve.") cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) log_utils.log( "Rotate face: " + oppface.__str__() + " 180 to move target<??> out of the way of the unwind move: " + unwindmove) rotstr = oppface.__str__() + rotdir + "2" cube = jbrik_solver_move_lib.perform_rotation_str(rotstr, cube) log_utils.log("Performing unwind: " + unwindmove) cube = jbrik_solver_move_lib.perform_rotation_str(unwindmove, cube) return cube
def attempt_corner_solve(movelist, cube): for i in range(0, 2): for rmove in movelist: cube = jbrik_solver_move_lib.perform_rotation_str(rmove, cube) return cube