// Important for working around lexical closures in things like

// forEach() or setTimeout(), etc which change the scope of "this".

var cube = this

// Some important booleans.

this.isReady = true

this.isShuffling = false

this.isRotating = false

this.isSolving = false

// Every fire of this.loop() will attempt to complete our tasks

// which can only be run if this.isReady === true.

this.taskQueue = new Queue()

// We need the ability to gang up twist commands.

// Every fire of this.loop() will attempt to empty it.

this.twistQueue = new Queue( Twist.validate )

// How long should a Cube.twist() take?

this.twistDuration = SECOND

// If we shuffle, how shall we do it?

this.shuffleMethod = this.PRESERVE_LOGO

// Size matters? Cubelets will attempt to read these values.

this.size = 420

this.cubeletSize = 140

// We need to create and setup a new CSS3 Object

// to represent our Cube.

// THREE will take care of attaching it to the DOM, etc.

if( erno.renderMode === 'css' ){

this.domElement = document.createElement( 'div' )

this.domElement.classList.add( 'cube' )

this.threeObject = new THREE.CSS3DObject( this.domElement )

}

else if( erno.renderMode === 'svg' ){

this.threeObject = new THREE.Object3D()

}

this.threeObject.rotation.set(

( 25 ).degreesToRadians(),

( -30 ).degreesToRadians(),

0

)

scene.add( this.threeObject )

// If we enable Auto-Rotate then the cube will spin (not twist!) in space

// by adding the following values to the Three object on each frame.

this.rotationDeltaX = 0.1

this.rotationDeltaY = 0.15

this.rotationDeltaZ = 0

// Here's the first big map we've come across in the program so far.

// Imagine you're looking at the Cube straight on so you only see the front face.

// We're going to map that front face from left to right (3), and top to bottom (3):

// that's 3 x 3 = 9 Cubelets.

// But then behind the Front slice we also have a Standing slice (9) and Back slice (9),

// so that's going to be 27 Cubelets in total to create a Cube.

this.cubelets = []

;([

// Front slice

[ W, O, , , G, ], [ W, O, , , , ], [ W, O, B, , , ],// 0, 1, 2

[ W, , , , G, ], [ W, , , , , ], [ W, , B, , , ],// 3, 4, 5

[ W, , , R, G, ], [ W, , , R, , ], [ W, , B, R, , ],// 6, 7, 8

// Standing slice

[ , O, , , G, ], [ , O, , , , ], [ , O, B, , , ],// 9, 10, 11

[ , , , , G, ], [ , , , , , ], [ , , B, , , ],// 12, XX, 14

[ , , , R, G, ], [ , , , R, , ], [ , , B, R, , ],// 15, 16, 17

// Back slice

[ , O, , , G, Y ], [ , O, , , , Y ], [ , O, B, , , Y ],// 18, 19, 20

[ , , , , G, Y ], [ , , , , , Y ], [ , , B, , , Y ],// 21, 22, 23

[ , , , R, G, Y ], [ , , , R, , Y ], [ , , B, R, , Y ] // 24, 25, 26

]).forEach( function( cubeletColorMap, cubeletId ){

cube.cubelets.push( new Cubelet( cube, cubeletId, cubeletColorMap ))

})

// Mapping the Cube creates all the convenience shortcuts

// that we will need later. (Demonstrated immediately below!)

this.map()

// Now that we have mapped faces we can create faceLabels

if( erno.renderMode === 'css' ){

this.faces.forEach( function( face, i ){

var labelElement = document.createElement( 'div' )

labelElement.classList.add( 'faceLabel' )

labelElement.classList.add( 'face'+ face.face.capitalize() )

labelElement.innerHTML = face.face.toUpperCase()

cube.domElement.appendChild( labelElement )

})

}

// We need to map our folds separately from Cube.map()

// because we only want folds mapped at creation time.

// Remapping folds with each Cube.twist() would get weird...

this.folds = [

new Fold( this.front, this.right ),

new Fold( this.left, this.up ),

new Fold( this.down, this.back )

]

// Enable some "Hero" text for this Cube.

if( erno.renderMode === 'css' ){

this.setText( 'BEYONDRUBIKs CUBE', 0 )

this.setText( 'BEYONDRUBIKs CUBE', 1 )

this.setText( 'BEYONDRUBIKs CUBE', 2 )

}

// Shall we load some presets here?

preset = 'preset' + preset.capitalize()

if( this[ preset ] instanceof Function === false ) preset = 'presetBling'

this[ preset ]()

// Get ready for major loop-age.

// Our Cube checks these booleans at roughly 60fps.

setInterval( cube.loop, 16 )

// Enable key commands for our Cube.

$( document ).keypress( function( event ){

if( $( 'input:focus, textarea:focus' ).length === 0 ){

var key = String.fromCharCode( event.which )

if( 'XxRrMmLlYyUuEeDdZzFfSsBb'.indexOf( key ) >= 0 ) cube.twistQueue.add( key )

}

})

var that = this, i

// Groups are simple collections of Cubelets.

// Their position and rotation is irrelevant.

this.core = new Group()

this.centers = new Group()

this.edges = new Group()

this.corners = new Group()

this.crosses = new Group()

this.cubelets.forEach( function( cubelet, index ){

if( cubelet.type === 'core' ) that.core.add( cubelet )

if( cubelet.type === 'center' ) that.centers.add( cubelet )

if( cubelet.type === 'edge' ) that.edges.add( cubelet )

if( cubelet.type === 'corner' ) that.corners.add( cubelet )

if( cubelet.type === 'center' || cubelet.type === 'edge' ) that.crosses.add( cubelet )

})

// Slices that can rotate about the X-axis:

this.left = new Slice(

this.cubelets[ 24 ], this.cubelets[ 21 ], this.cubelets[ 18 ],

this.cubelets[ 15 ], this.cubelets[ 12 ], this.cubelets[ 9 ],

this.cubelets[ 6 ], this.cubelets[ 3 ], this.cubelets[ 0 ]

)

this.left.name = 'left'

this.middle = new Slice(

this.cubelets[ 25 ], this.cubelets[ 22 ], this.cubelets[ 19 ],

this.cubelets[ 16 ], this.cubelets[ 13 ], this.cubelets[ 10 ],

this.cubelets[ 7 ], this.cubelets[ 4 ], this.cubelets[ 1 ]

)

this.middle.name = 'middle'

this.right = new Slice(

this.cubelets[ 2 ], this.cubelets[ 11 ], this.cubelets[ 20 ],

this.cubelets[ 5 ], this.cubelets[ 14 ], this.cubelets[ 23 ],

this.cubelets[ 8 ], this.cubelets[ 17 ], this.cubelets[ 26 ]

)

this.right.name = 'right'

// Slices that can rotate about the Y-axis:

this.up = new Slice(

this.cubelets[ 18 ], this.cubelets[ 19 ], this.cubelets[ 20 ],

this.cubelets[ 9 ], this.cubelets[ 10 ], this.cubelets[ 11 ],

this.cubelets[ 0 ], this.cubelets[ 1 ], this.cubelets[ 2 ]

)

this.up.name = 'up'

this.equator = new Slice(

this.cubelets[ 21 ], this.cubelets[ 22 ], this.cubelets[ 23 ],

this.cubelets[ 12 ], this.cubelets[ 13 ], this.cubelets[ 14 ],

this.cubelets[ 3 ], this.cubelets[ 4 ], this.cubelets[ 5 ]

)

this.equator.name = 'equator'

this.down = new Slice(

this.cubelets[ 8 ], this.cubelets[ 17 ], this.cubelets[ 26 ],

this.cubelets[ 7 ], this.cubelets[ 16 ], this.cubelets[ 25 ],

this.cubelets[ 6 ], this.cubelets[ 15 ], this.cubelets[ 24 ]

)

this.down.name = 'down'

// Slices are Groups with purpose; they are rotate-able!

// These are Slices that can rotate about the Z-axis:

this.front = new Slice(

this.cubelets[ 0 ], this.cubelets[ 1 ], this.cubelets[ 2 ],

this.cubelets[ 3 ], this.cubelets[ 4 ], this.cubelets[ 5 ],

this.cubelets[ 6 ], this.cubelets[ 7 ], this.cubelets[ 8 ]

)

this.front.name = 'front'

this.standing = new Slice(

this.cubelets[ 9 ], this.cubelets[ 10 ], this.cubelets[ 11 ],

this.cubelets[ 12 ], this.cubelets[ 13 ], this.cubelets[ 14 ],

this.cubelets[ 15 ], this.cubelets[ 16 ], this.cubelets[ 17 ]

)

this.standing.name = 'standing'

this.back = new Slice(

this.cubelets[ 26 ], this.cubelets[ 23 ], this.cubelets[ 20 ],

this.cubelets[ 25 ], this.cubelets[ 22 ], this.cubelets[ 19 ],

this.cubelets[ 24 ], this.cubelets[ 21 ], this.cubelets[ 18 ]

)

this.back.name = 'back'

// Faces .... special kind of Slice!

this.faces = [ this.front, this.up, this.right, this.down, this.left, this.back ]

// Good to let each Cubelet know where it exists

// in relationship to our full Cube.

for( i = 0; i < this.cubelets.length; i ++ ){

this.cubelets[ i ].setAddress( i )

}

if( fold === undefined ){

return [

this.folds[ 0 ].getText(),

this.folds[ 1 ].getText(),

this.folds[ 2 ].getText()

]

}

else if( isNumeric( fold ) && fold >= 0 && fold <= 2 ){

return this.folds[ fold ].getText()

}

if( fold === undefined ){

this.folds[ 0 ].setText( text )

this.folds[ 1 ].setText( text )

this.folds[ 2 ].setText( text )

}

else if( isNumeric( fold ) && fold >= 0 && fold <= 2 ){

this.folds[ fold ].setText( text )

}

compact = !compact

this.front.inspect( compact, side )

this.up.inspect( compact, side )

this.right.inspect( compact, side )

this.down.inspect( compact, side )

this.left.inspect( compact, side )

this.back.inspect( compact, side )

return (

this.front.isSolved( FRONT ) &&

this.up.isSolved( UP ) &&

this.right.isSolved( RIGHT ) &&

this.down.isSolved( DOWN ) &&

this.left.isSolved( LEFT ) &&

this.back.isSolved( BACK )

)

var onTwistComplete

if( twist instanceof Twist && !cube.isTweening() ){

command = twist.command

degrees = twist.degrees

if( erno.verbosity >= 0.8 ){

console.log(

'Executing a twist command to rotate the '+

twist.group +' '+ twist.wise +' by',

twist.degrees, 'degrees.'

)

}

// X-axis rotations

if( command === 'X' && !cube.isEngagedY() && !cube.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets = [

swap[ 6 ], swap[ 7 ], swap[ 8 ],

swap[ 15 ], swap[ 16 ], swap[ 17 ],

swap[ 24 ], swap[ 25 ], swap[ 26 ],

swap[ 3 ], swap[ 4 ], swap[ 5 ],

swap[ 12 ], swap[ 13 ], swap[ 14 ],

swap[ 21 ], swap[ 22 ], swap[ 23 ],

swap[ 0 ], swap[ 1 ], swap[ 2 ],

swap[ 9 ], swap[ 10 ], swap[ 11 ],

swap[ 18 ], swap[ 19 ], swap[ 20 ]

]

}

if( degrees === undefined ) degrees = cube.getDistanceToPeg( 'X' )

cube.cubelets.forEach( function( cubelet, i ){

if( i === cube.cubelets.length - 1 ) cubelet.rotate( 'X', degrees, onTwistComplete )

else cubelet.rotate( 'X', degrees )

})

}

else if( command === 'x' && !cube.isEngagedY() && !cube.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets = [

swap[ 18 ], swap[ 19 ], swap[ 20 ],

swap[ 9 ], swap[ 10 ], swap[ 11 ],

swap[ 0 ], swap[ 1 ], swap[ 2 ],

swap[ 21 ], swap[ 22 ], swap[ 23 ],

swap[ 12 ], swap[ 13 ], swap[ 14 ],

swap[ 3 ], swap[ 4 ], swap[ 5 ],

swap[ 24 ], swap[ 25 ], swap[ 26 ],

swap[ 15 ], swap[ 16 ], swap[ 17 ],

swap[ 6 ], swap[ 7 ], swap[ 8 ]

]

}

if( degrees === undefined ) degrees = cube.getDistanceToPeg( 'x' )

cube.cubelets.forEach( function( cubelet, i ){

if( i === cube.cubelets.length - 1 ) cubelet.rotate( 'x', degrees, onTwistComplete )

else cubelet.rotate( 'x', degrees )

})

}

else if( command === 'R' && !cube.right.isEngagedY() && !cube.right.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 2 ] = swap[ 8 ]

cube.cubelets[ 11 ] = swap[ 5 ]

cube.cubelets[ 20 ] = swap[ 2 ]

cube.cubelets[ 5 ] = swap[ 17 ]

cube.cubelets[ 23 ] = swap[ 11 ]

cube.cubelets[ 8 ] = swap[ 26 ]

cube.cubelets[ 17 ] = swap[ 23 ]

cube.cubelets[ 26 ] = swap[ 20 ]

}

if( degrees === undefined ) degrees = cube.right.getDistanceToPeg( 'X' )

cube.right.cubelets.forEach( function( cubelet, i ){

if( i === cube.right.cubelets.length - 1 ) cubelet.rotate( 'X', degrees, onTwistComplete )

else cubelet.rotate( 'X', degrees )

})

}

else if( command === 'r' && !cube.right.isEngagedY() && !cube.right.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 2 ] = swap[ 20 ]

cube.cubelets[ 11 ] = swap[ 23 ]

cube.cubelets[ 20 ] = swap[ 26 ]

cube.cubelets[ 5 ] = swap[ 11 ]

cube.cubelets[ 23 ] = swap[ 17 ]

cube.cubelets[ 8 ] = swap[ 2 ]

cube.cubelets[ 17 ] = swap[ 5 ]

cube.cubelets[ 26 ] = swap[ 8 ]

}

if( degrees === undefined ) degrees = cube.right.getDistanceToPeg( 'x' )

cube.right.cubelets.forEach( function( cubelet, i ){

if( i === cube.right.cubelets.length - 1 ) cubelet.rotate( 'x', degrees, onTwistComplete )

else cubelet.rotate( 'x', degrees )

})

}

else if( command === 'M' && !cube.middle.isEngagedY() && !cube.middle.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 1 ] = swap[ 19 ]

cube.cubelets[ 10 ] = swap[ 22 ]

cube.cubelets[ 19 ] = swap[ 25 ]

cube.cubelets[ 4 ] = swap[ 10 ]

cube.cubelets[ 22 ] = swap[ 16 ]

cube.cubelets[ 7 ] = swap[ 1 ]

cube.cubelets[ 16 ] = swap[ 4 ]

cube.cubelets[ 25 ] = swap[ 7 ]

}

if( degrees === undefined ) degrees = cube.middle.getDistanceToPeg( 'x' )

cube.middle.cubelets.forEach( function( cubelet, i ){

if( i === cube.middle.cubelets.length - 1 ) cubelet.rotate( 'x', degrees, onTwistComplete )

else cubelet.rotate( 'x', degrees )

})

}

else if( command === 'm' && !cube.middle.isEngagedY() && !cube.middle.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 1 ] = swap[ 7 ]

cube.cubelets[ 10 ] = swap[ 4 ]

cube.cubelets[ 19 ] = swap[ 1 ]

cube.cubelets[ 4 ] = swap[ 16 ]

cube.cubelets[ 22 ] = swap[ 10 ]

cube.cubelets[ 7 ] = swap[ 25 ]

cube.cubelets[ 16 ] = swap[ 22 ]

cube.cubelets[ 25 ] = swap[ 19 ]

}

if( degrees === undefined ) degrees = cube.middle.getDistanceToPeg( 'X' )

cube.middle.cubelets.forEach( function( cubelet, i ){

if( i === cube.middle.cubelets.length - 1 ) cubelet.rotate( 'X', degrees, onTwistComplete )

else cubelet.rotate( 'X', degrees, onTwistComplete )

})

}

else if( command === 'L' && !cube.left.isEngagedY() && !cube.left.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 18 ] = swap[ 24 ]

cube.cubelets[ 9 ] = swap[ 21 ]

cube.cubelets[ 0 ] = swap[ 18 ]

cube.cubelets[ 21 ] = swap[ 15 ]

cube.cubelets[ 3 ] = swap[ 9 ]

cube.cubelets[ 24 ] = swap[ 6 ]

cube.cubelets[ 15 ] = swap[ 3 ]

cube.cubelets[ 6 ] = swap[ 0 ]

}

if( degrees === undefined ) degrees = cube.left.getDistanceToPeg( 'x' )

cube.left.cubelets.forEach( function( cubelet, i ){

if( i === cube.left.cubelets.length - 1 ) cubelet.rotate( 'x', degrees, onTwistComplete )

else cubelet.rotate( 'x', degrees )

})

}

else if( command === 'l' && !cube.left.isEngagedY() && !cube.left.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 18 ] = swap[ 0 ]

cube.cubelets[ 9 ] = swap[ 3 ]

cube.cubelets[ 0 ] = swap[ 6 ]

cube.cubelets[ 21 ] = swap[ 9 ]

cube.cubelets[ 3 ] = swap[ 15 ]

cube.cubelets[ 24 ] = swap[ 18 ]

cube.cubelets[ 15 ] = swap[ 21 ]

cube.cubelets[ 6 ] = swap[ 24 ]

}

if( degrees === undefined ) degrees = cube.left.getDistanceToPeg( 'X' )

cube.left.cubelets.forEach( function( cubelet, i ){

if( i === cube.left.cubelets.length - 1 ) cubelet.rotate( 'X', degrees, onTwistComplete )

else cubelet.rotate( 'X', degrees )

})

}

// Y-axis rotations

if( command === 'Y' && !cube.isEngagedX() && !cube.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets = [

swap[ 2 ], swap[ 11 ], swap[ 20 ],

swap[ 5 ], swap[ 14 ], swap[ 23 ],

swap[ 8 ], swap[ 17 ], swap[ 26 ],

swap[ 1 ], swap[ 10 ], swap[ 19 ],

swap[ 4 ], swap[ 13 ], swap[ 22 ],

swap[ 7 ], swap[ 16 ], swap[ 25 ],

swap[ 0 ], swap[ 9 ], swap[ 18 ],

swap[ 3 ], swap[ 12 ], swap[ 21 ],

swap[ 6 ], swap[ 15 ], swap[ 24 ]

]

}

if( degrees === undefined ) degrees = cube.getDistanceToPeg( 'Y' )

cube.cubelets.forEach( function( cubelet, i ){

if( i === cube.cubelets.length - 1 ) cubelet.rotate( 'Y', degrees, onTwistComplete )

else cubelet.rotate( 'Y', degrees )

})

}

else if( command === 'y' && !cube.isEngagedX() && !cube.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets = [

swap[ 18 ], swap[ 9 ], swap[ 0 ],

swap[ 21 ], swap[ 12 ], swap[ 3 ],

swap[ 24 ], swap[ 15 ], swap[ 6 ],

swap[ 19 ], swap[ 10 ], swap[ 1 ],

swap[ 22 ], swap[ 13 ], swap[ 4 ],

swap[ 25 ], swap[ 16 ], swap[ 7 ],

swap[ 20 ], swap[ 11 ], swap[ 2 ],

swap[ 23 ], swap[ 14 ], swap[ 5 ],

swap[ 26 ], swap[ 17 ], swap[ 8 ]

]

}

if( degrees === undefined ) degrees = cube.getDistanceToPeg( 'y' )

cube.cubelets.forEach( function( cubelet, i ){

if( i === cube.cubelets.length - 1 ) cubelet.rotate( 'y', degrees, onTwistComplete )

else cubelet.rotate( 'y', degrees )

})

}

else if( command === 'U' && !cube.up.isEngagedX() && !cube.up.isEngagedZ() ){

onTwistComplete = function( swap ){

cube.cubelets[ 18 ] = swap[ 0 ]

cube.cubelets[ 19 ] = swap[ 9 ]

cube.cubelets[ 20 ] = swap[ 18 ]

cube.cubelets[ 9 ] = swap[ 1 ]

cube.cubelets[ 11 ] = swap[ 19 ]

cube.cubelets[ 0 ] = swap[ 2 ]

cube.cubelets[ 1 ] = swap[ 11 ]

cube.cubelets[ 2 ] = swap[ 20 ]

}

if( degrees === undefined ) degrees = cube.up.getDistanceToPeg( 'Y' )

cube.up.cubelets.forEach( function( cubelet, i ){