lercube 0.1.0__tar.gz

lercube-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: lercube
+Version: 0.1.0
+Summary: Rubik's cube simulator and solver
+Requires-Python: >=3.10

lercube-0.1.0/__init__.py

@@ -0,0 +1,23 @@
+from .cube import Cube
+from .dict import (
+	CORNER_COLOURS_TO_LETTERS,
+	CORNER_LETTERS,
+	CORNER_LETTER_PLACEMENTS,
+	CORNER_LETTER_PLACEMENTS_FLIPPED,
+	EDGE_COLOURS_TO_LETTERS,
+	EDGE_LETTERS,
+	EDGE_LETTER_PLACEMENTS,
+	EDGE_LETTER_PLACEMENTS_FLIPPED,
+)
+
+__all__ = [
+	"Cube",
+	"CORNER_COLOURS_TO_LETTERS",
+	"CORNER_LETTERS",
+	"CORNER_LETTER_PLACEMENTS",
+	"CORNER_LETTER_PLACEMENTS_FLIPPED",
+	"EDGE_COLOURS_TO_LETTERS",
+	"EDGE_LETTERS",
+	"EDGE_LETTER_PLACEMENTS",
+	"EDGE_LETTER_PLACEMENTS_FLIPPED",
+]

lercube-0.1.0/cube.py

@@ -0,0 +1,316 @@
+from .dict import *
+import random
+
+POSSIBLE_MOVES_FULL = [f"{x}{y}" for x in "FBRLUDfbrludxys" for y in ["", "'", "2"]]
+POSSIBLE_MOVES_MAIN = [f"{x}{y}" for x in "FBRLUD" for y in ["", "'", "2"]]
+
+TRANSLATE_MOVE = {
+    move: (
+        str(move[0]),
+        ["", "2", "'"].index(move[1:]) + 1,
+    )
+    for move in POSSIBLE_MOVES_FULL
+}
+
+class Cube:
+    def __init__(self):
+        self.cube = {
+            face: [[col] * 3 for _ in range(3)]
+            for face, col in zip("ULFRBD", 'WOGRBY')
+        }
+
+    @staticmethod
+    def generate_scramble(moveCount: int = 20, xyz: bool = False) -> list[str]:
+        possible_moves = POSSIBLE_MOVES_FULL if xyz else POSSIBLE_MOVES_MAIN
+        scramble = []
+        previous_face = None
+
+        while len(scramble) < moveCount:
+            move = random.choice(possible_moves)
+            face = move[0].lower()
+
+            if face == previous_face:
+                continue
+
+            scramble.append(move)
+            previous_face = face
+
+        return scramble
+
+    def translate(self, moves):
+        if moves is None:
+            return
+
+        if type(moves) is str:
+            moves = moves.split()
+
+        for move in moves:
+            if move not in POSSIBLE_MOVES_FULL:
+                raise ValueError(f"Move {move} is not a valid move.")
+
+            method_name, count = TRANSLATE_MOVE[move]
+            for _ in range(count):
+                getattr(self, method_name)()
+
+    #region face rotation helpers
+    def _rotate_face(self, face):
+        return [list(row) for row in zip(*face[::-1])]
+    def _rotate_face_twice(self, face):
+        return self._rotate_face(self._rotate_face(face))
+    def _rotate_face_counterclockwise(self, face):
+        return self._rotate_face(self._rotate_face(self._rotate_face(face)))
+    #endregion
+
+    #region moves
+    def F(self):
+        u_bottom = self.cube["U"][2].copy()
+        r_left = [row[0] for row in self.cube["R"]]
+        d_top = self.cube["D"][0].copy()
+        l_right = [row[2] for row in self.cube["L"]]
+
+        self.cube["U"][2] = l_right[::-1]
+        for index in range(3):
+            self.cube["R"][index][0] = u_bottom[index]
+        self.cube["D"][0] = r_left[::-1]
+        for index in range(3):
+            self.cube["L"][index][2] = d_top[index]
+        self.cube["F"] = self._rotate_face(self.cube["F"])
+
+    def B(self):
+        u_top = self.cube["U"][0][::-1]
+        r_right = [row[2] for row in self.cube["R"]]
+        d_bottom = self.cube["D"][2][::-1]
+        l_left = [row[0] for row in self.cube["L"]]
+
+        self.cube["U"][0] = r_right
+        for index in range(3):
+            self.cube["R"][index][2] = d_bottom[index]
+        self.cube["D"][2] = l_left
+        for index in range(3):
+            self.cube["L"][index][0] = u_top[index]
+        self.cube["B"] = self._rotate_face(self.cube["B"])
+
+    def R(self):
+        u_right = [row[2] for row in self.cube["U"]][::-1]
+        b_right = [row[0] for row in self.cube["B"]][::-1]
+        d_right = [row[2] for row in self.cube["D"]]
+        f_right = [row[2] for row in self.cube["F"]]
+
+        for index in range(3):
+            self.cube["U"][index][2] = f_right[index]
+            self.cube["B"][index][0] = u_right[index]
+            self.cube["D"][index][2] = b_right[index]
+            self.cube["F"][index][2] = d_right[index]
+        self.cube["R"] = self._rotate_face(self.cube["R"])
+
+    def L(self):
+        u_left = [row[0] for row in self.cube["U"]]
+        f_left = [row[0] for row in self.cube["F"]]
+        d_left = [row[0] for row in self.cube["D"]][::-1]
+        b_left = [row[2] for row in self.cube["B"]][::-1]
+
+        for index in range(3):
+            self.cube["U"][index][0] = b_left[index]
+            self.cube["F"][index][0] = u_left[index]
+            self.cube["D"][index][0] = f_left[index]
+            self.cube["B"][index][2] = d_left[index]
+        self.cube["L"] = self._rotate_face(self.cube["L"])
+
+    def U(self):
+        f_top = self.cube["F"][0].copy()
+        l_top = self.cube["L"][0].copy()
+        b_top = self.cube["B"][0].copy()
+        r_top = self.cube["R"][0].copy()
+
+        self.cube["F"][0] = r_top
+        self.cube["L"][0] = f_top
+        self.cube["B"][0] = l_top
+        self.cube["R"][0] = b_top
+        self.cube["U"] = self._rotate_face(self.cube["U"])
+
+    def D(self):
+        f_bottom = self.cube["F"][2].copy()
+        l_bottom = self.cube["L"][2].copy()
+        b_bottom = self.cube["B"][2].copy()
+        r_bottom = self.cube["R"][2].copy()
+
+        self.cube["F"][2] = l_bottom
+        self.cube["R"][2] = f_bottom
+        self.cube["B"][2] = r_bottom
+        self.cube["L"][2] = b_bottom
+        self.cube["D"] = self._rotate_face(self.cube["D"])
+
+    def x(self):
+        old = {face: [row.copy() for row in self.cube[face]] for face in "ULFRBD"}
+
+        self.cube["U"] = old["F"]
+        self.cube["F"] = old["D"]
+        self.cube["D"] = self._rotate_face_twice(old["B"])
+        self.cube["B"] = self._rotate_face_twice(old["U"])
+        self.cube["R"] = self._rotate_face(old["R"])
+        self.cube["L"] = self._rotate_face_counterclockwise(old["L"])
+
+    def y(self):
+        old = {face: [row.copy() for row in self.cube[face]] for face in "ULFRBD"}
+
+        self.cube["U"] = self._rotate_face(old["U"])
+        self.cube["D"] = self._rotate_face_counterclockwise(old["D"])
+        self.cube["F"] = old["R"]
+        self.cube["R"] = old["B"]
+        self.cube["B"] = old["L"]
+        self.cube["L"] = old["F"]
+
+    def z(self):
+        old = {face: [row.copy() for row in self.cube[face]] for face in "ULFRBD"}
+
+        self.cube["U"] = self._rotate_face(old["L"])
+        self.cube["R"] = self._rotate_face(old["U"])
+        self.cube["D"] = self._rotate_face(old["R"])
+        self.cube["L"] = self._rotate_face(old["D"])
+        self.cube["F"] = self._rotate_face(old["F"])
+        self.cube["B"] = self._rotate_face_counterclockwise(old["B"])
+
+    def f(self):
+        self.B()
+        self.z()
+
+    def b(self):
+        self.F()
+        self.z()
+        self.z()
+        self.z()
+
+    def r(self):
+        self.L()
+        self.x()
+
+    def l(self):
+        self.R()
+        self.x()
+        self.x()
+        self.x()
+
+    def u(self):
+        self.D()
+        self.y()
+
+    def d(self):
+        self.U()
+        self.y()
+        self.y()
+        self.y()
+    #endregion
+
+    def show_cube(self):
+        colors = {
+            "W": "\033[47m",
+            "R": "\033[41m",
+            "B": "\033[44m",
+            "O": "\033[48;2;255;165;0m",
+            "G": "\033[42m",
+            "Y": "\033[43m",
+        }
+        reset = "\033[0m"
+
+        def face_lines(face: list[list[str]]) -> list[str]:
+            return [
+                "".join(
+                    f"{colors[cell]}\033[30m {cell} {reset}"
+                    for cell in row
+                )
+                for row in face
+            ]
+
+        top, left, front, right, back, bottom = [
+            face_lines(self.cube[face])
+            for face in "ULFRBD"
+        ]
+        blank = " " * 11
+
+        print("\n".join([
+            *[f"{blank}{line}" for line in top],
+            "  ".join([left[0], front[0], right[0], back[0]]),
+            "  ".join([left[1], front[1], right[1], back[1]]),
+            "  ".join([left[2], front[2], right[2], back[2]]),
+            *[f"{blank}{line}" for line in bottom],
+        ]))
+
+    def old_pochmann(self):
+        #region old pochmann edges
+        edgeLetters = ("B","M")
+        listEdgeLetters = []
+        seenEdges = [("B","M"), ("M","B")]
+
+        while True:
+            while True:
+                edgeIndex = EDGE_LETTERS[edgeLetters[0]], EDGE_LETTERS[edgeLetters[1]]
+                edgeColours = (self.cube[edgeIndex[0][0]][edgeIndex[0][1]][edgeIndex[0][2]], self.cube[edgeIndex[1][0]][edgeIndex[1][1]][edgeIndex[1][2]])
+                edgeLetters = EDGE_COLOURS_TO_LETTERS[edgeColours]
+
+                if edgeLetters in seenEdges:
+                    break
+
+                listEdgeLetters.append(edgeLetters[0])
+                seenEdges.append(edgeLetters)
+                seenEdges.append((edgeLetters[1], edgeLetters[0]))
+
+            seenAll = True
+            for edgeLetters in EDGE_COLOURS_TO_LETTERS.values():
+                if edgeLetters not in seenEdges:
+                    seenAll = False
+                    listEdgeLetters.append(edgeLetters[0])
+                    break
+
+            if seenAll:
+                break
+        #endregion
+
+        #region old pochmann corners
+        cornerLetters = ("E","R","A")
+        listCornerLetters = []
+        seenCorners = [("E","R","A"), ("A","E","R"), ("R","A","E")]
+
+        while True:
+            while True:
+                cornerIndex = CORNER_LETTERS[cornerLetters[0]], CORNER_LETTERS[cornerLetters[1]], CORNER_LETTERS[cornerLetters[2]]
+                cornerColours = (self.cube[cornerIndex[0][0]][cornerIndex[0][1]][cornerIndex[0][2]], self.cube[cornerIndex[1][0]][cornerIndex[1][1]][cornerIndex[1][2]], self.cube[cornerIndex[2][0]][cornerIndex[2][1]][cornerIndex[2][2]])
+                cornerLetters = CORNER_COLOURS_TO_LETTERS[cornerColours]
+
+                if cornerLetters in seenCorners:
+                    break
+
+                listCornerLetters.append(cornerLetters[0])
+                seenCorners.append(cornerLetters)
+                seenCorners.append((cornerLetters[2], cornerLetters[0], cornerLetters[1]))
+                seenCorners.append((cornerLetters[1], cornerLetters[2], cornerLetters[0]))
+
+            seenAll = True
+            for cornerLetters in CORNER_COLOURS_TO_LETTERS.values():
+                if cornerLetters not in seenCorners:
+                    seenAll = False
+                    listCornerLetters.append(cornerLetters[0])
+                    break
+                
+            if seenAll:
+                break
+        #endregion
+
+        #region remove duplicates
+        edgeList = []
+        for letter in listEdgeLetters:
+            if edgeList and edgeList[-1] == letter:
+                edgeList.pop()
+            else:
+                edgeList.append(letter)
+        edgeList = " ".join(edgeList)
+
+        cornerList = []
+        for letter in listCornerLetters:
+            if cornerList and cornerList[-1] == letter:
+                cornerList.pop()
+            else:
+                cornerList.append(letter)
+        cornerList = " ".join(cornerList)
+        #endregion
+
+        return (edgeList, cornerList)

lercube-0.1.0/dict.py

@@ -0,0 +1,26 @@
+import json
+from pathlib import Path
+
+DATA_DIR = Path(__file__).parent / "json"
+
+def load_json_data(filename):
+    file_path = DATA_DIR / filename
+    with open(file_path, 'r') as f:
+        return json.load(f)
+
+def load_tuple_key_json_data(filename):
+    records = load_json_data(filename)
+    return {
+        tuple(record["key"]): tuple(record["value"])
+        for record in records
+    }
+
+EDGE_LETTERS = load_json_data("EDGE_LETTERS.json")
+EDGE_COLOURS_TO_LETTERS = load_tuple_key_json_data("EDGE_COLOURS_TO_LETTERS.json")
+EDGE_LETTER_PLACEMENTS = load_json_data("EDGE_LETTER_PLACEMENTS.json")
+EDGE_LETTER_PLACEMENTS_FLIPPED = load_json_data("EDGE_LETTER_PLACEMENTS_FLIPPED.json")
+
+CORNER_LETTERS = load_json_data("CORNER_LETTERS.json")
+CORNER_COLOURS_TO_LETTERS = load_tuple_key_json_data("CORNER_COLOURS_TO_LETTERS.json")
+CORNER_LETTER_PLACEMENTS = load_json_data("CORNER_LETTER_PLACEMENTS.json")
+CORNER_LETTER_PLACEMENTS_FLIPPED = load_json_data("CORNER_LETTER_PLACEMENTS_FLIPPED.json")

lercube-0.1.0/json/CORNER_COLOURS_TO_LETTERS.json

@@ -0,0 +1,290 @@
+[
+    {
+        "key": [
+            "W",
+            "O",
+            "B"
+        ],
+        "value": [
+            "A",
+            "E",
+            "R"
+        ]
+    },
+    {
+        "key": [
+            "W",
+            "B",
+            "R"
+        ],
+        "value": [
+            "B",
+            "Q",
+            "N"
+        ]
+    },
+    {
+        "key": [
+            "W",
+            "R",
+            "G"
+        ],
+        "value": [
+            "C",
+            "M",
+            "J"
+        ]
+    },
+    {
+        "key": [
+            "W",
+            "G",
+            "O"
+        ],
+        "value": [
+            "D",
+            "I",
+            "F"
+        ]
+    },
+    {
+        "key": [
+            "O",
+            "B",
+            "W"
+        ],
+        "value": [
+            "E",
+            "R",
+            "A"
+        ]
+    },
+    {
+        "key": [
+            "O",
+            "W",
+            "G"
+        ],
+        "value": [
+            "F",
+            "D",
+            "I"
+        ]
+    },
+    {
+        "key": [
+            "O",
+            "G",
+            "Y"
+        ],
+        "value": [
+            "G",
+            "L",
+            "U"
+        ]
+    },
+    {
+        "key": [
+            "O",
+            "Y",
+            "B"
+        ],
+        "value": [
+            "H",
+            "X",
+            "S"
+        ]
+    },
+    {
+        "key": [
+            "G",
+            "O",
+            "W"
+        ],
+        "value": [
+            "I",
+            "F",
+            "D"
+        ]
+    },
+    {
+        "key": [
+            "G",
+            "W",
+            "R"
+        ],
+        "value": [
+            "J",
+            "C",
+            "M"
+        ]
+    },
+    {
+        "key": [
+            "G",
+            "R",
+            "Y"
+        ],
+        "value": [
+            "K",
+            "P",
+            "V"
+        ]
+    },
+    {
+        "key": [
+            "G",
+            "Y",
+            "O"
+        ],
+        "value": [
+            "L",
+            "U",
+            "G"
+        ]
+    },
+    {
+        "key": [
+            "R",
+            "G",
+            "W"
+        ],
+        "value": [
+            "M",
+            "J",
+            "C"
+        ]
+    },
+    {
+        "key": [
+            "R",
+            "W",
+            "B"
+        ],
+        "value": [
+            "N",
+            "B",
+            "Q"
+        ]
+    },
+    {
+        "key": [
+            "R",
+            "B",
+            "Y"
+        ],
+        "value": [
+            "O",
+            "T",
+            "W"
+        ]
+    },
+    {
+        "key": [
+            "R",
+            "Y",
+            "G"
+        ],
+        "value": [
+            "P",
+            "V",
+            "K"
+        ]
+    },
+    {
+        "key": [
+            "B",
+            "R",
+            "W"
+        ],
+        "value": [
+            "Q",
+            "N",
+            "B"
+        ]
+    },
+    {
+        "key": [
+            "B",
+            "W",
+            "O"
+        ],
+        "value": [
+            "R",
+            "A",
+            "E"
+        ]
+    },
+    {
+        "key": [
+            "B",
+            "O",
+            "Y"
+        ],
+        "value": [
+            "S",
+            "H",
+            "X"
+        ]
+    },
+    {
+        "key": [
+            "B",
+            "Y",
+            "R"
+        ],
+        "value": [
+            "T",
+            "W",
+            "O"
+        ]
+    },
+    {
+        "key": [
+            "Y",
+            "O",
+            "G"
+        ],
+        "value": [
+            "U",
+            "G",
+            "L"
+        ]
+    },
+    {
+        "key": [
+            "Y",
+            "G",
+            "R"
+        ],
+        "value": [
+            "V",
+            "K",
+            "P"
+        ]
+    },
+    {
+        "key": [
+            "Y",
+            "R",
+            "B"
+        ],
+        "value": [
+            "W",
+            "O",
+            "T"
+        ]
+    },
+    {
+        "key": [
+            "Y",
+            "B",
+            "O"
+        ],
+        "value": [
+            "X",
+            "S",
+            "H"
+        ]
+    }
+]