         scaleToDraw: 0
         drawScaleCircle: 1
         rollingCircle: {
-            x: circleRadius
+            x: 0
             draw: 0
             rotation: Math.PI / 2
-            unrolledPoints: 0
+            originalRotation: Math.PI / 2
+            rolledPoints: numWheelPoints
         }
     }
     generateWheelPoints = (offset) ->
         if typeof offset is 'undefined'
             offset = {x:0, y:0}
         if wheelPoints is null
-            wheelPoints = _.map(_.range(0, numWheelPoints), (index) ->
+            wheelPoints = _.map(_.range(0, numWheelPoints + 1), (index) ->
                 return {x:0, y:0}
             )
         _.each(wheelPoints, (point, index) ->
-
-            angle = angleScale(index) + animationProps.rollingCircle.rotation
-            
-            r = circleRadius - wheelStrokeSize / 2
-            if index % 2 is 0
-                r -= wheelStrokeSize
-            x = Math.cos(angle) * r
-            y = Math.sin(angle) * r
-            if index < animationProps.rollingCircle.unrolledPoints
-                x = Math.cos
-                y = circleRadius
-            
-            x = scale(x)
-            y = scale(y)
+            x = y = 0
+            if index > animationProps.rollingCircle.rolledPoints
+                r = circleRadius - wheelStrokeSize / 2
+                x = 0 #wait what?
+                y = Math.sin(animationProps.rollingCircle.originalRotation) * r
+                
+                x = xScale(x)
+                y = scale(y)
+
+                y += offset.y
+            else
+                angle = angleScale(index) + animationProps.rollingCircle.rotation
+                
+                r = circleRadius - wheelStrokeSize / 2
+                #if index % 2 is 0
+                #f    r -= wheelStrokeSize
+                x = Math.cos(angle) * r
+                y = Math.sin(angle) * r
+                x = scale(x)
+                y = scale(y)
+                x += offset.x 
+                y += offset.y 
             #return {x: x, y: y}
-            x += offset.x
-            y += offset.y
             point.x = x
             point.y = y
         )

        new tweenjs.Tween(animationProps).delay(2600).to({drawScaleCircle: 0},0).start(0)
        new tweenjs.Tween(animationProps.rollingCircle).delay(2600).to({draw: 1},0).start(0)
        new tweenjs.Tween(animationProps.rollingCircle).delay(3000).to({
            x: scaleToDrawTo - circleRadius,
            rotation: Math.PI * 2 + animationProps.rollingCircle.rotation
            unrolledPoints: numWheelPoints
        },2000).start(0)

        generateWheelPoints()

        ctxt.beginPath()
        pxRadius = Math.floor(scale(circleRadius)) - 1
        yPos = yAxisPos - pxRadius
        drawCircle(xPos,yPos, 0, pxRadius)
    drawWheel = () ->
        ctxt.strokeStyle = 'black'
        ctxt.lineWidth =  Math.ceil(scale(wheelStrokeSize))
        path.render(false,false, true)

    drawRollingCircle = () ->
        if animationProps.rollingCircle.draw is 0
            return
        pxRadius = Math.floor(scale(circleRadius)) - 1

        xPos = xScale(animationProps.rollingCircle.x)
        yPos = yAxisPos - pxRadius
        drawCircle(xPos, yPos, animationProps.rollingCircle.rotation, pxRadius)

    presetStartTime = 0
    firstTime = null
