This post aims to explain a bit how to do the BlouBlou move in Exit Path.

Before trying to explain anything, I warn you that this trick isn’t really explained, and if you find anything interesting, pm me on YCK ep or comment the post, it would be greatly appreciated.

3x3x3 Mercury from mf8/dayan taken from twistypuzzles

Today I’m going to speak about the process I use to solve the Mercury Planet cube from the crazy 3x3x3 serie!

But first, here is a link to a video explaining how to do a ‘kit’ of all the planet cubes (and more) by buying only 2 puzzles:

I used that video to make my kit and am very happy with it!

This cube has one 1 face, for this tutorial I put it on the white one (this will be important for my commutators to know which face is 1 and which are 0), and all the other faces are 0 faces.

I’ll call outer 3x3x3 the pieces which you usually have on a 3x3x3 (the double sided edges, 3 sided corners and centers), circle edges the pieces of the circle beside the edges and circle corners the pieces of the circle beside the corner pieces.

Now we are ready to dive into the solve of this funny puzzle ðŸ˜›

Strategy

I searched for some moves to do on this cube and came up with a strategy of my own. If you want you can exchange some of the steps because some are independent from all the others, so you can do it what way you prefer.

solving the outer 3x3x3 edges

placing/orienting the corners

solving the circle edges

solving the circle corners

Solving the outer 3x3x3 edges

By ‘solving the outer 3x3x3’ I mean solve the standard 3x3x3 edges (you can do corners at the same time but I found it to be quite confusing).

To do that you need only the algorithms you already know for the 3x3x3 (otherwise look at some other articles to find how to do it or try to do it by yourself first).

One important thing for this step is to notice that some of the circle edges can’t be moved (the ones beside the white and the yellow face).

My way of doing is to move them at the good spot and then doing the edge placement.

One difficulty you can encounter is the case with only on pair of edge and corrners exchanged (even permutation of corners and edges). To solve that problem, I do the algorithm we would usually do on a 3x3x3 with yellow or white in front.

Placing/orienting the corners of the outer 3x3x3

That step is dived into 2 which are quite independent from all the other steps. So you can do it at any time but I find it to be better there for recognition of the pieces in the next steps. First I place them using the usual 3x3x3 3-cycle of corners with yellow on top.

Then orientation is also done with yellow on top with the standard 3x3x3 last-layer corner orientation algorithms.

That step is very easy and fast, and even more if you already did some kind of F2L during the first step.

Solving the circle edges

This part is again independant from all the other moves so you could also for example place the circle corners before but once more, I find it easier for recognition.

Here comes the challenge. I have had to find a new commutator in order to solve that part of the cube.

I finally came up with a commutator that is pretty long (I imagine it’s not very efficient but I didn’t find another thing) but very easy to remember. I do this commutator with the white face on top.

here is a picture of the effect of that 3-cycle:

3-cycle

You can also notice my drawing abilities with paint :,)

Of course, you can mirror it / conjugate it to get other pieces to be exchanged.

Here it is:

[x,y]=[RL’FR’LD2L’RFR’L , U]

x will exchange 2 pieces, y prepares for undoing

Here is the ready to do sequence:

RL’FR’LD2L’RFR’LÂ Â UÂ Â L’RF’R’LD2L’RF’LR’Â Â U’

With only that commutator, you should be able to solve all these circle edges.

My strategy is to solve red blue green orange circle edges first and finally white and yellow (just that I find it easier but you can do it another way).

You know are only one step away from a solved cube ðŸ™‚

Solving circle corners

Once again a step that I didn’t have any commutator for.

I figured out a new one, which I execute with white on top again. The setups can be sometimes quite hard to remember but it works ðŸ˜› .

Here is it’s effect:

3-cycle

[x,y] = [R’DRDFD’F’, U]

Final sequence:

R’DRDFD’F’Â Â UÂ Â FDF’D’R’D’RÂ Â U’

Now you are able to solve the cube entirely!Â gratz ðŸ˜‰

Conclusion

This wasn’t an easy challenge for sure (even if there are tons of lot harder puzzles) but this is the pleasant thing of figuring out how to solve puzzles!

The only problem I have with my method is for some setups which makes me sometimes mess up the whole cube and I have to start again the solve.

I’ll maybe post some other planet solutions if I figure out to solve another ðŸ˜‰

Feel free to comment if you need help, I am not explaining everything in detail.

I made mine with cubetwist’s bandaging kit, so it doesn’t shapeshift, but apart from it, it does every moves an original would do and has the same “bandaging”.

Below you can find a scheme of the aurumQ-1 if you’d like to make your own one (you don’t need the kit to do it, only a simple 3x3x3 with a bit of tape is enough)

My solution is very simple and requires only 2 algorithms and a bit of intuition.

I splitted this method in 2 main parts:

aurumQ-1 taken from twistypuzzle’s museum

Corners pairing and placement

Edges placement

step 1: corners

So, as I just wrote, the first step will be to pair corners 2 by 2 (by pair I mean placing one corner next toÂ it’s neighboor).

The 3 first pairs are purely intuitive, if you’ve already solved a 3x3x3 you shouldn’t have much troubles doing it.

The first problem may come at your fourth and last pair. Effectively, most of the time you’ll get the 2 last corners swapped. (if it is not the cast, you’re very lucky and can go to the next step)
The problem is that you can’t use algorithms like some PLLs of the CFOP method for standard 3x3x3s because your bandaged cube won’t allow some of the movements required.

So the solution has been to find another algorithm that does this action using only the allowed moves. I finally came to a solution, but I imagine it isn’t the most efficient algorithm to perform this task, if someone has better, feel free to share it in the comments.

In order to reverse them, I do the following algorithm (using the standard 3x3x3 notation) with my “middle-moving” slice on the left of my front face:

L2 U L2 U’ L2 D L2 U’ L2 U’ L2 U L2 U L2 U’ D’

After performing that, your last 2 corners should be nicely paired.

Maybe you’ll have seen at this step that we won’t have to look at the orientation of the corners, which makes the resolution even smaller.

You’re half done!

The next and last step will be to place your edges correctly!

step 2: edges

In order to place my edges, I’ve had again to create a new algorithm, the ones I knew couldn’t be applied due (again) to the bandaging.

The algorithm I made is not the best because it does 2 2 corners commutation, but it is enough to solve entirely the puzzle (this method doesn’t aim to speedsolve)

Assuming you’re in the same position as for the algorithm I wrote before, here are the edges that will be swapped:

{(front;up),(back;up)}

{(top;right),(bottom;left)}

Here is the algorithm:

L2 U (L2 U2)2 L2 U’ L2 U2 L2 U2

Try to think a bit and your puzzle will be solved within a few algorithms.

You’re now done, congratz ðŸ˜›

This was very funny to figure out how to solve it. Obviously this isn’t a very efficient method but it is enough to feel proud of it!

Copy from an article I made a while ago on another place.

Unidirectionnal teleportation will allow you to create teleporters that leads it’s pair, but only in one direction (instead of both directions).

To make one, you just need to modify a bit the tags of your teleporters.

Name the first one as you would normally do (t+label+(1 or 2)) example: ta2

Then the second teleporter’s name will be a bit different. You must name if Â as a normal other, but you will also add another character at the end, for example: ta1*

Then, you’ll be able to travel from ta1* to ta2 but not from ta2 to ta1*!

visual explanations

Explanations:

Knowing how to do this is funny, but not as much as understanding it.

This the point of this part.

So, in order to understand why does it work, I opened the game with the software JPEXS Free Flash Decompiler, and searched through the code to find this function:

code to initialize tp

As you can see by it’s name, this function aims to initialize tps, pairing each one with it’s twin.

As you (already I think) now, to label a teleporter, you use the character ‘t’ followed by another character which will be the id of the teleporter, and finally, you use character 1 or 2 to inform if the teleporter is an entry/exit.

In the code, the id letter is registered in this.letter and the type in this.type.

The important fact to remark is that the substr function will only take the 3rd letter as type and no more.

Then comes the conditionnal structures which are used to pair the entry teleporter with it’s exit.

What is written there is:

if the type of your teleporter (this.type) equals to 1, then it’s partner’s label will be ‘t’+this.letter+’2′

if the type of your teleporter (this.type) equals to 2, then it’s partner’s label will be ‘t’+this.letter+’1′

These conditions allow us to create tps that are linked with another in only one direction.

If you didn’t understand, let’s take a look at a small example:

Let the first tp’s label be “ta1*” and the second “ta2”

During the init function these will be the values:

this.letter = ‘a’ // the id of our teleporter is here

this.type = ‘1’ Â // only the third character, the ‘*’ isn’t here

and at the end of the first if:

this.partner = “ta2”

This is totally normal, but when “ta2” will be initialized, it’s partner will switch to “ta1” and not “ta1*”