burik:0.1.0 (#2708)

Author: Gcalmet

packages/preview/burik/0.1.0/LICENSE

@@ -0,0 +1,5 @@
+« Copyright © 2025 Gabin Calmet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software. »

packages/preview/burik/0.1.0/README.md

@@ -0,0 +1,117 @@
+# Burik — A Typst Library for easy Rubik's Cube tutorials edition
+
+**Burik** is a Typst library specifically designed to facilitate the creation of tutorials for **3x3 Rubik's Cube** solving.
+
+Burik was first designed to make life easier for tutorial creators, as it allows algorithms manipulation in strings and algorithms visualization with parametrizable drawing functions from different point of view.
+
+There is also an interest for the tutorial's user as there is no possible mismatch between the written algorithm and the displayed image.
+
+## Installation
+
+To use this package, simply add the following code to your document:
+
+`#import "@preview/burik:0.1.0"`
+
+You can check the example file for more details.
+
+
+## Use Example
+
+````typ
+#import "@preview/burik:0.1.0"
+
+#f2l("f R' f'")
+#oll("r U R' U R U2 r'")
+#pll("R' U R' U' R3 U' R' U R U R2")
+````
+<table>
+<tr> Click on the image to open an example file </tr>
+<td>
+<p align="center">
+  <a href="./example.typ">
+  <img src="./thumbnail.png">
+  </a>
+</p>
+</td>
+</table>
+
+## How it works ?
+
+When you pass an algorithm to Burik, it inverts it and executes it on a solved cube. As a result, you obtain the configuration in which executing the non-inverted algorithm is useful.
+
+## Moves
+
+Moves used to encode an algorithm on the Rubik's Cube are the standard ones (visit [J Perm](https://jperm.net/3x3/moves) for +) :
+
+- `F, B, R, L, U, D` for the 6 classical moves
+- `f, b, r, l, u, d` for the 6 wide moves
+- `E, S, M` for the 3 slice moves
+- `x, y, z` for the 3 cube rotations
+  
+In each case, you can use  `', 2, 3, ` to indicate the number of turns.
+
+## Algorithms
+
+For Burik, an algorithm is a string of moves separated by a space. For instance `"R U R' U R U2 R' U"` can be interpreted as an algorithm.
+
+Algorithms come with tool functions that can be used to create new algorithms or for easier manipulation :
+
+- `conc(A, B)` returns `C` such that `C = A + B`
+
+- `invert(A)` returns `A'` such that `A + A' = " "`
+  
+- `enclose(A, B)` returns `C` such that `C = B + A + B'` (or `C + B = B + A`)
+
+- `simplify(A)` returns `A'` such that `A = A'` and that `A'`̀  has no useless moves
+
+## Colors
+
+There are seven parametrizable colors in RGB hexadecimal code in `cubes.typ`
+
+- white for stickers from the `U` face
+- yellow for stickers from the `D` face
+- red for stickers from the `R` face
+- orange for stickers from the `L` face
+- green for stickers from the `F` face
+- blue for stickers from the `B` face
+- black for every non-colorized stickers
+  
+## Cubes
+
+Cubes are dictionnaries with 6 keys `u, d, f, b, r, l` for the six faces, and each value is an array of 9 colors.
+
+There are 3 predefined cubes in `cubes.typ` and they all have white on top and green in front :
+
+- `pll_cube` is a fully solved cube
+
+- `oll_cube` has solved white face, two first layers and yellow face (black stickers on the last layer permutation)
+
+- `f2l_cube` has solved white face and two first layers. The last layer  and the yellow face is in black.
+
+There is no assertion that the cubes that you may create from scrath using the same method are solvable, so you must be careful when doing so. I would recommend using the predefined cubes as much as possible.
+
+## Drawing
+
+There are 3 drawing functions :
+
+- `draw_pattern` for drawing the 6 faces of the cube as the pattern of a cube (useful for debugging or scramble checking)
+
+- `draw_last_layer` for drawing the last layer with reduced stickers for the side pieces (useful for OLL, PLL and every last layer algorithm)
+  
+- `draw_3d_cube` for drawing the cube in perpective with a view on faces `F, U, R` (useful for F2L)
+
+And there also 3 illustrating functions :
+
+- `pll` to illustrate PLL algorithms, by default this is in the last face point of view, with yellow face on top, green in front, and starting with the `pll_cube` as the target configuration. You can choose to display black arrows on the yellow face to illustrate ongoing permutations.
+  
+- `oll` to illustrate OLL algorithms, by default this is in the last face point of view, with yellow face on top, green in front, and starting with the `oll_cube` as the target configuration.
+  
+- `f2l` to illustrate F2L algorithms, by default this is in the 3D view, with yellow face on top, green in front, and starting with the `f2l_cube` as the target configuration.
+
+## License
+
+This project is licensed under the MIT License. You can find the full text in the `LICENSE` file included in this repository.
+
+## Future Work
+
+There are no current versions that include other cube shapes than 3x3 (like 2x2, 4x4, 5x5, ...) or other puzzle shapes (like megaminx, skewb, ...).

packages/preview/burik/0.1.0/README.typ

@@ -0,0 +1,116 @@
+#import "@preview/burik:0.1.0": *
+
+= Burik — A Typst Library for easy Rubik's Cube tutorials edition
+#v(1em)
+*Burik* is a Typst library specifically designed to facilitate the creation of tutorials for *3x3 Rubik's Cube* solving.
+
+Burik was first designed to make life easier for tutorial creators, as it allows algorithms manipulation in strings and algorithms visualization with parametrizable drawing functions from different point of view.
+
+There is also an interest for the tutorial's user as there is no possible mismatch between the written algorithm and the displayed image.
+
+== Installation
+
+To use this package, clone this #link("https://github.com/Gcalmet/burik", "GitHub repository") or add this line at the beginning of your document in the webapp :
+
+````typ
+#import "@preview/burik:0.1.0"
+````
+
+== Use example
+
+````typ
+#import "@preview/burik:0.1.0"
+#f2l("f R' f'")
+#oll("r U R' U R U2 r'")
+#pll("R' U R' U' R3 U' R' U R U R2")
+````
+
+#f2l("f R' f'")
+#oll("r U R' U R U2 r'")
+#pll("R' U R' U' R3 U' R' U R U R2")
+
+You can check the #link("example.typ", "example file") for more usage examples.
+
+== How does it work ?
+
+When you pass an algorithm to Burik, it inverts it and executes the inverted algorithm on a solved cube. As a result, it obtains a configuration in which executing the non-inverted algorithm is useful.
+
+== Moves
+
+Moves used to encode an algorithm on the Rubik's Cube are the standard ones (visit #link("https://jperm.net/3x3/moves", "J Perm website") for more details).
+
+
+// link to the website
+
+- #raw("F, B, R, L, U, D") for the 6 classical moves
+- #raw("f, b, r, l, u, d ") for the 6 wide moves
+- #raw("E, S, M ") for the 3 slice moves
+- #raw("x, y, z") for the 3 cube rotations
+  
+In each case, you can use  #raw(" ', 2, 3, ") to indicate the number of turns.
+
+== Algorithms
+
+For Burik, an algorithm is a string of moves separated by a space. For instance `"R U R' U R U2 R' U"` can be interpreted as an algorithm.
+
+Algorithms come with tool functions that can be used to create new algorithms or for easier manipulation :
+
+- `conc(A, B)` returns `C` such that `C = A + B`
+
+- `invert(A)` returns `A'` such that `A + A' = " "`
+  
+- `enclose(A, B)` returns `C` such that `C = B + A + B'`
+
+- `simplify(A)` returns `A'` such that `A = A'` and that `A'`̀  has no useless moves
+
+== Colors
+
+There are seven parametrizable colors in RGB hexadecimal code in `cubes.typ`
+
+- #text(color.white, "white") for stickers from the `U` face
+- #text(color.yellow, "yellow") for stickers from the `D` face
+- #text(color.red, "red") for stickers from the `R` face
+- #text(color.orange, "orange") for stickers from the `L` face
+- #text(color.green, "green") for stickers from the `F` face
+- #text(color.blue, "blue") for stickers from the `B` face
+- #text(color.black, "black") for every non-colorized stickers
+  
+== Cubes
+
+Cubes are dictionnaries with 6 keys ` u, d, f, b, r, l ` for the six faces, and each value is an array of 9 colors.
+
+There are 3 predefined cubes in `cubes.typ` and they all have white on top and green in front :
+
+- `pll-cube` is a fully solved cube
+
+- `oll-cube` has solved white face, two first layers and yellow face (black stickers on the last layer permutation)
+
+- `f2l-cube` has solved white face and two first layers. The last layer  and the yellow face is in black.
+
+There is no assertion that the cubes that you may create from scrath using the same method are solvable, so you must be careful when doing so. I would recommend using the predefined cubes as much as possible.
+
+== Drawing
+
+There are 3 drawing functions :
+
+- `draw-pattern` for drawing the 6 faces of the cube as the pattern of a cube (useful for debugging or scramble checking)
+
+- `draw-last-layer` for drawing the last layer with reduced stickers for the side pieces (useful for OLL, PLL and every last layer algorithm)
+  
+- `draw-3d-cube` for drawing the cube in perpective with a view on faces `F, U, R` (useful for F2L)
+
+And there also 3 illustrating functions :
+
+- `pll` to illustrate PLL algorithms, by default this is in the last face point of view, with yellow face on top, green in front, and starting with the `pll-cube` as the target configuration. You can choose to display black arrows on the yellow face to illustrate ongoing permutations.
+  
+- `oll` to illustrate OLL algorithms, by default this is in the last face point of view, with yellow face on top, green in front, and starting with the `oll-cube` as the target configuration.
+  
+- `f2l` to illustrate F2L algorithms, by default this is in the 3D view, with yellow face on top, green in front, and starting with the `f2l-cube` as the target configuration.
+
+== License
+
+This project is licensed under the MIT License. You can find the full text in the `LICENSE` file included in this repository.
+
+== Future Work
+
+There are no current versions that include other cube shapes than 3x3 (like 2x2, 4x4, 5x5, ...) or other puzzle shapes (like megaminx, skewb, ...).

packages/preview/burik/0.1.0/algo.typ

@@ -0,0 +1,116 @@
+#import "cubes.typ" : *
+#import "moves.typ" : *
+
+#let move-value = move => {
+  if move.ends-with("'") {
+    (move.slice(0, -1), -1)
+  } else if move.ends-with("2") {
+    (move.slice(0, -1), 2)
+  } else {
+    (move, 1)
+  }
+}
+
+#let value-to-move = (face, value) => {
+  let v = calc.rem(value,4)
+  if v == 0 {
+    none
+  } else if v == 1 {
+    face
+  } else if v == 2 {
+    face + "2"
+  } else {
+    face + "'"
+  }
+}
+
+#let simplify = algo => {
+  let moves = algo.split(" ")
+  let changed = true
+
+  while changed {
+    let i = 0
+    let new-moves = ()
+    changed = false
+
+    while i < moves.len() {
+      if i < moves.len() - 1 {
+        let a = moves.at(i)
+        let b = moves.at(i + 1)
+        let (face-a, val-a) = move-value(a)
+        let (face-b, val-b) = move-value(b)
+
+        if face-a == face-b {
+          let merged = value-to-move(face-a, val-a + val-b)
+          if merged != none {
+            new-moves.push(merged)
+          }
+          i += 2
+          changed = true
+          continue
+        }
+      }
+      new-moves.push(moves.at(i))
+      i += 1
+    }
+
+    moves = new-moves
+  }
+  moves.join(" ")
+}
+
+#let apply-sequence = (cube, sequence) => sequence.fold(cube, apply-move)
+
+#let invert-move = move => {
+  if move.ends-with("'") {
+    move.slice(0,-1)
+  } else if move.ends-with("2") {
+    move
+  } else if move.ends-with("3") {
+     move.slice(0,-1)
+  } else {
+    move + "'"
+  }
+}
+
+#let invert-algo = algo-array => {
+  algo-array.rev().map(invert-move)
+}
+
+#let invert = str => str.split(" ").rev().map(invert-move).join(" ")
+
+#let conc = (algo1, algo2) => {
+  simplify(algo1 + " " + algo2)
+}
+
+#let enclose = (algo, prefix)  => {
+  conc(prefix, conc(algo, invert(prefix)))
+}
+
+#let find-permutation(cube)={
+  let permut = ()
+  
+  let edges = ("U" : cube.u.at(7), "L" : cube.l.at(5), "R" : cube.r.at(3), "D" : cube.d.at(1)) 
+
+  let corners = ("LU" :  cube.l.at(2), "RU" : cube.u.at(8), "RD" : cube.r.at(6) , "LD" : cube.d.at(0)) 
+
+  let centers = ("U" : cube.u.at(4), "L" : cube.l.at(4), "R" : cube.r.at(4), "D" : cube.d.at(4), "LU" : cube.l.at(4), "RU" : cube.u.at(4), "RD" : cube.r.at(4), "LD":cube.d.at(4))
+  
+  for (edge1, color1) in edges.pairs() {
+    for (edge2, color2) in edges.pairs() {
+      if color1 == centers.at(edge2) and edge1 != edge2{
+        permut.push((edge1, edge2))
+      }
+    }
+  }
+
+  for (corner1, color1) in corners.pairs() {
+    for (corner2, color2) in corners.pairs() {
+      if color1 == centers.at(corner2) and corner1 != corner2{
+        permut.push((corner1, corner2))
+      }
+    }
+  }
+  
+  permut
+}