Sorry your browser is not supported!

// define all the variables used
dim xpnts#[720] as float
dim ypnts#[720] as float

x# as float
y# as float
wl# as float
amp# as float
scrwid# as float
scrhih# as float
halfhih# as float
ticktop# as float
tickbot# as float
i as integer
l as integer
maxtick as integer

// get resolution and
scrwid# = GetDeviceWidth()
scrhih# = GetDeviceHeight()

// calculate some values
halfhih# = scrhih# / 2.0
ticktop# = halfhih# - 100.0
tickbot# = halfhih# + 100.0
maxtick = Floor(scrwid#/100.0)

// set resolution
setVirtualResolution(scrwid#, scrhih#)

// calculate the sine wave for
// one full wave
x# = 0.0
for i=1 to 360
	// store X as a value from 0.0 to 1.0
	xpnts#[i] = x# / 360.0

	// store Y as a value from -1.0 to 1.0
	ypnts#[i] = sin(x#)

	// increment X
	x# = x# + 1.0
next i

// now make the points to go back the other way
for i=361 to 720
	xpnts#[i] = xpnts#[720-i+1]
	ypnts#[i] = ypnts#[i-360]
next i

// make a dummy sprite (default size is 10x10)
spr = createSprite(0)

// set offset to center
SetSpriteOffset(spr,5.0,5.0)

// start at the first point
i = 1

// set the wavelength
wl# = 200.0

// set the amplitude
amp# = 40.0

// main loop
do
	// set up for exit
	if GetRawKeyPressed(27) then exit

	// draw a center line and some ticks
	DrawLine(0.0,halfhih#,scrwid#,halfhih#,255,255,255)
	for l=1 to 10
		DrawLine(0.0,halfhih#-l*10,scrwid#,halfhih#-l*10,128,128,128)
		DrawLine(0.0,halfhih#+l*10,scrwid#,halfhih#+l*10,128,128,128)
	next l
	for l=0 to maxtick
		DrawLine(l*100,ticktop#,l*100,tickbot#,255,255,255)
	next l

	// grab the points and apply amplitude and wave length
	x# = xpnts#[i] * wl#
	y# = ypnts#[i] * amp#

	// position the sprite
	setSpritePositionByOffset(spr, x#, y# + halfhih#)

	// update point in curve
	i = i + 1

	// go back to start if at end
	if i > 720 then i = 1

	print("X="+str(x#,2))
	print("Y="+str(y#,2))
	sync()
loop

    ` ***********************************
    ` ** 0. Linear 0 to 1
    ` ** cEFFECT_LINEAR
    ` ***********************************
    for n = 0 to 100
        arrEffectProgress[0,n] = (n * 1.0) / 100
    next n

    ` ***********************************
    ` ** 1. Fast-Slow
    ` ** cEFFECT_FS
    ` ***********************************
    for n = 0 to 100
        ang# = n * 0.9
        arrEffectProgress[1,n] = sin(ang#)
    next n

    ` ***********************************
    ` ** 2. Slow-Fast
    ` ** cEFFECT_SF
    ` ***********************************
    for n = 0 to 100
        ang# = 90 + (n * 0.9)
        arrEffectProgress[2,n] = 1 - sin(ang#)
    next n

    ` ***********************************
    ` ** 3. Quadratic 0 to 1
    ` ** cEFFECT_SFS
    ` ***********************************
    for n = 0 to 100
        ang# = (n * 1.8) + 270
        arrEffectProgress[3,n] = (sin(ang#) + 1) * 0.5
    next n

    ` ***********************************
    ` ** 4. Fast-Slow-Fast
    ` ** cEFFECT_PP_FSF
    ` ***********************************
    for n = 0 to 100
        ang# = (n * 1.8)
        arrEffectProgress[4,n] = 1 - sin(ang#)
    next n

    ` ***********************************
    ` ** 5. Quadratic Ping Pong (smooth transition between effects)
    ` ** cEFFECT_PP_SFS
    ` ***********************************
    for n = 0 to 100
        ang# = (n * 3.6) + 270
        arrEffectProgress[5,n] = (sin(ang#) + 1) * 0.5
    next n

    ` ***********************************
    ` ** 6. random progressive. Starts at 0, ends at 1, everything else can vary by 10%
    ` ** cEFFECT_RNDP
    ` ***********************************
    arrEffectProgress[6,0] = 0
    arrEffectProgress[6,100] = 1
    for n = 1 to 99
        offset# = (sin(n * 1.8) + 1) * 5   : ` Gives a maximum offset range of 10 at centre of curve
        thisVal# = (n * 1.0) / 100.0
        thisValOffset# = (thisVal# * offset#) / 100.0
        arrEffectProgress[6,n] = thisVal# - (thisValOffset# / 2) + (random(0, thisValOffset# * 100) / 100.0)
    next n

    ` ***********************************
    ` ** 7. random. Starts at 0, ends at 1, everything else random
    ` **    Each value used only once. This allows textures
    ` **    such as bitmaps fonts to be randomised while still
    ` **    using the full alphabet
    ` **    cEFFECT_RND
    ` ***********************************
    for n = 0 to 100
        arrEffectProgress[7,n] = (n * 1.0) / 100.0
    next n
    ` Switch all values between 1 and 99
    for Elem1 = 1 to 99
        Elem2 = random(1,98) + 1
        Val1# = arrEffectProgress[7,Elem1]
        arrEffectProgress[7,Elem1] = arrEffectProgress[7,Elem2]
        arrEffectProgress[7,Elem2] = Val1#
    next Elem1