Sorry your browser is not supported!

REM *** spriteToWorld by Steven Holding
REM *** NOTES
REM *** Two functions to get a world co-ordinate based on a point on a sprite
REM *** relative to it's centre of rotation (offset)
REM *** In a percentage based game this is done by percentage of the size of the
REM *** sprite, in a pixel based game this is done in pixels on the original image

function spriteToWorldX(spr,x#,y#)
	rem get sprite data
	a# = getSpriteAngle(spr)
	ox# = getSpriteXbyOffset(spr)
	
	rem get display data
	dw# = getVirtualWidth()
	dh# = getVirtualHeight()
	aspect# = (dw# / dh#)
	if aspect# = 1.0
        scaleX# = getSpriteWidth(spr)/100.0
        aspect# = getDisplayAspect()
        scaleY# = scaleX# * aspect#
	else
        aspect# = 1.0
		i = getSpriteImageID(spr)
        scaleX# = getSpriteWidth(spr)/getImageWidth(i)
        scaleY# = getSpriteHeight(spr)/getImageHeight(i)
    endif
	
	rem calculate value
	dx# = cos(a#) * (x# * scaleX#) - sin(a#) * (y# * scaleY#)
	wx# = ox# + dx#
endfunction wx#

function spriteToWorldY(spr,x#,y#)
	rem get sprite data
    a# = getSpriteAngle(spr)
    oy# = getSpriteYbyOffset(spr)
	
	rem get display data
	dw# = getVirtualWidth()
	dh# = getVirtualHeight()
	aspect# = (dw# / dh#)
	if aspect# = 1.0
        scaleX# = getSpriteWidth(spr)/100.0
        aspect# = getDisplayAspect()
        scaleY# = scaleX# * aspect#
	else
        aspect# = 1.0
		i = getSpriteImageID(spr)
        scaleX# = getSpriteWidth(spr)/getImageWidth(i)
        scaleY# = getSpriteHeight(spr)/getImageHeight(i)
    endif
    
	rem calculate value
    dy# = sin(a#) * (x# * scaleX#) + cos(a#) * (y# * scaleY#)
    wy# = oy# + dy# * aspect#
endfunction wy#

REM *** FadeSprite(sprite, speed, mode)
REM *** this function fades a sprite in and out, mode 0 will fade the sprite in, and mode 1 will fade it out


Function FadeSpride(sprite as integer, speed as float, mode as integer)
    Select mode
        Case 0 //fade in
            Alpha = GetSpriteColorAlpha(sprite)
            If Alpha > 255 then Alpha = 255
            If Alpha < 255
                SetSpriteColorAlpha( sprite, Alpha + speed )
            EndIf
        EndCase
        Case 1 //fade out
            Alpha = GetSpriteColorAlpha(sprite)
            If Alpha < 0 then Alpha = 0
            If Alpha > 0
                SetSpriteColorAlpha( sprite, Alpha - speed )
            EndIf
        EndCase
    EndSelect
EndFunction

//********************************************************************************
//
//	Debug Log Module
//
//********************************************************************************
//	As AGK currently offers no debug console, the DMGT debug is written to a log
//	file only.
//	To prevent cluttering of mobile devices there is only 1 file written.
//********************************************************************************

initDebug:
//********************************************************************************
//
//	Variables
//
//********************************************************************************

//********************************************************************************
//	Constants
//********************************************************************************

#constant true 1 : ` these are elsewhere in DMGT but have included them here for functionality.  remove if you declare these consts elsewhere in your code.
#constant false 0

//********************************************************************************
//	Types
//********************************************************************************

type tDebugLog
	fileID as integer
endtype


//********************************************************************************
//	Dimmed arrays
//********************************************************************************

dim debugLog[0] as tDebugLog


//********************************************************************************
//	Assign Values
//********************************************************************************


//********************************************************************************
//	Other init stuff
//********************************************************************************

//	Opens the file for writing
debugLog[0].fileID=openToWrite("dmgt_debugLog.txt",false) : ` append=false means file is overwritten if it exists

writeDebug("================================================================================")
writeDebug("Game title! (DMGT v1.0a) Debug log.")
writeDebug("(c) Whoever you are 2012, all rights reserved")
writeDebug("================================================================================")
writeDebug("Platform: "+GetDeviceName())

return

//	Just to be safe
end


//********************************************************************************
//
//	Functions
//
//********************************************************************************

//********************************************************************************
//	writeDebug(text$)
//********************************************************************************
//	writes the specified line to the debug file
//********************************************************************************

function writeDebug(text$)

	writeLine(debugLog[0].fileID,text$)

endfunction


//********************************************************************************
//	closeDebugLog()
//********************************************************************************
//	Closes the log file, use as part of tidy up and exit safely.
//********************************************************************************

function closeDebugLog()

	closefile(debugLog[0].fileID)

endfunction

//Calculate the distance in pixels between two X,Y Positions
function calculateDistance(xPosition1#, yPosition1#, xPosition2#, yPosition2#)
	distance# = 0
	b# = 0
	c# = 0
	if xPosition1# > xPosition2#
		b# = xPosition1# - xPosition2#
	elseif xPosition1# < xPosition2#
		b# = xPosition2# - xPosition1#
	endif

	if yPosition1# > yPosition2#
		c# = yPosition1# - yPosition2#
	elseif yPosition1# < yPosition2#
		c# = yPosition2# - yPosition1#
	endif

    distance# = sqrt((b# * b#) + (c# * c#))
endfunction distance#

//Calculate the angle in pixels between two X,Y Positions.
function calculateAngle(xPosition1#, yPosition1#, xPosition2#, yPosition2#)
	distance# = calculateDistance(xPosition1#, yPosition1#, xPosition2#, yPosition2#)
	angle# = 0
	c# = 0;

	if yPosition1# > yPosition2#
		c# = yPosition1# - yPosition2#
	elseif yPosition1# < yPosition2#
		c# = yPosition2# - yPosition1#
	endif

	if distance# > 0
		angle# = ASin(c# / distance#)
    endif
	//If the first position is above the second position
	if xPosition1# = xPosition2# and yPosition1# < yPosition2#
		angle# = 180
	//If the first position is below the second position
	elseif xPosition1# = xPosition2# and yPosition1# > yPosition2#
		angle# = 0
	//If the first position is to the left of the position
	elseif xPosition1# < xPosition2# and yPosition1# = yPosition2#
		angle# = 90
	//If the first position is to the right of the position
	elseif xPosition1# > xPosition2# and yPosition1# = yPosition2#
		angle# = 270
	//If the first position is to the right and above the position
	elseif xPosition1# > xPosition2# and yPosition1# < yPosition2#
		angle# = 270 - angle#
	//If the first position is to the left and above the position
	elseif xPosition1# < xPosition2# and yPosition1# < yPosition2#
		angle# = angle# + 90
	//If the first position is to the right and below the position
	elseif xPosition1# > xPosition2# and yPosition1# > yPosition2#
		angle# = angle# + 270
	//If the first position is to the left and below the position
	elseif xPosition1# < xPosition2# and yPosition1# > yPosition2#
		angle# = 90 - angle#
    endif
endfunction angle#

//Calculate the velocity of an object using the angle its moving, and its current speed in pixels per frame.
function calculateVelocity(angle#, speed#)
    dim velocity[2] as float
    velocity[0] = CosRad((angle# - 90) / 57.2957795) * speed#
    velocity[1] = SinRad((angle# - 90) / 57.2957795) * speed#
endfunction velocity

// Requires images to be wrapped instead of clamped when loaded.
// ***
// example image loading code
//
//    image = loadimage("Backdrop/1a.png")
//    SetImageWrapU(image , 1)
//    SetImageWrapV(image , 1)
//    sprite = createsprite(image)
//

//Usage example
//
// HScrollSprite(sprite, spite.u, 0.005, 1)
//
// Notes:
// Mode = 0 to 1 for direction
// Loaded images must be to power of 2, i.e. 16x16, 32x32, 64x64, 128x128, 256x256, 512x512, 1024x1024 etc etc

Function HScrollSprite(bg, u as float,  speed as float, mode)
    Select mode
        Case 0
            If u <= 0 then u = 1
            u = u + speed
            SetSpriteUVOffset(bg, u, 0)
        EndCase
        Case 1
            If u => 1 then u = 0
            u = u - speed
            SetSpriteUVOffset(bg, u, 0)
        EndCase
    EndSelect
EndFunction u

Function VScrollSprite(bg, v as float,  speed as float, mode)
    Select mode
        Case 0
            If v <= 0 then u = 1
            v = v + speed
            SetSpriteUVOffset(bg, 0, v)
        EndCase
        Case 1
            If v => 1 then v = 0
            v = v - speed
            SetSpriteUVOffset(bg, 0, v)
        EndCase
    EndSelect
EndFunction v

SetVirtualResolution(480,480)
sync()
myColor$ = ColorPick(30,20)

do
    print(myColor$)

    if myColor$ <> "CANCELLED"
        print(val(myColor$, 16))
        a$ = "Alpha:" + str(val(mid(myColor$,1,2),16))
        print(a$)
        r$ = "Red  :" + str(val(mid(myColor$,3,2),16))
        print(r$)
        g$ = "Green:" + str(val(mid(myColor$,5,2),16))
        print(g$)
        b$ = "Blue :" + str(val(mid(myColor$,7,2),16))
        print(b$)
    endif

    print("")
    print("Click to run again")
    Sync()
    if GetPointerReleased() = 1 then myColor$ = ColorPick(30,20)
loop

`********************************************************
Function ColorPick(x as integer, y as integer)

` feel free to load any image you want here
imgBackdrop = LoadImage("Missing.png")

yMin = y + 17
yMax = y + 17 + 255

cAlpha = 255
cRed = 255
cGreen = 255
cBlue = 255

sprBackground = CreateSprite(0)
SetSpritePosition(sprBackground, x, y)
SetSpriteSize(sprBackground, 294, 300)
SetSpriteColor(sprBackground, 128, 128, 128, 255)

sprMixerBackground = CreateSprite(imgBackdrop)
SetSpriteSize(sprMixerBackground, 100, 100)
SetSpritePosition(sprMixerBackground, x + 175, y + 12)

sprMixer = CreateSprite(0)
SetSpriteSize(sprMixer, 100, 100)
SetSpriteColor(sprMixer, cRed, cGreen, cBlue, cAlpha)
SetSpritePosition(sprMixer, x + 175, y + 12)

sprAccept = CreateSprite(0)
SetSpriteSize(sprAccept, 48, 20)
SetSpriteColor(sprAccept, 0, 255, 0, 255)
SetSpritePosition(sprAccept, x + 175, y + 262)

sprCancel = CreateSprite(0)
SetSpriteSize(sprCancel, 48, 20)
SetSpriteColor(sprCancel, 255, 0, 0, 255)
SetSpritePosition(sprCancel, x + 227, y + 262)

txtButtons = CreateText("OKAY QUIT")
SetTextSize(txtButtons, 16)
SetTextColor(txtButtons, 0, 0, 0, 255)
SetTextPosition(txtButtons, x + 180, y + 264)

sprTrack1 = CreateSprite(0)
SetSpriteSize(sprTrack1, 3, 256)
SetSpriteColor(sprTrack1, 200, 200, 200, 255)
SetSpritePosition(sprTrack1, x + 30, y + 22)

sprTrack2 = CloneSprite(sprTrack1)
SetSpritePosition(sprTrack2, x + 65, y + 22)

sprTrack3 = CloneSprite(sprTrack1)
SetSpritePosition(sprTrack3, x + 100, y + 22)

sprTrack4 = CloneSprite(sprTrack1)
SetSpritePosition(sprTrack4, x + 135, y + 22)

txtAlpha = CreateText("Alpha: " + str(cAlpha))
SetTextSize(txtAlpha, 16)
SetTextPosition(txtAlpha, x + 175, y + 120)

txtRed = CreateText("Red  : " + str(cRed))
SetTextSize(txtRed, 16)
SetTextPosition(txtRed, x + 175, y + 136)

txtGreen = CreateText("Green: " + str(cGreen))
SetTextSize(txtGreen, 16)
SetTextPosition(txtGreen, x + 175, y + 152)

txtBlue = CreateText("Blue : " + str(cBlue))
SetTextSize(txtBlue, 16)
SetTextPosition(txtBlue, x + 175, y + 168)

txtHexLabel = CreateText("Hex:")
SetTextSize(txtHexLabel, 16)
SetTextPosition(txtHexLabel, x + 175, y + 188)

hAlpha$ = hex(cAlpha)
if len(hAlpha$) = 1 then hAlpha$ = "0" + hAlpha$
hRed$ = Hex(cRed)
if len(hRed$) = 1 then hRed$ = "0" + hRed$
hGreen$ = Hex(cGreen)
if len(hGreen$) = 1 then hGreen$ = "0" + hGreen$
hBlue$ = Hex(cBlue)
if len(hBlue$) = 1 then hBlue$ = "0" + hBlue$

hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$

txtHex = CreateText(hColor$)
SetTextSize(txtHex, 16)
SetTextPosition(txtHex, x + 175, y + 204)

sprSliderA = CreateSprite(0)
SetSpriteSize(sprSliderA, 20, 10)
SetSpritePosition(sprSliderA, x + 22, y + 17)

sprSliderR = CloneSprite(sprSliderA)
SetSpritePosition(sprSliderR, x + 57, y + 17)
SetSpriteColor(sprSliderR, 255, 0, 0, 255)

sprSliderG = CloneSprite(sprSliderA)
SetSpritePosition(sprSliderG, x + 92, y + 17)
SetSpriteColor(sprSliderG, 0, 255, 0, 255)

sprSliderB = CloneSprite(sprSliderA)
SetSpritePosition(sprSliderB, x + 127, y + 17)
SetSpriteColor(sprSliderB, 0, 0, 255, 255)

`*** function input loop ***
do
    if GetPointerState() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprSliderA
        repeat
            y# = GetPointerY()
            if y# < yMin then y# = yMin
            if y# > yMax then y# = yMax
            SetSpritePosition(sprSliderA, x + 22, y#)
            cAlpha = 255 - (y# - yMin)
            hAlpha$ = hex(cAlpha)
            if len(hAlpha$) = 1 then hAlpha$ = "0" + hAlpha$
            hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$
            SetTextString(txtHex, hColor$)
            SetSpriteColorAlpha(sprMixer, cAlpha)
            SetTextString(txtAlpha, "Alpha: " + str(cAlpha))
            sync()
        until GetPointerState() = 0
    endif

    if GetPointerState() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprSliderR
        repeat
            y# = GetPointerY()
            if y# < yMin then y# = yMin
            if y# > yMax then y# = yMax
            SetSpritePosition(sprSliderR, x + 57, y#)
            cRed = 255 - (y# - yMin)
            hRed$ = Hex(cRed)
            if len(hRed$) = 1 then hRed$ = "0" + hRed$
            hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$
            SetTextString(txtHex, hColor$)
            SetSpriteColorRed(sprMixer, cRed)
            SetTextString(txtRed, "Red  : " + str(cRed))
            sync()
        until GetPointerState() = 0
    endif

    if GetPointerState() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprSliderG
        repeat
            y# = GetPointerY()
            if y# < yMin then y# = yMin
            if y# > yMax then y# = yMax
            SetSpritePosition(sprSliderG, x + 92, y#)
            cGreen = 255 - (y# - yMin)
            hGreen$ = Hex(cGreen)
            if len(hGreen$) = 1 then hGreen$ = "0" + hGreen$
            hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$
            SetTextString(txtHex, hColor$)
            SetSpriteColorGreen(sprMixer, cGreen)
            SetTextString(txtGreen, "Green: " + str(cGreen))
            sync()
        until GetPointerState() = 0
    endif

    if GetPointerState() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprSliderB
        repeat
            y# = GetPointerY()
            if y# < yMin then y# = yMin
            if y# > yMax then y# = yMax
            SetSpritePosition(sprSliderB, x + 127, y#)
            cBlue = 255 - (y# - yMin)
            hBlue$ = Hex(cBlue)
            if len(hBlue$) = 1 then hBlue$ = "0" + hBlue$
            hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$
            SetTextString(txtHex, hColor$)
            SetSpriteColorBlue(sprMixer, cBlue)
            SetTextString(txtBlue, "Blue : " + str(cBlue))
            sync()
        until GetPointerState() = 0
    endif

    if GetPointerReleased() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprAccept
        hColor$ = hAlpha$ + hRed$ + hGreen$ + hBlue$
        return$ = hColor$
        exit
    endif

    if GetPointerReleased() = 1 AND GetSpriteHit(GetPointerX(), GetPointerY()) = sprCancel
        return$ = "CANCELLED"
        exit
    endif

    sync()
loop

`*** cleanup ***
DeleteImage(imgBackdrop)
DeleteSprite(sprBackground)
DeleteSprite(sprMixerBackground)
DeleteSprite(sprTrack1)
DeleteSprite(sprTrack2)
DeleteSprite(sprTrack3)
DeleteSprite(sprTrack4)
DeleteSprite(sprMixer)
DeleteSprite(sprSliderA)
DeleteSprite(sprSliderR)
DeleteSprite(sprSliderG)
DeleteSprite(sprSliderB)
DeleteSprite(sprAccept)
DeleteSprite(sprCancel)

DeleteText(txtAlpha)
DeleteText(txtRed)
DeleteText(txtGreen)
DeleteText(txtBlue)
DeleteText(txtHexLabel)
DeleteText(txtHex)
DeleteText(txtDecimalLabel)
DeleteText(txtDecimal)
DeleteText(txtButtons)

EndFunction return$

SetDisplayAspect( 0.66 )

do
  rem print out how many segments there are in this string if split by a comma
  Print(str(SplitStringCount(",FOO,CAKE,BANANA,", ",")))
  rem test cases

  rem invalid segment (negative number)
  Print(SplitString(",FOO,CAKE,BANANA,", ",", -1))
  rem first segment
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 0))
  rem second segment
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 1))
  rem third segment
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 2))
  rem fourth segment
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 3))
  rem fifth segment
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 4))
  rem invalid segment (too high a number
  Print(SplitString(",FOO,CAKE,BANANA,", ",", 5))
  rem no delimiter found
    Print(SplitString(",FOO,CAKE,BANANA,", "!", 1))
 Sync()
loop

rem this gets the amount of 'segments' that a string can be split into
rem this is based off of 1, not 0.  so, if the string and delimiter you pass in
rem returns a counted valueof 3, you can get segments 0-2 from it.
function SplitStringCount(pString as string, pDelimiter as string)
    delimitCount as integer
    i as integer

    rem get length of string
    pStringLength as integer
    pStringLength = len(pString)

    rem parse through the string and count how many delimited chars there are
    for i = 0 to pStringLength - 1
        if mid(pString, i + 1, 1) = pDelimiter
            delimitCount = delimitCount + 1
        endif
    next i

    delimitCount = delimitCount + 1
endfunction delimitCount

rem this splits a string by its delimiter and will return one segment of it.
rem to see how many segments there are, use SplitStringCount.
rem NOTE: SplitString is 0-based, whereas SplitStringCount is 1-based.
rem       This is so that SplitStringCount will return a total value of segments (e.g., 3)
rem       and to access them in SplitString, you'll use values 0-2.

REM NOTE, if this function 'errors' out - e.g., invalid segment (negative number or too a high a number)
REM this function will return the ENTIRE string back to you.
REM if the function was successful, it will only send back a segment as the return value.
function SplitString(pString as string, pDelimiter as string, pSegment)
    delimitCount as integer
    myReturn as string
        myReturn = ""
    charCount as integer
    segmentCount as integer
    exitSearch as integer
    i as integer

    rem get the length of the original source string
    pStringLength as integer
    pStringLength = len(pString)

    rem count how many delimiters there are in the string
    for i = 0 to pStringLength - 1
        if mid(pString, i + 1, 1) = pDelimiter
            delimitCount = delimitCount + 1
        endif
    next i

    rem if there are no delimiters found in the original source string
    rem or there was an invalid segment number passed in (negative, too high a number)
    rem return the original source string
    if delimitCount = 0 or pSegment < 0 or pSegment > delimitCount
        exitfunction pString
    endif

    rem this is only applicable to the non-first segment.
    rem this finds the first character after a selected delimiter.
    rem if we wanted to split up 'foo,bar' and get the second segment, this would return the position of 'b'
    rem since the first letter of the first segment starts at 0, we can ignore it
    if pSegment > 0
        for i = 0 to pStringLength - 1
            charCount = charCount + 1

            if mid(pString, i + 1, 1) = pDelimiter
                segmentCount = segmentCount + 1

                if segmentCount = pSegment
                    exit
                endif
            endif
        next i
    endif

    rem return an empty string
    rem if the last character in the original source string was a delimiter:  foo,bar,
    if charCount >= pStringLength
        myReturn = ""
        exitfunction myReturn
    endif

    rem now we search through and add characters that we need to our return variable.
    rem keep adding eltters until we hit a delimiter or the string ends
    while exitSearch = 0 and charCount < pStringLength
        if mid(pString, charCount + 1, 1) = pDelimiter
            exitSearch = 1
        else
            myReturn = myReturn + mid(pString, charCount + 1, 1)
            charCount = charCount + 1
        endif
    endwhile

    rem return value
endfunction myReturn

#constant CONST_TIME_ELAPSED 0.01667

Function GetTimeElapsed()
     myReturn as float
     myReturn = TimeLastFrame()

     if myReturn > CONST_TIME_ELAPSED
        myReturn = CONST_TIME_ELAPSED
     Endif

Endfunction myReturn

// scale the specified sprite back to its 'pixel' size
function _Percent_To_Pixel( SpriteID as integer)
    SetSpriteScale(SpriteID, 100.0 / GetDeviceWidth(), 100.0 / GetDeviceWidth())
endfunction

// Set the display aspect
SetDisplayAspect( -1 )

// Load an image and make a sprite
Spr = CreateSprite( LoadImage("recircle.png") )
_Percent_To_Pixel( Spr )
do
    sync()
loop

// scale the specified sprite back to its 'pixel' size
function _Percent_To_Pixel( SpriteID as integer)
    SetSpriteScale(SpriteID, 100.0 / GetDeviceWidth(), 100.0 / GetDeviceWidth())
endfunction

rem utility functions
rem #################################################################
rem returns a string in the format "001" when passed 1, 3
function padNumberToString ( myVal, pad )
    fsReturn as string = str ( myVal )
    while len( fsReturn) < pad
        fsReturn = "0" + fsReturn
    endwhile
    fsReturn = right( fsReturn, pad )
endfunction fsReturn

REM LOAD IMAGES FROM A PROPERLY FORMATTED CSV FILE
REM EXAMPLE:
REM IMAGEID, IMAGEPATH, MAGFILTER, MINFILTER

REM PFILENAME IS PATH TO FILE, POVERWRITEEXISTING IS A NUMBER TO DELETE EXISTING IMAGE AND LOAD IN A NEW ONE. 0 KEEPS ORIGINAL IMAGES INTACT (IF ANY)

function LoadImagesFromCSV(pFileName as string, pOverwriteExisting as integer)
    REM MYRETURN VALUE
    REM TO STORE WHETHER OR NOT EVERYTHING COMPLETED SUCCESSFULLY
    REM 0 MEANS NO, 1 MEANS YES
    REM SET IT TO 1 INITIALLY, IF SOME ERROR OCCURS SET IT TO 0
    REM IF IT MAKES IT THROUGH THE ENTIRE FUNCTION NORMALLY, IT HAS COMPLETED SUCCESSFULLY!
    myReturn as integer
    myReturn = 1
	REM FILE ID THAT WE WORK WITH WHEN MANIPULATING THE FILE
	tFileID as integer

	REM TEMP VARIABLES USED FOR HOLDING DATA FROM THE CSV
	tImageID as integer
	tImagePath as string
	tMagFilter as integer
	tMinFilter as integer

	REM VARIABLE TO HOLD DATA BEING READ FROM THE CSV
	tString as string

    REM MAKE SURE FILE PASSED IN EXISTS
	if GetFileExists(pFileName) = 1

	REM GET FILE NAME AND FILE ID
	tFileID = opentoread(pFileName)

		REM LOOP UNTIL AT END OF FILE
        while fileEOF(tFileID) = 0

		REM READ IN LINE FROM FILE
		tString = readline(tFileID)

		   REM MAKE SURE THAT LINE IS NOT EMPTY
         	   if tString <> ""
                    REM GET FILE ID, PATH, MAG AND MIN FILTERS
                	tImageID = val(SplitString(tString, ",", 0))
                	tImagePath = SplitString(tString, ",", 1)
                	tMagFilter = val(SplitString(tString, ",", 2))
                	tMinFilter = val(SplitString(tString, ",", 3))

                    REM BEFORE WE DO ANY MANIPULATING WITH THE CURRENT DATA
                    REM MAKE SURE THE FILE EXISTS
                    if GetFileExists(tImagePath) = 1
                        REM DELETE ANY EXISTING IMAGE IF OVERWRITE IS ENABLED
                        REM AND IT ALREADY EXISTS
                        if pOverwriteExisting <> 0 and GetImageExists(tImageID) = 1
                            DeleteImage(tImageID)
                        endif

                        REM LOAD IMAGE =)
                        if GetImageExists(tImageID) = 0
                            loadImage(tImageID, tImagePath)
                            SetImageMagFilter(tImageID, tMagFilter)
                            SetImageMinFilter(tImageID, tMinFilter)
                        endif
                    else
                        REM IMAGE NOT FOUND.  RETURN 0
                        myReturn = 0
                    endif
 	           endif
        	endwhile

		REM CLOSE FILE
        closefile(tFileID)
    else
        REM CSV NOT FOUND. RETURN 0
        myReturn = 0
	endif

endfunction myReturn

Function PointerWithin( posX# as float,posY# as float,width# as float,height# as float )
   inArea = 0
   if GetPointerX( ) > posX# and GetPointerY( ) > posY# and GetPointerX( ) < posX# + width# and GetPointerY( ) < posY# + height#
      inArea = 1
   endif
Endfunction inArea

SetVirtualResolution( 1024,768 )

newText = CreateText( "Quit" )
SetTextSize( newText,64 )
rem center our new text
SetTextPosition( newText,( GetVirtualWidth ( ) /2.0 ) - ( GetTextTotalWidth( newText ) /2.0 ),( GetVirtualHeight ( ) / 2.0 ) - ( GetTextTotalHeight( newText ) /2.0 ) )

Do
    rem check if pointer (in this case the mouse) is within the text
    if PointerWithin( GetTextX( newText ),GetTextY( newText ),GetTextTotalWidth( newText ),GetTextTotalHeight(newText) )
        rem pointer is within - Pointer pressed then end application
        if GetPointerPressed( ) then end
    endif

    Sync( )
Loop

Function PointerWithin( posX# as float,posY# as float,width# as float,height# as float )
   inArea = 0
   if GetPointerX( ) > posX# and GetPointerY( ) > posY# and GetPointerX( ) < posX# + width# and GetPointerY( ) < posY# + height#
      inArea = 1
   endif
Endfunction inArea

REM WE WANT TO MAKE SURE TO LIMIT OUR TIMESTEPS IN OUR APPLICATION, AS HAVING TOO BIG OF A TIMESTEP IS A NIGHTMARE WHEN IT COMES TO COLLISION DETECTION

REM DECLARE GLOBAL CONSTANT
REM 60FPS TIMESTEP = 0.01667, 30FPS TIMESTEP = 0.03333
#constant CONST_TIME_ELAPSED 0.01667

REM STORE THE TIME IT TOOK TO COMPLETE LAST FRAME
global VALUE_TIME_ELAPSED as float

REM INSTEAD OF USING GETFRAMETIME(), USE THIS FUNCTION INSTEAD
REM X = X + (100 * GetTimeElapsed())
Function GetTimeElapsed()
Endfunction VALUE_TIME_ELAPSED


REM CALL THIS FUNCTION AT THE START OF EVERY FRAME!
REM OTHERWISE GETTIMEELAPSED() WILL ALWAYS RETURN 0!
REM
REM WHILE TRUE = TRUE
REM      UPDATETIMEELAPSED() 
REM      X = X + (100 * GETTIMEELAPSED())
REM      SYNC()
REM ENDWHILE
REM

Function UpdateTimeElapsed()
     REM UPDATE THE VARIABLE TO THE TIME IT TOOK TO RENDER LAST FRAME
     VALUE_TIME_ELAPSED = GetFrameTime()

     REM VERIFY THAT THE VARIABLE ISN'T EXCEEDING OUR LIMIT
     REM IF SO, SET IT TO THE LIMIT WE SET IN THE CONSTANT

     if VALUE_TIME_ELAPSED > CONST_TIME_ELAPSED
        VALUE_TIME_ELAPSED = CONST_TIME_ELAPSED
     Endif

Endfunction

Function GetTimeElapsed()
     REM INIT VARIABLE THAT WILL STORE THE TIME IT TAKES TO RENDER A FRAME
     myReturn as float
     myReturn = GetFrameTime()

     REM VERIFY THAT THE VARIABLE ISN'T EXCEEDING OUR TIMESTEP LIMIT OF 60FPS

     if myReturn  > 0.01667
        myReturn  = 0.01667
     Endif

Endfunction myReturn

REM *** spriteToWorldX by Steven Holding
REM *** NOTES
REM *** Two functions to get a world co-ordinate based on a point on a sprite
REM *** relative to it's centre of rotation (offset)
REM *** In a percentage based game this is done by percentage of the size of the
REM *** sprite, in a pixel based game this is done in pixels on the original image

function spriteToWorldX(spr,x#,y#)
	rem get sprite data
	a# = getSpriteAngle(spr)
	ox# = getSpriteXbyOffset(spr)
	
	rem get display data
	dw# = getVirtualWidth()
	dh# = getVirtualHeight()
	aspect# = (dw# / dh#)
	if aspect# = 1.0
		scaleX# = getSpriteWidth(spr)/100.0
		aspect# = getDisplayAspect()
		scaleY# = scaleX# * aspect#
	else
		aspect# = 1.0
		i = getSpriteImageID(spr)
		scaleX# = getSpriteWidth(spr)/getImageWidth(i)
		scaleY# = getSpriteHeight(spr)/getImageHeight(i)
	endif
	
	rem calculate value
	dx# = cos(a#) * (x# * scaleX#) - sin(a#) * (y# * scaleY#)
	wx# = ox# + dx#
endfunction wx#

function spriteToWorldY(spr,x#,y#)
	rem get sprite data
	a# = getSpriteAngle(spr)
	oy# = getSpriteYbyOffset(spr)
	
	rem get display data
	dw# = getVirtualWidth()
	dh# = getVirtualHeight()
	aspect# = (dw# / dh#)
	if aspect# = 1.0
		scaleX# = getSpriteWidth(spr)/100.0
		aspect# = getDisplayAspect()
		scaleY# = scaleX# * aspect#
	else
		aspect# = 1.0
		i = getSpriteImageID(spr)
		scaleX# = getSpriteWidth(spr)/getImageWidth(i)
		scaleY# = getSpriteHeight(spr)/getImageHeight(i)
	endif
    
	rem calculate value
	dy# = sin(a#) * (x# * scaleX#) + cos(a#) * (y# * scaleY#)
	wy# = oy# + dy# * aspect#
endfunction wy#

` *************************************************************************
function initFont()
` *** @H Initialises font registry
` *** @A arrFont[] as tFont
` *************************************************************************

    dim arrFont[1] as tFont
    arrFont[1].file = "default"

endfunction


` *************************************************************************
function registerFont(file$)
` *** @H checks for loaded font and registers/loads if not
` *** @H This function automatically loads the font image
` *** @V global fontCount
` *** @A arrFont[] as tFont
` *** @R ImageId of font
` *************************************************************************

    fontId = 0
    for n = 1 to gFontCount
        if arrFont[n].file = file$
            fontId = arrFont[n].image
        endif
    next n

    if fontId = 0
        gFontCount = gFontCount + 1
        dim arrFont[gFontCount] as tFont
        arrFont[gFontCount].file = file$
        arrFont[gFontCount].image = loadImage(file$)
        arrFont[gFontCount].loaded = 1
        fontId = arrFont[gFontCount].image
    endif

endfunction fontId

` *************************************************************************
` *** Types
` *************************************************************************
global gFontCount

type tFont
    file as string
    image
    loaded
endtype

// Locates the position of thisSearch$ within thisString$ starting from thisStart, Zero if not present
function inString ( thisString$ , thisSearch$ , thisStart )
	returnVal = 0
	thisLen = len ( thisSearch$ )
	for i=thisStart to ( len ( thisString$ ) - thisLen + 1 )
		if thisSearch$ = mid ( thisString$ , i , thisLen )
			returnVal = i
			exit
		endif
	next i
endfunction returnVal

dim myWordArray$ [ 10 ]
thisText$ = "The quick brown fox jumped over the lazy dog"
numWords = 0
thisEnd = 0
thisLen = len ( thisText$ )
repeat
	thisStart = thisEnd + 1
	thisEnd = inString ( thisText$ , " " , thisStart )
	if thisEnd = 0 then thisEnd = thisLen + 1
	inc numWords, 1
	myWordArray$ [ numWords ] = mid ( thisText$ , thisStart , thisEnd - thisStart )
until thisEnd > thisLen

for i=1 to numWords
	print ( "Word " + str ( i ) + " = " + chr ( 34 ) +  myWordArray$ [ i ] + chr ( 34 ) )
next i

thisLine$ = "textsize=20"
thisSplit = instring ( thisLine$ , "=" , 1 )
thisParam$ = left ( thisLine$ , thisSplit - 1 )
thisValue$ = right ( thisLine$ , len (thisLine$) - thisSplit )

print ("Parameter = " + chr(34) + thisParam$ + chr (34) )
print ("Value = " + chr(34) + thisValue$ + chr (34) )

//  Access a portion of thisString$ when split using delimiter in thisDelimiter$
//  returns the nth occurrance - starting at 1 for first.
//  "" returned if thisOccurance is greater than number portions
function SplitStringNew( thisString$ , thisDelimiter$ , thisOccurance )
	thisFound = 0
	thisEnd = 0
	thisLen = len ( thisString$ )
	repeat
		thisStart = thisEnd + 1
		thisEnd = inString ( thisString$ , thisDelimiter$ , thisStart )
		if thisEnd = 0 then thisEnd = thisLen + 1
		inc thisFound, 1
	until thisFound = thisOccurance or thisEnd > thisLen
	if thisFound = thisOccurance
		thisReturn$ = mid ( thisString$ , thisStart , thisEnd - thisStart )
	else
		thisReturn$ = ""
	endif
endfunction thisReturn$

	thisText$ = "The quick brown fox jumped over the lazy dog"
	thisWord = 1
	repeat
		thisWord$ = SplitStringNew( thisText$ , " " , thisWord )
		if thisWord$ <> ""
			print ( "Word " + str ( thisWord ) + " = " + chr ( 34 ) +  thisWord$ + chr ( 34 ) )
			inc thisWord , 1
		endif
	until thisWord$ = ""

// Randomization Function
// Sets the seed value of SetRandomSeed
// Timer() doesn't work well for generating a seed value
// Instead use this function that takes a low starting value and a high starting value
// Generates a seed value for using in SetRandomSeed()
// Usage: SetRandomizationSeed(1,65535)
//

FUNCTION SetRandomizationSeed(lowValue,highValue)

    IF lowValue = highValue
        lowValue = highValue - lowValue
    ENDIF

    IF lowValue <= 0
        lowValue = 1
    ENDIF

    IF highValue <= lowValue
        highValue = lowValue+lowValue
    ENDIF

    r1 = Random(lowValue,highValue)
    r2 = r1*r1
    r1 = Random(r1,r2)
    r1 = r1*timer()
    SetRandomSeed(r1)

ENDFUNCTION

function counter_MSS(time#)
time=ceil(time#)-1
timervalueMIN$=str(time/60)
timervalueSEC$=str(mod(time,60))
if mod(time,60)<10
 timeprint$=timervalueMIN$+":"+"0"+timervalueSEC$
else timeprint$=timervalueMIN$+":"+timervalueSEC$
endif
endfunction timeprint$

function counter_HMMSS(time#)
time=ceil(time#)-1
 timervalueHOUR=time/3600
 timervalueMIN=time/60
 timervalueSEC=mod(time,60)
if timervalueMIN>=60 then timervalueMIN=timervalueMIN-60
printvalueHOUR$=str(timervalueHOUR)
if timervalueMIN<10
printvalueMIN$="0"+str(timervalueMIN)
else
printvalueMIN$=str(timervalueMIN)
endif
if timervalueSEC<10
printvalueSEC$="0"+str(timervalueSEC)
else
printvalueSEC$=str(timervalueSEC)
endif
timeprint$=printvalueHOUR$+":"+printvalueMIN$+":"+printvalueSEC$
endfunction timeprint$

REM *** Rainbow Text by Steven Holding
REM *** Makes text rainbow coloured. If used in every loop the colours rotate.

function rainbowText(textID)
	l = GetTextLength(textID)
	f# = 180.0/l#
	for ch=0 to l
		colour# = abs(sin(timer()*240.0+ch*f#))
		red#=(1.0-colour#)*255.0
		grn#=abs(0.5-colour#)*510
		blu#=255.0 - red#
		setTextCharColor(textID,ch,red#,grn#,blu#,255)
	next
endfunction

Function _GetDistance( x1#, y1#, x2#, y2#)
    Distance# = sqrt((x1# - x2#)^2 + (y1# - y2#)^2)
Endfunction Distance#

Function _Factorial( Number as integer )
    // Local
    Factorial as integer
    Factorial = Number

    If Number = 0
        Factorial = 1
    Else
        For n = Number-1 to 1 step -1
            Factorial = Factorial * n
        Next n
    Endif

Endfunction Factorial

Function _DegreesToRad( Angle# )
    Angle# = Angle * (3.14159265 / 180.0)
Endfunction Angle#

Function _RadToDegrees( Radians# )
    Radians# = Radians# * (180.0 / 3.14159265)
Endfunction Radians#

// clock timer(s)
Function _MSTimer( Num_Minutes, Num_Seconds, Reset )
    Global Dim Minutes[0] as integer
    Global Dim Seconds[0] as integer
    Global Dim Old_Time#[0] as float

    If Reset = 1
        Minutes[0] = Num_Minutes
        Seconds[0] = Num_Seconds
        Old_Time#[0] = 0.0
    Endif



    // time variable to store the 'old time'

    If Timer() - Old_Time#[0] > 1.0
        Seconds[0] = Seconds[0] - 1
        If Seconds[0] < 0
            Seconds[0] = 60
            Minutes[0] = Minutes[0] - 1
        Endif
        Old_Time#[0] = Timer()
    Endif

    Time$ = Str(Minutes[0]) + " : " + str(Seconds[0])

Endfunction Time$

#constant PI 3.14159265358979

function Hermite( startValue as float, endValue as float, value as float)
    result# = Lerp(startValue, endValue, value * value * (3.0 - 2.0 * value))
endfunction result#

function Sinerp( startValue as float, endValue as float, value as float)
    result# = Lerp( startValue, endValue, sin(value * PI * 0.5))
endfunction result#

function Coserp( startValue as float, endValue as float, value as float)
    result# = Lerp(startValue, endValue, 1.0 - cos(value * PI * 0.5))
endfunction result#

function Bounce(x as float)
    result# =  abs(sin(6.28*(x+1)*(x+1)) * (1-x))
endFunction result#

function Berp( startValue as float, endValue as float , value as float )
    value = Clamp(0, 1, value)
    value = (sin(value * PI * (0.2 + 2.5 * value * value * value)) * Pow(1.0 - value, 2.2) + value) * (1.0 + (1.2 * (1.0 - value)))
    result# = startValue + (endValue - startValue) * value
endfunction result#

function Lerp( startValue as float, endValue as float , value as float )
    result# = ((1.0 - value) * startValue) + (value * endValue)
endfunction result#

function SmoothStep( x as float, min as float, max as float)
        x = Clamp (x, min, max)
        v1# = (x-min)/(max-min)
        v2# = (x-min)/(max-min)
        result# = -2*v1 * v1 *v1 + 3*v2 * v2
endfunction result#

function Approx( value as float, target as float, range as float)
    result = (( abs(value - target) < range) )
endfunction result

function Clerp( startValue as float, endValue as float, value as float )
        min# = 0.0
        max# = 360.0
        half# = abs((max# - min#)/2.0)
        retval# = 0.0
        diff# = 0.0

        if (endValue - startValue) < -half#
            diff = ((max - startValue) + endValue) * value
            retval# =  startValue + diff#
        elseif (endValue - startValue) > half#
            diff# = -((max# - endValue) + startValue) * value
            retval# =  startValue + diff#
        else
            retval# = startValue + (endValue - startValue) * value
        endif
endfunction retval#

function Pow( base as float, exp as float )
    result# = base ^ exp
endfunction result#

function Clamp( min as float, max as float, value as float)
    if value < min then exitfunction min
    if value > max then exitfunction max
endfunction value