- Hello and welcome to part three

of my Rubik's Cube coding challenge.

So I've done two parts already,

if you watch those,

I'm very thankful to you.

But I'm going to do something really important in this.

And it's really not about the Rubik's Cube at all,

it's really about animation.

And I want to be able to just do something

to make it a little more visually pleasing

to watch it do stuff.

So what it does right now is,

if I hit the space bar,

it's going to shuffle a whole bunch of moves.

All the possible moves,

up, down

left, right

clockwise, counterclockwise.

It could do any move along any axis.

It's also then going to whatever,

it's doing a random sequence of 100 moves

and then it's going to do those in reverse.

And you can see it looks kind of like it's solving it,

of course it's not.

Just doing a random sequence

and then applying it in reverse.

Hit the space bar again,

it's going to go again.

It's actually doing the same sequence again.

So this would be I think more,

I would be a little more confident

that it's working correctly,

if I could actually watch the,

the cubies

rotate themselves to actually turn.

So in order to do that,

I need to add animation,

I need to actually use the rotate function

to do that.

So (chuckles), I have to figure out how to do that.

Alright I think a way that's going to make sense

to do this is

to create a class,

called move.

And each move is what?

It's a given axis,

like what's the axis that's moving,

what's the direction it's moving

and then if I'm going to do an animation,

I need to animate an angle from zero to 90 degrees.

So I need an angle

which will start as zero.

I need to have an axis

and maybe what I'll do is just do x,

y

and z.

An angle and an axis.

And I'll have that access

distort in variables x, y and z.

So the x will be one

or negative one,

if it's right or left.

The y will be one

or negative one, if it's up or down.

The z will be one

or negative one, if it's front or back.

So, that's kind of I think how I'll deal

with this right now.

So when I make a move,

I have to give it an x, a y

and a z.

And that's all I have to give it.

And a direction.

So I need to know whether I'm rotating,

whether I'm rotating clockwise

or counter clockwise.

Or the angle is going up

or the angle is going down.

So this dot x equals x.

This dot y equals y.

This dot Z equals Z.

This dot direction equals direction.

And this is this.

Ultimately I've kind of done this already

in the sense that I have these functions,

called turn z,

turn y, turn x.

And those actually move the cubes around

and rotate their faces.

But they do it instantaneously.

So what I think I want to do is,

create an animation that happens,

then I finish that animation

then I quickly move everything around.

And it'll look as if it's happening seamlessly.

So let's just say,

for the sake of argument,

I'm going to have one move.

Move m.

I'll call it move.

And move m,

forget about this,

well I'll leave the sequence thing in here

for a second.

Move, is a new move

which is going to rotate the z-axis,

the front face.

So that is zero, zero,

one in a clockwise direction.

That's a move.

Then I want to say,

move dot start.

I think I'll have a function called start

and what does that do?

It sets a variable,

I'll have a variable called animating.

And it sets animating

equal to true.

I don't know that I'm going to need this,

but I feel like I might need a flag

to know when I've started

or stopped.

So then I need

an update function

and what update will do,

is, I could use LERP

for to like interpolate from zero to 90 degrees

or I could just increase the angle.

So let's just increase the angle right now.

I'm going to say, angle plus equals direction times,

you know some amount like point one.

So I'm going to increment the angle by point one

and if angle is greater than HALF_PI,

then,

angle should go back

to being zero actually.

And then I'm going to say,

animating equals false.

So let's just see if I can get this to happen.

So basically, if I have a move,

then I say move dot start,

then in draw, I just want to say

move dot update.

And if I run this.

(chuckles) so the data of the move is happening.

That angle is changing

but I need to actually rotate these.

So the way that I could do that is,

right here when I'm showing the cube,

I could check

and say,

if cube, well right here you could just say,

if cube dot z

equals move dot z.

Let's just do that alright.

If cube dot z equals move z.

Then I want to rotate

z

by move dot angle.

And I'm going to want to have a push

and a pop here.

Right? That should then,

z cannot be resolved

or is not a field.

Move has a z.

Cube index i.

If cube index i right.

If cube index i dot z.

Here we go! Look at it!

It's turning!

(grunts) It's kind of doing something.

What's it doing?

Why is it keep going?

Okay (chuckles).

So, (clears throat)

update, (laughs)

should only update the angle

if it's animating.

So once it reaches the end,

it stops animating.

So now, we should see it

turn.

You know what, I think,

I'm having this weird issue with processing

which is that, it takes a little while

for processing to start.

So what I'm actually going to do is,

I'm going to have move dot start

go into,

when I press the space bar.

Just so I can be sure it hasn't started yet.

So I'm going to run this sketch.

I'm going to hit the space bar.

There we go.

Look at that. It moves,

but look at this, it moves

but the red stuff doesn't stay there.

Because all I'm doing is creating the animation

of the moving,

I'm not actually updating the data.

But I need to update the data

so I can do all the future moves.

But I think there's an easy thing I can do here

which is I can say, move dot update if

move dot finished.

Then, what do I want to do?

Turn z move dot direction.

Turning z, isn't that a function?

Turn z move dot z,

move dot direction.

So I think there's got to be a way

I can encapsulate this into one function.

There's no finished,

so I probably could just use the animating Boolean right?

Let's add another one (laughs).

Finished is false,

finished is true

and then,

Boolean finished,

returned finished.

So now, what should happen is,

it should animate, (laughs)

because it's doing this over

and over again.

So it ultimately,

I want them,

when the move is finished,

I want to turn it once

and then be done.

So really what I should do,

is put this turn z

into the move.

Yes.

So actually, I don't know if I need

that Boolean variable at all.

What I want, is when it's done,

I want to actually just say turn z,

move according to this z

and this direction right?

And then I don't need this finished stuff.

I'm going to keep that in there just in case I need it.

So now, it should turn.

There we go!

Look at this!

(exclaims excitedly)

So now, I'm turning it.

So this is the idea.

This is the logic.

I just want to hit the space bar,

it's doing every single move.

Now the question is,

now that I've got this working,

how can I make every move work in the same way?

So there's some things

that are kind of hard coded in here.

For example, this shouldn't always be turn z.

Right, this should sometimes be turn x

or turn y

or turn

z.

Before I do that though,

let me just make sure it works in other directions.

So for example,

if I were to say a negative one,

that should be the back of the cube.

Okay. So that's working.

And if I were to say one,

negative one,

that should be the front of the cube

but going now in counter clockwise direction.

Okay.

So that doesn't work.

So why doesn't that work?

Because if I'm going in counterclockwise direction,

I'm going all the way to negative HALF_PI.

So that's something I need to fix.

So here, if angle,

so I could say, if absolute value of the angle

is greater than HALF_PI.

So if I'm going in the negative direction,

I need to check negative HALF_PI.

That should fix that.

Great! So now I can go in either direction.

Only in the z axis.

So what if I make a move,

that is now