skn3 Tween demo - missing function?

Monkey Forums/Monkey Programming/skn3 Tween demo - missing function?

Supertino

(Posted 2014) [#1]

Hey

I have been using skn3's Tween code in my games for a while but I noticed an issue today when I wanted to pause and resume a tween, it looks like that functionality was never fully implemented, there is a commented line in the Resume Method about updating the start timer but no actual code.

I wanted to scroll a screen using a tween and pause\resume if the screen was touched so I used tween.stop and tween.resume but noticed that it doesn't actual stop the tween timers updating so when it resumes it's whizzed forward or even finished. I assume there needs to be some code within the Resume Method to recover or offset the timer(s).

The code in question is bundled with Monkey Sample docs "Jonathan Pittock" Tween demo.

You can add these two lines to the Update method of the tweendemo.monkey to get a better understanding;

If KeyHit(KEY_S) tween.Stop() 'Pause game
If KeyHit(KEY_C) tween.Resume() ' Resume game

Imagine you have a pause button that pauses your game, the desired behavior is that the oval stops and resumes from the same spot to finish the movement when un-paused.

I have spent about an hour fudging about but I cannot quite get it to work. If any one is a little bored and wants to take a look i'd appreciate it.

Sammy

(Posted 2014) [#2]

There is a pausable Millisecs() compatible routine in the Monkey Code forum that may help :-

http://www.monkey-x.com/Community/posts.php?topic=5830

Just substitute this for the Mojo.Millisecs() one SKN3 is using and then stop and start it with your own pause methods.

I have not test this though but I dont see a reason it would not work.

Skn3	(Posted 2014) [#3]

Does this help?

tween.monkey

Import mojo

'--------------------------------------------------------------------------------------------------
'Tween module contents
Const PI := 3.14159265

'---------------
'base classes

Class Tween
    Global Linear:TweenEquationCall = New TweenEquationCallLinear

    Global Back:TweenEquation = New TweenEquationBack
    Global Bounce:TweenEquation = New TweenEquationBounce
    Global Circ:TweenEquation = New TweenEquationCirc
    Global Cubic:TweenEquation = New TweenEquationCubic
    Global Elastic:TweenEquation = New TweenEquationElastic
    Global Expo:TweenEquation = New TweenEquationExpo
    Global Quad:TweenEquation = New TweenEquationQuad
    Global Quart:TweenEquation = New TweenEquationQuart
    Global Quint:TweenEquation = New TweenEquationQuint
    Global Sine:TweenEquation = New TweenEquationSine

    Field equation:TweenEquationCall

    Field start:Float
    Field change:Float
    Field current:Float

    Field isActive := False
    Field isLooping := False
    Field isYoYo := False

    Field duration:Int
    Field loopCount:Int
    Field timeStart:Int
    Field timeCurrent:Int
    Field timePrevious:Int
	Field timePaused:Int

    ' --- constructors ---
    Method New(equation:TweenEquationCall,startValue:Float,endValue:Float,duration:Int)
        SetEquation(equation)
        SetDuration(duration)
        SetValue(startValue,endValue)
    End

    ' --- private methods ---
    Private
    Method UpdateValue()
        current = equation.Call(timeCurrent,start,change,duration)
    End
    Public

    ' --- value methods ---
    Method Value:Float()
        Return current
    End

    ' --- setup methods methods ---
    Method SetEquation(equation:TweenEquationCall)
        Self.equation = equation
    End

    Method SetDuration(duration:Int)
        Self.duration = duration
    End

    Method SetValue(startValue:Float,endValue:Float)
        start = startValue
        change = endValue - startValue
    End

    Method SetYoYo(flag:Bool)
        isYoYo = flag
    End

    Method SetLooping(flag:Bool)
        isLooping = flag
    End

    ' --- control methods ---
    Method Start()
        ' --- this will re-start the tween ---
        Rewind()
        isActive = True
        loopCount = 0
    End

    Method Stop()
        ' --- stop the tween from updating ---
		If isActive
        	isActive = False
			timePaused = Millisecs()
		EndIf
    End

	Method Resume:Void()
		' --- resume the tween from a paused state ---
		If isActive = False
			isActive = True
	
			'update the start timer!
			'get difference
			Local difference:= timePaused - timeStart
			
			'update timestamps
			timeCurrent = Millisecs()
			timeStart = timeCurrent - difference
			timePrevious = timeCurrent
			timePaused = 0
			
			Print "difference = " + difference
			Print "timeStart = " + timeStart
		EndIf
	End

    Method Rewind()
        ' --- put the tween at the start of its tween ---
        timeCurrent = 0
		timePaused = 0
        timeStart = Millisecs()
        UpdateValue()
    End

    Method FastForward()
        ' --- set the tween at the end ---
        timeCurrent = duration
        UpdateValue()
        Stop()
    End

    Method ContinueTo(endValue:Float,duration:Int=0)
        ' --- change the end target for teh value
        start = current
        SetValue(start,endValue)

        If isActive
            'isActive so need to continue operation
            If duration = 0
                'no duration specified so use previous duration!
                Self.duration = duration - timeCurrent
            Else
                'override duration
                Self.duration = duration
            Endif

            timeStart = Millisecs()
            timeCurrent = 0

            If duration <= 0
                duration = 0
                Stop()
            Endif
        Else
            If duration > 0 SetDuration(duration)
            Start()
        Endif
    End

    Method YoYo()
        ContinueTo(start)
    End

    ' --- class methods ---
    Method Update()
        If isActive
            'update the current time!
            timePrevious = timeCurrent
            Local time := Millisecs() - timeStart

            If time > duration
                'time is beyond length of tween
                If isLooping Or isYoYo
                    'increase the loop count
                    loopCount += 1

                    'look at yoyoing the values
                    If isYoYo
                        timeCurrent = duration
                        current = start + change

                        If isLooping Or loopCount <= 1
                            ContinueTo(start,duration)
                        Else
                            Stop()
                        Endif
                    Else
                        'wrap around the tween to the start
                        timeCurrent = 0'
                        timeStart = Millisecs()
                    Endif
                Else
                    'set the tween to the end
                    timeCurrent = duration
                    current = start + change
                    Stop()
                Endif
            Else If time < 0
                'time is before the start of the tween
                timeCurrent = 0
                timeStart = Millisecs()
                UpdateValue()
            Else
                'time is within the tween
                timeCurrent = time
                UpdateValue()
            Endif
        Endif
    End
End

Class TweenEquation
    ' --- really just a grouping class for user access ---
    Field EaseIn:TweenEquationCall
    Field EaseOut:TweenEquationCall
    Field EaseInOut:TweenEquationCall
End

Class TweenEquationCall
    ' --- base class to provide a call function pointer work around ---
    Method Call:Float(t:Float,b:Float,c:Float,d:Float) Abstract
End



'---------------
'Linear
Class TweenEquationCallLinear Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        Return c*t/d + b
    End
End

'---------------
'Sine
Class TweenEquationSine Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallSineEaseIn
        EaseOut = New TweenEquationCallSineEaseOut
        EaseInOut = New TweenEquationCallSineEaseInOut
    End
End

Class TweenEquationCallSineEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        'return -c * Cos(t / d * (PI / 2)) + c + b
        Return -c * Cos((t / d * (PI / 2)) * 57.2957795) + c + b
    End
End

Class TweenEquationCallSineEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        Return c * Sin((t/d * (PI/2)) * 57.2957795) + b
    End
End

Class TweenEquationCallSineEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        Return -c/2 * (Cos((PI*t/d) * 57.2957795) - 1) + b
    End
End



'---------------
'Back
Class TweenEquationBack Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallBackEaseIn
        EaseOut = New TweenEquationCallBackEaseOut
        EaseInOut = New TweenEquationCallBackEaseInOut
    End
End

Class TweenEquationCallBackEaseIn Extends TweenEquationCall
    Field s := 1.70158
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
		Return c * t * t * ((s + 1) * t - s) + b
    End
End

Class TweenEquationCallBackEaseOut Extends TweenEquationCall
    Field s := 1.70158
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = t / d - 1
		Return c * (t * t * ((s + 1) * t + s) + 1) + b
    End
End

Class TweenEquationCallBackEaseInOut Extends TweenEquationCall
    Field s := 1.70158
    Field s2:Float
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        s2 = s
        t /= d / 2
        s2 *= 1.525
		If t < 1
            Return c / 2 * (t * t *((s2+1) * t - s2)) + b
        Endif
		t -= 2
		Return c / 2 * (t * t * ((s2 + 1) * t + s2) + 2) + b
    End
End



'---------------
'Elastic
Class TweenEquationElastic Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallElasticEaseIn
        EaseOut = New TweenEquationCallElasticEaseOut
        EaseInOut = New TweenEquationCallElasticEaseInOut
    End
End

Class TweenEquationCallElasticEaseIn Extends TweenEquationCall
    Field p:Float
    Field a:Float
    Field s:Float

    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
		If t = 0 Return b
		t /= d
        If t = 1 Return b+c
        p = d *  0.3
		a = c
        s = p / 4
        t -= 1
		Return -(a * Pow(2,10 * (t)) * Sin(((t * d - s) * (2 * PI) / p) * 57.2957795)) + b
    End
End

Class TweenEquationCallElasticEaseOut Extends TweenEquationCall
    Field p:Float
    Field a:Float
    Field s:Float

    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
		If t = 0 Return b
		t /= d
        If t = 1 Return b+c
        p = d * 0.3
		a = c
        s = p / 4
		Return (a * Pow(2,-10 * t) * Sin(((t * d - s) * (2 * PI) / p) * 57.2957795) + c + b)
    End
End

Class TweenEquationCallElasticEaseInOut Extends TweenEquationCall
    Field p:Float
    Field a:Float
    Field s:Float

    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
		If t = 0 Return b
		t /= d / 2
        If t = 2 Return b+c
        p = d * (0.3 * 1.5)
		a = c
        s = p / 4
		If t < 1
            t -= 1
            Return -0.5 * (a * Pow(2,10 * t) * Sin(((t * d - s) * (2 * PI) / p) * 57.2957795)) + b
        Endif
        t -= 1
		Return a * Pow(2,-10 * t) * Sin(((t * d - s) * (2 * PI) / p) * 57.2957795) * 0.5 + c + b
    End
End



'---------------
'Bounce
Class TweenEquationBounce Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallBounceEaseIn
        EaseOut = New TweenEquationCallBounceEaseOut
        EaseInOut = New TweenEquationCallBounceEaseInOut
    End
End

Class TweenEquationCallBounceEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = (d-t) / d
		If t < 0.3636363
			Return c - (c * (7.5625 * t * t)) + b
		Else If t < 0.7272727
            t -= 0.5454545
			Return c - (c * (7.5625 * t * t + 0.75)) + b
		Else If t < 0.9090909
            t -= 0.8181818
			Return c - (c * (7.5625 * t * t + 0.9375)) + b
		Else
            t -= 0.9636363
			Return c - (c * (7.5625 * t * t + 0.984375)) + b
        Endif
    End
End

Class TweenEquationCallBounceEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
		If t < 0.3636363
			Return c *(7.5625 * t * t) + b
		Else If t < 0.7272727
            t -= 0.5454545
			Return c * (7.5625 * t * t + 0.75) + b
		Else If t < 0.9090909
            t -= 0.8181818
			Return c * (7.5625 * t * t + 0.9375) + b
		Else
            t -= 0.9636363
			Return c * (7.5625 * t * t + 0.984375) + b
        Endif
    End
End

Class TweenEquationCallBounceEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
		If t < d/2
            t = (d - t * 2) / d
    		If t < 0.3636363
    			Return (c - (c * (7.5625 * t * t))) * 0.5 + b
    		Else If t < 0.7272727
                t -= 0.5454545
    			Return (c - (c * (7.5625 * t * t + 0.75))) * 0.5 + b
    		Else If t < 0.9090909
                t -= 0.8181818
    			Return (c - (c * (7.5625 * t * t + 0.9375))) * 0.5 + b
    		Else
                t -= 0.9636363
    			Return (c - (c * (7.5625 * t * t + 0.984375))) * 0.5 + b
            Endif
        Else
            t = (t * 2 - d) / d
    		If t < 0.3636363
    			Return (c *(7.5625 * t * t)) * 0.5 + c * 0.5 + b
    		Else If t < 0.7272727
                t -= 0.5454545
    			Return (c * (7.5625 * t * t + 0.75)) * 0.5 + c * 0.5 + b
    		Else If t < 0.9090909
                t -= 0.8181818
    			Return (c * (7.5625 * t * t + 0.9375)) * 0.5 + c * 0.5 + b
    		Else
                t -= 0.9636363
    			Return (c * (7.5625 * t * t + 0.984375)) * 0.5 + c * 0.5 + b
            Endif
        Endif
    End
End



'---------------
'Circ
Class TweenEquationCirc Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallCircEaseIn
        EaseOut = New TweenEquationCallCircEaseOut
        EaseInOut = New TweenEquationCallCircEaseInOut
    End
End

Class TweenEquationCallCircEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return -c * (Sqrt(1 - t * t) - 1) + b
    End
End

Class TweenEquationCallCircEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = t / d - 1
        Return c * Sqrt(1 - t*t) + b
    End
End

Class TweenEquationCallCircEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d / 2
		If t < 1 Return -c / 2 * (Sqrt(1 - t * t) - 1) + b
		t -= 2
		Return c / 2 * (Sqrt(1 - t * t) + 1) + b
    End
End



'---------------
'Cubic
Class TweenEquationCubic Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallCubicEaseIn
        EaseOut = New TweenEquationCallCubicEaseOut
        EaseInOut = New TweenEquationCallCubicEaseInOut
    End
End

Class TweenEquationCallCubicEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return c * t * t * t + b
    End
End

Class TweenEquationCallCubicEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = t / d - 1
        Return c * (t * t * t + 1) + b
    End
End

Class TweenEquationCallCubicEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d / 2
		If t < 1 Return c / 2 * t * t * t + b
		t -= 2
		Return c / 2 *(t * t * t + 2) + b
    End
End



'---------------
'Expo
Class TweenEquationExpo Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallExpoEaseIn
        EaseOut = New TweenEquationCallExpoEaseOut
        EaseInOut = New TweenEquationCallExpoEaseInOut
    End
End

Class TweenEquationCallExpoEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        If t = 0 Return b
        Return c * Pow(2,10 * (t / d - 1)) + b
    End
End

Class TweenEquationCallExpoEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        If t = d Return b + c
        Return c * (-Pow(2,-10 * t / d) + 1) + b
    End
End

Class TweenEquationCallExpoEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
		If t =0 Return b
		If t = d Return b + c
		t /= d / 2
		If t < 1 Return c / 2 * Pow(2,10 * (t - 1)) + b
		t -= 1
		Return c / 2 * (-Pow(2,-10 * t) + 2) + b
    End
End



'---------------
'Quad
Class TweenEquationQuad Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallQuadEaseIn
        EaseOut = New TweenEquationCallQuadEaseOut
        EaseInOut = New TweenEquationCallQuadEaseInOut
    End
End

Class TweenEquationCallQuadEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return c * t * t + b
    End
End

Class TweenEquationCallQuadEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return -c * t * (t - 2) + b
    End
End

Class TweenEquationCallQuadEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d / 2
		If t < 1 Return c / 2 * t * t + b
		t -= 1
		Return -c / 2 * (t * (t - 2) - 1) + b
    End
End



'---------------
'Quart
Class TweenEquationQuart Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallQuartEaseIn
        EaseOut = New TweenEquationCallQuartEaseOut
        EaseInOut = New TweenEquationCallQuartEaseInOut
    End
End

Class TweenEquationCallQuartEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return c * t * t * t * t + b
    End
End

Class TweenEquationCallQuartEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = t / d-1
        Return -c * (t * t * t * t - 1) + b
    End
End

Class TweenEquationCallQuartEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d / 2
		If t < 1 Return c / 2 * t * t * t * t + b
        t -= 2
		Return -c / 2 * (t * t * t * t - 2) + b
    End
End



'---------------
'Quint
Class TweenEquationQuint Extends TweenEquation
    Method New()
        EaseIn = New TweenEquationCallQuintEaseIn
        EaseOut = New TweenEquationCallQuintEaseOut
        EaseInOut = New TweenEquationCallQuintEaseInOut
    End
End

Class TweenEquationCallQuintEaseIn Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d
        Return c * t * t * t * t * t + b
    End
End

Class TweenEquationCallQuintEaseOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t = t / d - 1
        Return c * (t * t * t * t * t + 1) + b
    End
End

Class TweenEquationCallQuintEaseInOut Extends TweenEquationCall
    Method Call:Float(t:Float,b:Float,c:Float,d:Float)
        t /= d / 2
		If t < 1 Return c / 2 * t * t * t * t * t + b
        t -= 2
		Return c / 2 * (t * t * t * t * t + 2) + b
    End
End

tweendemo.monkey

Import mojo
Import tween

Class myApp Extends App
    Field tween:Tween
    Field equations:String[] = ["Linear","Back","Bounce","Circ","Cubic","Elastic","Expo","Quad","Quart","Quint","Sine"]
    Field easeTypes:String[] = ["EaseIn","EaseOut","EaseInOut"]

    Field currentEquation:Int
    Field currentEaseType:Int
	Field paused:Bool

    Method OnCreate()
        SetUpdateRate(60)

        tween = New Tween(Tween.Linear,100,540,2000)
        tween.Start()
    End

    Method OnUpdate()
		If KeyHit(KEY_P)
			If paused = False
				If tween tween.Stop()
				paused = True
			Else
				If tween tween.Resume()
				paused = False
			EndIf
		EndIf
		
        If KeyHit(KEY_1) NextEquation()
        If KeyHit(KEY_2) NextEase()
        If KeyHit(KEY_SPACE)
            tween.Rewind()
            tween.Start()
        Endif
        tween.Update()
    End

    Method OnRender()
        SetColor(0,0,0)
        DrawRect(0,0,640,480)

        SetColor(100,100,100)
        DrawRect(88,198,464,24)

        SetColor(0,0,0)
        DrawRect(89,199,462,22)

        SetColor(255,255,255)
        DrawOval(tween.Value()-10,200,20,20)

        DrawText(EquationString(),5,5)
        DrawText("Press 1 to change tween equation",5,30)
        DrawText("Press 2 to change ease mode",5,45)
        DrawText("Press space to replay current selection", 5, 60)
		If paused
			DrawText("Press p to resume", 5, 75)
		Else
			DrawText("Press p to pause", 5, 75)
		EndIf
		
    End

    Method EquationString:String()
        If equations[currentEquation] = "Linear"
            Return "Tween.Linear"
        Else
            Return "Tween."+equations[currentEquation]+"."+easeTypes[currentEaseType]
        Endif
    End

    Method NextEquation()
        currentEquation += 1
        If currentEquation >= equations.Length() currentEquation = 0
        SetEquation1()
    End

    Method NextEase()
        currentEaseType += 1
        If currentEaseType >= easeTypes.Length() currentEaseType = 0
        SetEquation1()
    End

    Method SetEquation1()
        Select equations[currentEquation]
            Case "Linear"
                tween.SetEquation(Tween.Linear)
                tween.Rewind()
                tween.Start()
				paused = False
            Case "Back"
                SetEquation2(Tween.Back)
            Case "Bounce"
                SetEquation2(Tween.Bounce)
            Case "Circ"
                SetEquation2(Tween.Circ)
            Case "Cubic"
                SetEquation2(Tween.Cubic)
            Case "Elastic"
                SetEquation2(Tween.Elastic)
            Case "Expo"
                SetEquation2(Tween.Expo)
            Case "Quad"
                SetEquation2(Tween.Quad)
            Case "Quart"
                SetEquation2(Tween.Quart)
            Case "Quint"
                SetEquation2(Tween.Quint)
            Case "Sine"
                SetEquation2(Tween.Sine)
        End
    End

    Method SetEquation2(equation:TweenEquation)
        Select easeTypes[currentEaseType]
            Case "EaseIn"
                tween.SetEquation(equation.EaseIn)
                tween.Rewind()
                tween.Start()
            Case "EaseOut"
                tween.SetEquation(equation.EaseOut)
                tween.Rewind()
                tween.Start()
            Case "EaseInOut"
                tween.SetEquation(equation.EaseInOut)
                tween.Rewind()
                tween.Start()
        End
		paused = False
    End
End

Function Main()
    New myApp
End

Supertino

(Posted 2014) [#4]

Thanks Skn3 those additions work a treat. I actually went ahead and created my own but I lacked the fancy equations and easing etc. but now I'll switch back to yours =D

@Sammy thanks for the info on that millisecs() routine, I am sure I can make use of that.

My simple linear tween class in case anyone is interested (pssssst! use Skn3 code)

Class SimpleTween
	Field value:Float
	Field startTime:Int
	Field startValue:Float, endValue:Float
	Field duration:Int
	Field perFrameVector:Float
	Field isActive:Bool
	Field paused:Bool
	Field pauseTime:Int
	
	Method New(startValue:Float, endValue:Float, duration:Int)
		Self.startValue = startValue
		Self.endValue = endValue
		Self.duration = duration
	End Method
	
	Method Start:Void()
		Stop()
		Local FPS:Float = Float(UpdateRate)
		isActive = True
		startTime = Millisecs()
		perFrameVector = (endValue - startValue) / ( (FPS / 1000) * Float(duration))
	End Method
	
	Method Update:Void()
		If isActive = False Then Return
		If paused = True Then Return
		value = value + perFrameVector
		If (startTime + duration) < Millisecs() Then Stop()
	End Method
	
	Method Stop:Void()
		value = 0.0
		isActive = False
	End Method
	
	Method IsActive:Bool()
		Return isActive
	End Method
	
	Method Value:Float()
		Return value
	End Method
	
	Method Pause:Void()
		paused = True
		pauseTime = Millisecs()
	End Method
	
	Method Resume:Void()
		paused = False
		startTime = startTime + (Millisecs() -pauseTime)
	End Method
	
	Method SetValue:Void(startValue:Float, endValue:Float)
		Self.startValue = startValue
		Self.endValue = endValue
	End Method
	
	Method SetDuration:Void(duration:Int)
		Self.duration = duration
	End Method
	
End Class

Basic usage;

Global myTween:SimpleTween = New SimpleTween(0,200,2000) ' 2 second tween
myTween.Start ' call once to start Tween
myTween.Update ' call somewhere in OnUpdate
DrawOval myTween.Value,200,32 ' call somewhere in OnRender