Custom methods

This article will explain how to create custom methods. Methods are used for generating statistics.

Existing methods

But first, we'll go through all the existing methods so you know what exists and how statistics for them should be structured.

CFOP

CFOP is the method used by default because it's the method most used by the community and so the most often reconstructed one (not because it's the best one). The following steps, mostly built on existing conventions, are used for statistics:

• F2L: All of F2L, including Cross and the pairs. Pairs are given in the form "1st pair".
• LL: The last layer, usually OLL and PLL.
• Cross+1: Cross and the first pair, also includes XCross, XXCross etc.
• OLS: The last pair and OLL. Includes everything that solves the orientation of the last layer, so WVLS, COLL and ZBLL are counted, too.
• PLL: Standard PLL, can also include EPLL and CPLL.

Roux

The statistics for Roux follow the format Antonio Kam uses in his reconstructions. The steps are:

• F2B: First Two Blocks, consisting of FB (first block) and SB (second block).
• L10P: Last Ten Pieces, consisting of CMLL (corners of the last layer, ignores the M slice) and LSE (last six edges).
• FB: The first block, includes FB, FS (first square) and FP (first pair).
• SS: The second square, also includes SB (second block).
• SP: The second pair which completes the SB.
• CMLL: All CxLL subsets are counted.
• EOLRb: Orienting the edges (EO, 4a) and placing UL and UR edges (LR, 4b), also includes EOLR, which performs both simultaneously.
• EP: Permutation of the edges, also permits 4c.

ZZ

"[T]he only legitimate 21st century speedcubing method, ZZ" - MattDiPalma
is also included in Nachbildung. Because there are two main "variants" of it, different methods were added for them.

EOCross

EOCross uses the same statistics as CFOP, except that Cross+1 is replaced with EOCross (since they are often considered to be of equal difficulty to plan). The statistics are:

• F2L
• LL
• EOCross: Includes all types of EOCross like XEOCross, just EO and also EOLine and EOArrow.
• OLS
• PLL

EOLine

EOLine is drastically different from EOCross, except for the last layer. Its steps are:

• F2L
• LL
• EOLine: Just EOLine, includes EOArrow, EOCross, XEOLine etc.
• Left block: The left block, includes Left square and Left pair.
• Right block: The right block, includes Right square and Right pair.
• OLS
• PLL

Petrus

Since Petrus used to be pretty popular and is currently experiencing some growth, I decided I'd also add it here. There weren't really any conventions yet, so I just created my own:

• F2L
• LL
• 223: The 223 block, includes 222, 223, EO222 and EO223.
• EO: Orienting the edges, after the 223.
• Right block: The right block that finishes F2L, same as the one in ZZ (EOLine).
• OLS
• PLL

LEOR

LEOR is a pretty new method similar to Petrus, and thus uses very similar steps:

• F2L
• LL
• Left block: Unlike one might think, this is not equivalent to the ZZ Left block, but rather to the Roux First block. FBEO is also included.
• EOStripe: Orienting the edges and solving DF and DB. Also counts just Stripe.
• Right block
• OLS
• PLL

Creating new methods

For creating a new method, create a .json file with any name in the methods folder, which should be next to the .jar. You need to be familiar with JSON for this.
As an example, we'll create a file for SSC here.
The first value you have to provide is the displayed name, a string following the key "name":

{
    "name": "SSC"
}

Then, you can define the steps, under the key "steps" with an array as a value:

{
    "name": "SSC",
    "steps": [...]
}

Each of these steps can either be an object or a string. Objects are custom and unique to this method while strings are used for shared steps and link to a file in common_method_substeps.
Firstly, we'll look at how you can create new objects:
So to start, create a new object with a name.
Then, add a regex which will check whether a step name should be counted towards this statistic. The regex will be matched against the entire string, so a regex of b will only match b, not banana. If you're not familiar with regex and you don't want to learn it, you can start by separating each value with |. To test whether your regex works, you can use services like RegExr.

{
    "name": "SSC",
    "steps": [
        {
            "name": "EOEdge",
            "regex": "EO|EOEdge|Edge"
        },
        {
            "name": "CO",
            "regex": "Pseudo (pair|triplet)|OL5C"
        },
        {
            "name": "CP",
            "regex": "CP|PBLC"
        },
        {
            "name": "L8E",
            "regex": "EZD|L8E|LEE"
        }
    ]
}

For using common substeps (F2L, LL, PLL, Right block, Pair OLS, RB OLS), you can just put a string instead of the object pointing to its identifier. I won't go over creating common substeps here, but it's basically the same as creating a normal substep except that you put it in its own file and also have a identifier, which is only used for identification purposes and can be the same as the name (e.g. RB OLS just shows as OLS, but if you want to link to it, you have to use "RB OLS").
Now everything is basically done. However, you can also add auto fill steps. However, they're optional and will change in a future update, so you don't really need them. They are used for automatically filling empty step names when the setting is activated. For creating the names, add an array with the key "auto_fill_steps" and the strings for the step names that should be added. It may look like this:

"auto_fill_steps": [ "EOEdge", "Pseudo pair", "Pseudo triplet", "OL5C", "CP", "L8E" ]

And this is it, you've now created your own method for custom statistics.