rewrite the config format

__main__.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from solver import EOLRBSolution, solve_eolrb, create_eolrb_prune_table
 from scorer import (
     FingerTrickWithRegrip,
-    load_config,
+    load_definitions,
     generate_finger_tricks,
     build_pretty_string_from_finger_tricks_with_regrips,
 )
@@ -38,7 +38,8 @@ def get_first_n_from_generator(gen: Generator[Any, None, Any], n: int) -> List[A
     try:
         while len(results) < n:
             item = next(gen)
-            results.append(item)
+            if item not in results:
+                results.append(item)
     except StopIteration:
         pass
     return results
@@ -59,19 +60,19 @@ def load_or_generate_prune_table(file_path: str, prune_size: int) -> Dict:
 
 
 def main():
-    config = load_config("./moves.yaml")
+    definitions = load_definitions("./moves.yaml")
     prune_table = load_or_generate_prune_table("prune_table.pkl", PRUNE)
     print("prune table size:", humanize.naturalsize(sys.getsizeof(prune_table)))
 
     # TODO: make this function a method of an object that contains a list of finger tricks
     score_func = lambda solution: sum(ft.score() for ft in solution.finger_tricks)
     data = defaultdict(list)
-    eolrb_states, n_states = eolrb_states_generator(
-        list(EOLROrientation), EOLR_PERMUTATIONS
-    )
     # eolrb_states, n_states = eolrb_states_generator(
-    #     [EOLROrientation.Solved], [EOLRPermutation(UR="UR", UL="UL")]
+    #     list(EOLROrientation), EOLR_PERMUTATIONS
     # )
+    eolrb_states, n_states = eolrb_states_generator(
+        [EOLROrientation.OneOne], EOLR_PERMUTATIONS
+    )
     for i, (eolrb_cube, ori, perm, pre_auf) in enumerate(eolrb_states):
         print(
             f"generating algs for {ori.name} (UR in {perm.UR}, UL in {perm.UL}, pre AUF {pre_auf}) ({i}/{n_states})"
@@ -80,7 +81,7 @@ def main():
         solutions = get_first_n_from_generator(alg_generator, SOLUTIONS_TO_EVAL)
         solutions_with_finger_tricks = [
             EOLRBSolutionWithFingertricks(
-                solution, generate_finger_tricks(config, solution.alg)
+                solution, generate_finger_tricks(definitions, solution.alg)
             )
             for solution in solutions
         ]
@@ -121,7 +122,7 @@ def main():
                 }
             )
             with open("output.json", "w") as f:
-                f.write(json.dumps(data))
+                f.write(json.dumps(data, indent=4))
 
 
 if __name__ == "__main__":

alg_trainer.py

@@ -0,0 +1,25 @@
+import json
+
+
+def main():
+    with open("./output.json") as f:
+        data = json.loads(f.read())
+    covered_cases = set()
+    for case, scrambles in data.items():
+        if not scrambles:
+            continue
+        scramble = scrambles[0]
+        if scramble["raw_alg"] in covered_cases:
+            continue
+        if scramble["stm"] > 7:
+            continue
+        if case.startswith("Solved"):
+            continue
+        if not case.startswith("OneOne"):
+            continue
+        print(f'{case}: "{scramble['alg']}"')
+        covered_cases.add(scramble["raw_alg"])
+
+
+if __name__ == "__main__":
+    main()

moves.yaml

@@ -1,46 +1,105 @@
-# TODO: do a lot of random MU algs and find out which moves are statistically faster
+fingers:
+  - name: index
+    default_score: 1
+    home_grips:
+      - BL
+      - LB
+    # TODO: change to grip_set
+    grips:
+      side:
+        - B
+        - BL
+        - LB
+        - LF
+        - FL
+        - F
+      top:
+        - UF
+    regrips:
+      - start: UF
+        end: BL
+        score: 3
+        # TODO: this doesn't need to be here
+        finger: index
+      - start: UF
+        end: LB
+        score: 3
+        # TODO: this doesn't need to be here
+        finger: index
+  - name: ring
+    default_score: 1
+    home_grips:
+      - B
+      - DB
+    grips:
+      slice:
+        - B
+        - DB
+        - DF
+        - F
+    regrips: []
+  - name: pinky
+    default_score: 1
+    home_grips:
+      - DB
+      - DF
+    grips:
+      slice:
+        - B
+        - DB
+        - DF
+        - F
+        - F floating
+    regrips: []
 finger_tricks:
   - name: "U push"
     move: "U"
     grip_pre:
-      index: BL
+      index: LB
     grip_post:
       index: B
+    grip_pre_blacklist: {}
     score: 5
   - name: "U flick"
     move: "U"
     grip_pre:
       index: F
     grip_post:
-      index: BL
+      # TODO: rethink this parameter
+      index: LB
+    grip_pre_blacklist: {}
     score: 4
   - name: "U' push"
     move: "U'"
     grip_pre:
-      index: FL
+      index: LF
     grip_post:
       index: F
+    grip_pre_blacklist: {}
     score: 5
   - name: "U' flick"
     move: "U'"
     grip_pre:
-      index: B
+      index: BL
     grip_post:
-      index: FL
+      index: LF
+    grip_pre_blacklist: {}
     score: 3
   - name: "U2 feido"
     move: "U2"
     grip_pre:
-      index: B
+      index: BL
     grip_post:
       index: F
+    grip_pre_blacklist: {}
     score: 5
   - name: "U2 double flick"
     move: "U2"
     grip_pre:
-      index: B
+      index: BL
     grip_post:
-      index: FL
+      index: LF
+    grip_pre_blacklist: {}
     score: 6
   - name: "U2' double flick"
     move: "U2"
@@ -48,6 +107,7 @@ finger_tricks:
       index: F
     grip_post:
       index: BL
+    grip_pre_blacklist: {}
     score: 9
   - name: "U2 beido"
     move: "U2"
@@ -55,6 +115,7 @@ finger_tricks:
       index: F
     grip_post:
       index: B
+    grip_pre_blacklist: {}
     score: 5
   - name: "M' ring flick"
     move: "M'"
@@ -62,13 +123,19 @@ finger_tricks:
       ring: B
     grip_post:
       ring: DF
+    grip_pre_blacklist: {}
     score: 3
   - name: "M' pinky flick"
     move: "M'"
+    # I can't do M' after finishing beido
     grip_pre:
       pinky: B
     grip_post:
       pinky: F floating
+    grip_pre_blacklist:
+      index:
+        - BL
+        - UF
     score: 6
   - name: "M push"
     move: "M"
@@ -76,6 +143,15 @@ finger_tricks:
       pinky: F
     grip_post:
       pinky: DB
+    grip_pre_blacklist: {}
+    score: 5
+  - name: "M index push"
+    move: "M"
+    grip_pre:
+      index: B
+    grip_post:
+      index: UF
+    grip_pre_blacklist: {}
     score: 6
   - name: "M2 double flick"
     move: "M2"
@@ -85,158 +161,5 @@ finger_tricks:
     grip_post:
       pinky: F floating
       ring: DB
+    grip_pre_blacklist: {}
     score: 7
-regrips:
-  # TODO: rethink this format?
-  - finger: index
-    pre: B
-    post: BL
-    score: 1
-  - finger: index
-    pre: B
-    post: FL
-    score: 2
-  - finger: index
-    pre: B
-    post: F
-    score: 2
-  - finger: index
-    pre: BL
-    post: B
-    score: 1
-  - finger: index
-    pre: BL
-    post: FL
-    score: 1
-  - finger: index
-    pre: BL
-    post: F
-    score: 2
-  - finger: index
-    pre: FL
-    post: B
-    score: 2
-  - finger: index
-    pre: FL
-    post: BL
-    score: 1
-  - finger: index
-    pre: FL
-    post: F
-    score: 1
-  - finger: index
-    pre: F
-    post: B
-    score: 2
-  - finger: index
-    pre: F
-    post: BL
-    score: 2
-  - finger: index
-    pre: F
-    post: FL
-    score: 1
-  - finger: ring
-    pre: B
-    post: DB
-    score: 1
-  - finger: ring
-    pre: B
-    post: DF
-    score: 2
-  - finger: ring
-    pre: DB
-    post: B
-    score: 2
-  - finger: ring
-    pre: DB
-    post: DF
-    score: 1
-  - finger: ring
-    pre: DF
-    post: B
-    score: 2
-  - finger: ring
-    pre: DF
-    post: DB
-    score: 1
-  - finger: pinky
-    pre: B
-    post: DB
-    score: 1
-  - finger: pinky
-    pre: B
-    post: DF
-    score: 2
-  - finger: pinky
-    pre: B
-    post: F
-    score: 2
-  - finger: pinky
-    pre: B
-    post: F floating
-    score: 2
-  - finger: pinky
-    pre: DB
-    post: B
-    score: 1
-  - finger: pinky
-    pre: DB
-    post: DF
-    score: 1
-  - finger: pinky
-    pre: DB
-    post: F
-    score: 2
-  - finger: pinky
-    pre: DB
-    post: F floating
-    score: 2
-  - finger: pinky
-    pre: DF
-    post: B
-    score: 2
-  - finger: pinky
-    pre: DF
-    post: DB
-    score: 1
-  - finger: pinky
-    pre: DF
-    post: F
-    score: 1
-  - finger: pinky
-    pre: DF
-    post: F floating
-    score: 1
-  - finger: pinky
-    pre: F
-    post: B
-    score: 3
-  - finger: pinky
-    pre: F
-    post: DB
-    score: 2
-  - finger: pinky
-    pre: F
-    post: DF
-    score: 1
-  - finger: pinky
-    pre: F
-    post: F floating
-    score: 1
-  - finger: pinky
-    pre: F floating
-    post: B
-    score: 2
-  - finger: pinky
-    pre: F floating
-    post: DB
-    score: 2
-  - finger: pinky
-    pre: F floating
-    post: DF
-    score: 2
-  - finger: pinky
-    pre: F floating
-    post: F
-    score: 2

scorer.py

@@ -8,13 +8,14 @@ from dataclasses import dataclass
 class FingerTrick:
     name: str
     move: str
+    grip_pre_blacklist: Dict[str, List[str]]
     grip_pre: Dict[str, str]
     grip_post: Dict[str, str]
     score: float
 
 
 @dataclass
-class Regrip:
+class Grip:
     finger: str
     pre: str
     post: str
@@ -22,23 +23,66 @@ class Regrip:
 
 
 @dataclass
-class Config:
-    finger_tricks: List[FingerTrick]
+class Regrip:
+    finger: str
+    start: str
+    end: str
+    score: float
+
+
+@dataclass
+class Finger:
+    name: str
+    default_score: int
+    home_grips: List[str]
+    grips: Dict[str, List[str]]
     regrips: List[Regrip]
 
 
-def home_grip() -> Dict[str, str]:
-    return {
-        "index": "B",  # this could also be BL
-        "ring": "B",
-        "pinky": "BD",
-    }
+@dataclass
+class Config:
+    fingers: List[Finger]
+    finger_tricks: List[FingerTrick]
 
 
-def load_config(file_path: str) -> Config:
+@dataclass
+class Definitions:
+    fingers: List[Finger]
+    finger_tricks: List[FingerTrick]
+    finger_regrips: List[Regrip]
+
+
+def build_regrips_from_fingers(fingers: List[Finger]) -> List[Regrip]:
+    regrips = []
+    for finger in fingers:
+        finger_regrips = {}
+        for grip_set in finger.grips.values():
+            # reate a dict with distances of every two elements in a list
+            for i in range(len(grip_set)):
+                for j in range(len(grip_set)):
+                    if i != j:
+                        finger_regrips[(grip_set[i], grip_set[j])] = Regrip(
+                            start=grip_set[i],
+                            end=grip_set[j],
+                            score=abs(j - i) * finger.default_score,
+                            finger=finger.name,
+                        )
+        for regrip in finger.regrips:
+            finger_regrips[(regrip.start, regrip.end)] = regrip
+        regrips.extend(finger_regrips.values())
+
+    return regrips
+
+
+def load_definitions(file_path: str) -> Definitions:
     with open(file_path, "r") as f:
         data_dict = yaml.safe_load(f.read())
-    return dacite.from_dict(data_class=Config, data=data_dict)
+    config = dacite.from_dict(data_class=Config, data=data_dict)
+    return Definitions(
+        fingers=config.fingers,
+        finger_tricks=config.finger_tricks,
+        finger_regrips=build_regrips_from_fingers(config.fingers),
+    )
 
 
 def grip_correct(current_grip: Dict[str, str], required_grip: Dict[str, str]):
@@ -59,47 +103,69 @@ class FingerTrickWithRegrip:
         return score
 
 
-def calculate_finger_trick_regrips(
-    config: Config, finger_trick: FingerTrick, grip: Dict[str, str]
+@dataclass
+class Algorithm:
+    score: float
+    finger_tricks_with_regrips: List[FingerTrickWithRegrip]
+
+
+def find_finger_trick_regrips(
+    regrips: List[Regrip], finger_trick: FingerTrick, grip: Dict[str, str]
 ) -> List[Regrip]:
-    regrips = []
+    alg_regrips = []
     for finger in finger_trick.grip_pre.keys():
         current_location = grip[finger]
         desired_location = finger_trick.grip_pre.get(finger)
+        blacklisted_locations = finger_trick.grip_pre_blacklist.get(finger, [])
         if current_location != desired_location:
-            regrip = next(
+            # print("FINGA", finger)
+            # print("CURRENT", current_location)
+            # print("DESIRED", desired_location)
+            # print("BLACK", blacklisted_locations)
+            # __import__("pprint").pprint(regrips)
+            alg_regrip = next(
                 (
                     regrip
-                    for regrip in config.regrips
+                    for regrip in regrips
                     if regrip.finger == finger
-                    and regrip.pre == current_location
-                    and regrip.post == desired_location
+                    and regrip.start == current_location
+                    and regrip.end == desired_location
+                    and regrip.start not in blacklisted_locations
                 ),
-                None,
             )
-            if regrip:
-                regrips.append(regrip)
-    return regrips
+            if alg_regrip:
+                alg_regrips.append(alg_regrip)
+    return alg_regrips
+
+
+def generate_home_grip(fingers: List[Finger]) -> Dict[str, str]:
+    # TODO: make this smarter
+    home_grip = {}
+    for finger in fingers:
+        home_grip[finger.name] = finger.home_grips[0]
+    return home_grip
 
 
 def generate_finger_tricks(
-    config: Config, moves: List[str]
+    definitions: Definitions, moves: List[str]
 ) -> List[FingerTrickWithRegrip]:
-    grip = home_grip()
-    alg = []
+    grip = generate_home_grip(definitions.fingers)
+    alg: List[FingerTrickWithRegrip] = []
     for move in moves:
         # print("current grip:", grip)
         # prit("current move:", move)
         possible_finger_tricks = [
             finger_trick
-            for finger_trick in config.finger_tricks
+            for finger_trick in definitions.finger_tricks
             if move == finger_trick.move
         ]
         # print("possible finger tricks:", possible_finger_tricks)
         finger_tricks_with_regrips = [
             FingerTrickWithRegrip(
                 finger_trick=finger_trick,
-                regrips=calculate_finger_trick_regrips(config, finger_trick, grip),
+                regrips=find_finger_trick_regrips(
+                    definitions.finger_regrips, finger_trick, grip
+                ),
             )
             for finger_trick in possible_finger_tricks
         ]
@@ -109,10 +175,14 @@ def generate_finger_tricks(
         # print("best finger trick:", best_finger_trick)
         # apply regrips
         for regrip in best_finger_trick.regrips:
-            grip[regrip.finger] = regrip.post
+            grip[regrip.finger] = regrip.end
         # apply move
         grip.update(best_finger_trick.finger_trick.grip_post)
         alg.append(best_finger_trick)
+
+    # TODO: think about this
+    # don't count the first regrip
+    alg[0].finger_trick.score = 0
     return alg
 
 
@@ -123,7 +193,7 @@ def build_pretty_string_from_finger_tricks_with_regrips(
 
     for finger_trick_with_regrips in finger_tricks_with_regrips:
         for regrip in finger_trick_with_regrips.regrips:
-            elems.append(f"regrip {regrip.finger} from {regrip.pre} to {regrip.post}")
+            elems.append(f"regrip {regrip.finger} from {regrip.start} to {regrip.end}")
         elems.append(finger_trick_with_regrips.finger_trick.name)
 
     return elems