initial commit

eolr.py

@@ -0,0 +1,126 @@
+from dataclasses import dataclass
+from enum import Enum
+import itertools
+from typing import List, Tuple, Iterator
+from cube import Edge, LSECube
+
+
+class EOLROrientation(Enum):
+    Arrow = ["UR", "UF", "UL", "DF"]
+    BackArrow = ["UR", "UF", "UL", "DB"]
+    FourZero = ["UB", "UR", "UF", "UL"]
+    OneOne = ["UB", "DF"]
+    BackOneOne = ["UB", "DB"]
+    SixFlip = ["UB", "UR", "UF", "UL", "DF", "DB"]
+    Solved = []
+    TwoAdjTwo = ["UB", "UR", "DF", "DB"]
+    TwoAdjZero = ["UB", "UR"]
+    TwoOppTwo = ["UB", "UF", "DF", "DB"]
+    TwoOppZero = ["UB", "UF"]
+    ZeroTwo = ["DF", "DB"]
+
+
+@dataclass
+class EOLRPermutation:
+    UR: str
+    UL: str
+
+
+EOLR_PERMUTATIONS = [
+    EOLRPermutation(ur_pos, ul_pos)
+    for ul_pos, ur_pos in itertools.permutations(
+        ["UB", "UR", "UF", "UL", "DF", "DB"], 2
+    )
+]
+
+
+EOLR_EDGES = [
+    "UB",
+    "UR",
+    "UF",
+    "UL",
+    "DF",
+    "DB",
+]
+
+
+def apply_eolr_orientation(cube: LSECube, ori: EOLROrientation):
+    for edge in ori.value:
+        cube.edges[edge].oriented = not cube.edges[edge].oriented
+
+
+def apply_eolr_permutation(cube: LSECube, perm: EOLRPermutation):
+    cube.edges[perm.UR], cube.edges["UR"] = cube.edges["UR"], cube.edges[perm.UR]
+    cube.edges[perm.UL], cube.edges["UL"] = cube.edges["UL"], cube.edges[perm.UL]
+
+
+def apply_eolr_auf(cube: LSECube, auf: int):
+    cube.cycle_corners(auf)
+
+
+def eolrb_states_generator(
+    orientations: List[EOLROrientation], permutations: List[EOLRPermutation]
+) -> Tuple[Iterator[Tuple[LSECube, EOLROrientation, EOLRPermutation, int]], int]:
+    num_permutations = len(orientations) * len(permutations) * 4
+
+    def generator():
+        for ori in orientations:
+            for perm in permutations:
+                for auf in range(4):
+                    state = LSECube()
+                    apply_eolr_auf(state, auf)
+                    apply_eolr_orientation(state, ori)
+                    apply_eolr_permutation(state, perm)
+                    yield (state, ori, perm, auf)
+
+    return generator(), num_permutations
+
+
+def lr_solved(cube: LSECube):
+    return cube.edges["UR"] == Edge("UR", True) and cube.edges["UL"] == Edge("UL", True)
+
+
+def eo_solved_non_mc(cube: LSECube) -> bool:
+    return (
+        cube.edges["UB"].oriented
+        and cube.edges["UF"].oriented
+        and cube.edges["DF"].oriented
+        and cube.edges["DB"].oriented
+    )
+
+
+def centers_solved_non_mc(cube: LSECube) -> bool:
+    return cube.centers["U"] in ["U", "D"]
+
+
+def eo_solved_mc(cube: LSECube) -> bool:
+    return (
+        not cube.edges["UB"].oriented
+        and not cube.edges["UF"].oriented
+        and not cube.edges["DF"].oriented
+        and not cube.edges["DB"].oriented
+    )
+
+
+def centers_solved_mc(cube: LSECube) -> bool:
+    return cube.centers["U"] in ["F", "B"]
+
+
+def eolrb_solved(cube: LSECube) -> bool:
+    """
+    this function has weird side effects and modifies cube but we don't care about it for now
+    """
+    if not lr_solved(cube):
+        return False
+    if centers_solved_non_mc(cube) and eo_solved_non_mc(cube):
+        return True
+    if centers_solved_mc(cube) and eo_solved_mc(cube):
+        return True
+    return False
+
+
+def eolrb_solution_mc(cube: LSECube) -> bool:
+    """
+    this function only works if eolrb is solved
+    """
+    return centers_solved_mc(cube) and eo_solved_mc(cube)