# Cubetrac, designed to help develop your BLD solving method



## leeo (Feb 13, 2017)

I've been working on Cubetrac as an assist for developing my BLD solving method for the past few years. To generate some interest, here is a little cursory tour of some of the features:

Recognizes all commonly accepted moves: U F R B L D M E S x y z Uw Fw' Dw2 and so forth
Parses conjugate notation with ":" or ",": [ U L B, R F ] parses to: U L B R F B' L' U' F' R'
Generates the BLD reading based on your letter system. Letter system fully customizable to any unicode character: here is speffz:

```
ULB=AER UBR=BQN URF=CMJ UFL=DIF
LFD=GLU LDB=HXS FRD=KPV RBD=OTW

UB=AQ UR=BM UF=CI UL=DE LF=FL LD=GX
LB=HR FR=JP FD=KU RB=NT RD=OV BD=SW
```
You may specify any Corner Cubie for the corner buffer, and any Edge Cubie for the edge buffer. Here I choose letters unused to specify a scramble, so since "B" refers to a move, "A" ('anchor' perhaps) is used instead followed by the Singmaster name

```
A UB
A ULB
```
If your reading position differs from the standard WCF scrambling orientation, that may also be specified: Here I specify that my reading orientation is also the scrambling orientation, which is the most common choice from a poll. Other orientations begin with "@UF=" followed by the Singmaster name of the corner cubie that is whole-cube rotated to UF for reading. UF is where WCF rules explicitly specfiy the colors for a scrambling.

```
@UF=UF
```
The output to a text box is an uncommented BLD reading. For example for U L B R F B' L' U' F' R'

```
(AJIMNWq's_FKl'u_#_CFG)
```
I found it nice to save sequences into an internal memory so that the display does not get too cluttered. Again, another letter unused to specify a move sequence: "H" for _hold_ followed by a short number defines a memory of the sequence entered to that point given that numerical name. For example:

```
U L B R F B' L' U' F R' H1
```
defines memory number 1 to be the seqence U L B R F B' L' U' F R' 
To retrieve a memory, another unused letter, "G" for get

```
G1
```
inserts the sequence from memory number 1 into the display processing stream.
With the memory system in place, I often found it nice to clear the reading by command or provide other features. Here, another unused letter, "K" followed by a number activates the command associated. K0 clears the identified stream to blank. This can now be combined with the H and G to do some actions:

```
U L B R F B' L' U' F R' H1 K0
```
clears the display, but not before defining memory number 1. Now

```
K0 G1 G1 H2
```
defines memory number 2 to be memory number 1 applied twice.
The entire BH forms from any buffer is generated on startup. These may be retrieved with the G command followed by your letter-system letters in this format. The buffer, ULB, or speffz _A, specified earlier, is assumed by default.

```
input: G(_LM)
expands to: L U' F D2 F' U F D2 F' L'
reads as: (#_ALM) L U' F D2 F' U F D2 F' L'
```
the code K1 inverts the sequence to that point

```
input: G(_LM) k1
reads as: (#_AML) L F D2 F' U' F D2 F' U L'
```
today, I found it useful to define G(_LM') as syntatic sugar for G(_ML). Here is a result from 2750 random moves (test routine K1005) with additional moves added to minimize the number of restarts (K12)

```
(chlp:AFCJHUEBW_#_AVOSLJI)
```
with the BH catalog in place, the 2750 move generator can be converted to a BLD generator this way

```
g(FC') g(JH') g(UE') g(BW')    g(_VO') g(_SL') g(_JI')  k1
```
which is 68 half-turn metric moves, with 14 double faceturns, so the quarter-turn metric is 68+14= 82 quarter faceturns.


----------

