Sorry your browser is not supported!

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

setVirtualResolution(480,480)

spr = createSprite(loadImage("avatar.png"))
setSpritePosition(spr, 0,0)
x = 0
do
    inc x,1
    setspritePosition(spr, x, bounce2(x))
    print(x)
    print(bounce2(x))
    print(getSpriteY(spr))
    sync()
loop

function bounce2(x) 
    h = getVirtualHeight()
    w = getVirtualWidth()
    ans# = h-abs(sin(x)*(w-x))
endfunction ans#

function bounce2(x#, count)
    w# = x# * (count * 180)
    ans# = abs(sin(w#)*(1.0-x#))
endfunction ans#

function round_decimal(floatval#,round_to)
    value$ = str(floatval#)
    for x = 1 to Len( value$ )
    check$ = left(value$,x)
    if right(check$,1) = "."
        roundedvalue$ = left(value$,x+round_to)
        exitfunction roundedvalue$
    endif
    next x
endfunction roundedvalue$

// Use this function first ! This function initialise SuperGenesisEngine
function InitSGE(ScreenSizeX,ScreenSizeY,TileSizeX,TileSizeY,WorldSizeX,WorldSizeY,WorldSizeOfDepth)
    setvirtualresolution(ScreenSizeX,ScreenSizeY)
    global dim SGE_World_Map[WorldSizeOfDepth,WorldSizeX,WorldSizeY]
    global dim SGE_World_Position_X[WorldSizeOfDepth]
    global dim SGE_World_Position_Y[WorldSizeOfDepth]
    global dim SGE_World_Depth_Visible[WorldSizeOfDepth]
    Global SGE_WorldBankImage$

    global SGE_Camera_Position_X , SGE_Camera_Position_Y , SGE_W_SizeOfDepth , SGE_ScreenSizeX , SGE_ScreenSizeY , SGE_TileSizeX , SGE_TileSizeY , SGE_WorldSizeX , SGE_WorldSizeY
    global SGE_Camera_Limit_X , SGE_Camera_Limit_Y

    SGE_W_SizeOfDepth = WorldSizeOfDepth
    SGE_ScreenSizeX = ScreenSizeX
    SGE_ScreenSizeY = ScreenSizeY
    SGE_TileSizeX = TileSizeX
    SGE_TileSizeY = TileSizeY
    SGE_WorldSizeX = WorldSizeX
    SGE_WorldSizeY = WorldSizeY

    SGE_Camera_Limit_X = SGE_WorldSizeX*SGE_TileSizeX-SGE_ScreenSizeX-SGE_TileSizeX
    SGE_Camera_Limit_Y = SGE_WorldSizeY*SGE_TileSizeY-SGE_ScreenSizeY-SGE_TileSizeY

    SizeX = ScreenSizeX / TileSizeX + 1
    SizeY = ScreenSizeY / TileSizeY + 1

    global dim SGE_World_SpriteID[WorldSizeOfDepth,SizeX,SizeY]

    ImageDummy = getimage(0,0,TileSizeX-1,TileSizeY-1)

    for Depth = 0 to WorldSizeOfDepth
        for Y = 0 to SizeY
            for X = 0 to SizeX
                SGE_World_SpriteID[Depth,X,Y] = createsprite(ImageDummy)
                setspritedepth(SGE_World_SpriteID[Depth,X,Y],10000-Depth*100)
                setspriteposition(SGE_World_SpriteID[Depth,X,Y],X*TileSizeX,Y*TileSizeY)
                SetSpriteSize(SGE_World_SpriteID[Depth,X,Y],TileSizeX,TileSizeY)
                SetSpriteTransparency(SGE_World_SpriteID[Depth,X,Y],1)
                FixSpriteToScreen(SGE_World_SpriteID[Depth,X,Y],1)
            next X
        next Y
    next Depth
endfunction

function Draw(com$,num$)
        print(com$)
        print(num$)
        sync()
endfunction

function LoadTileBankImage(File$,BorderLineSize)
    global SGE_BorderLineSize
    SGE_BorderLineSize = BorderLineSize
    BankID = loadimage(File$)
    SGE_WorldBankImage$ = File$
    NBimageX = (getimagewidth(BankID)-BorderLineSize)/(SGE_TileSizeX+BorderLineSize)
    NBimageY = (getimageheight(BankID)-BorderLineSize)/(SGE_TileSizeY+BorderLineSize)
    Global SGE_MaxTileImage
    SGE_MaxTileImage = NBimageX*NBimageY

    global dim SGE_TileImageID[SGE_MaxTileImage]
    global dim SGE_TileAnimationImageID[SGE_MaxTileImage]
    global dim SGE_TileAnimationTimer[SGE_MaxTileImage]
    global dim SGE_TileAnimationFrameImage[SGE_MaxTileImage,30]
    global dim SGE_TileAnimationFrameTime[SGE_MaxTileImage,30]
    global dim SGE_TileAnimationCurrentFrame[SGE_MaxTileImage]

    for Y = 0 to NBimageY-1
        for X = 0 to NBimageX-1
            SGE_TileImageID[NBimage] = copyimage(BankID,X*(SGE_TileSizeX+BorderLineSize)+BorderLineSize,Y*(SGE_TileSizeY+BorderLineSize)+BorderLineSize,SGE_TileSizeX,SGE_TileSizeY)
            SGE_TileAnimationImageID[NBimage] = SGE_TileImageID[NBimage]
            SGE_TileAnimationFrameImage[NBimage,0] = NBimage
            inc NBimage
            NBI# = NBimage
            NBM# = SGE_MaxTileImage
            Progress# = (NBI#/NBM#)*100
            Draw("Loading Tile...",str(Progress#,1)+" %")
        next X
    next Y

    deleteimage(BankID)
endfunction

function SetTileAnimation(Animation,Frame,Tile,Time)
    SGE_TileAnimationFrameTime[Animation,Frame] = Time
    SGE_TileAnimationFrameImage[Animation,Frame] = Tile
endfunction

function RefreshTileAnimation()
    TileTimer = getmilliseconds()
    for Tile = 0 to SGE_MaxTileImage
        if TileTimer-(SGE_TileAnimationTimer[Tile]+SGE_TileAnimationFrameTime[Tile,SGE_TileAnimationCurrentFrame[Tile]]) >= SGE_TileAnimationFrameTime[Tile,SGE_TileAnimationCurrentFrame[Tile]]
            SGE_TileAnimationCurrentFrame[Tile] = SGE_TileAnimationCurrentFrame[Tile] + 1
            if SGE_TileAnimationFrameTime[Tile,SGE_TileAnimationCurrentFrame[Tile]] = 0
                SGE_TileAnimationCurrentFrame[Tile] = 0
            endif
            SGE_TileAnimationTimer[Tile] = TileTimer
            SGE_TileAnimationImageID[Tile] = SGE_TileImageID[SGE_TileAnimationFrameImage[Tile,SGE_TileAnimationCurrentFrame[Tile]]]
        endif
    next Tile
endfunction

function AddTileToWorld(TileID,PositionX,PositionY,Depth)
    if PositionX <= SGE_WorldSizeX and PositionX >= 0 and Depth >= 0 and Depth <= SGE_W_SizeOfDepth and PositionY <= SGE_WorldSizeY and PositionY >= 0
        SGE_World_Map[Depth,PositionX,PositionY] = TileID
    endif
endfunction

function SetWorldDepthVisible(Depth,Visible)
    if Depth >= 0 and Depth <= SGE_W_SizeOfDepth
        if Visible >=0 and Visible <= 1
            SGE_World_Depth_Visible[Depth] = Visible
            SizeX = SGE_ScreenSizeX / SGE_TileSizeX + 1
            SizeY = SGE_ScreenSizeY / SGE_TileSizeY + 1
            for Y = 0 to SizeY
                for X = 0 to SizeX
                    setspritevisible(SGE_World_SpriteID[Depth,X,Y],Visible)
                next X
            next Y
        endif
    endif
endfunction

function SetTileCameraPosition(CameraPositionX,CameraPositionY)
    SGE_Camera_Position_X = CameraPositionX
    SGE_Camera_Position_Y = CameraPositionY
endfunction

function FillWorld(TileID,Depth)
    for Y = 0 to SGE_WorldSizeX
        for X = 0 to SGE_WorldSizeY
            AddTileToWorld(TileID,X,Y,Depth)
        next X
    next Y
endfunction

function FillZoneWorld(TileID,TopX,TopY,Lenght,Height,Depth)
    for Y = TopY to TopY+Height
        for X = TopX to TopX+Lenght
            AddTileToWorld(TileID,X,Y,Depth)
        next X
    next Y
endfunction

function SaveWorld(WorldName$)
    WorldName$ = WorldName$ + ".wld"
    ID_File = opentowrite(WorldName$)
    writeinteger(ID_File,SGE_WorldSizeX)
    writeinteger(ID_File,SGE_WorldSizeY)
    writeinteger(ID_File,SGE_W_SizeOfDepth)
    writeinteger(ID_File,SGE_BorderLineSize)
    writestring(ID_File,SGE_WorldBankImage$)
    for Depth = 0 to SGE_W_SizeOfDepth
        for Y = 0 to SGE_WorldSizeY
            for X = 0 to SGE_WorldSizeX
                writeinteger(ID_File,SGE_World_Map[Depth,X,Y])
            next X
        next Y
    next Depth
    closefile(ID_File)
endfunction

function LoadWorld(WorldName$)
    WorldName$ = WorldName$ + ".wld"
    ID_File = opentoread(WorldName$)
    SGE_WorldSizeX = readinteger(ID_File)
    SGE_WorldSizeY = readinteger(ID_File)
    SGE_W_SizeOfDepth = readinteger(ID_File)
    SGE_BorderLineSize = readinteger(ID_File)
    SGE_WorldBankImage$ = readstring(ID_File)
    for Depth = 0 to SGE_W_SizeOfDepth
        for Y = 0 to SGE_WorldSizeY
            for X = 0 to SGE_WorldSizeX
                SGE_World_Map[Depth,X,Y] = readinteger(ID_File)
            next X
        next Y
    next Depth
    closefile(ID_File)
    LoadTileBankImage(SGE_WorldBankImage$,SGE_BorderLineSize)
endfunction

function TestInputX()
    MX# = GetRawJoystickX(Joy_0_ID)
    MoveX = round(MX#)
endfunction MoveX

function TestInputY()
    MY# = GetRawJoystickY(Joy_0_ID)
    MoveY = round(MY#)
endfunction MoveY

function RenderWorld()
    RefreshTileAnimation()
    if SGE_Camera_Position_X <= SGE_Camera_Limit_X and SGE_Camera_Position_Y <= SGE_Camera_Limit_Y and SGE_Camera_Position_X >=0 and SGE_Camera_Position_Y >= 0
        TileStartX = SGE_Camera_Position_X / SGE_TileSizeX
        TileStartY = SGE_Camera_Position_Y / SGE_TileSizeY
        TileStopX = (SGE_Camera_Position_X + SGE_ScreenSizeX) / SGE_TileSizeX
        TileStopY = (SGE_Camera_Position_Y + SGE_ScreenSizeY) / SGE_TileSizeY
        PositionScreenX = TileStartX * SGE_TileSizeX - SGE_Camera_Position_X
        PositionScreenY = TileStartY * SGE_TileSizeY - SGE_Camera_Position_Y

        for Depth = 0 to SGE_W_SizeOfDepth
            PosY = PositionScreenY
            SprID_Y = 0
            if SGE_World_Depth_Visible[Depth] = 1
                for Y = TileStartY to TileStopY
                    PosX = PositionScreenX
                    SprID_X = 0
                    for X = TileStartX to TileStopX
                        setspriteposition(SGE_World_SpriteID[Depth,SprID_X,SprID_Y],PosX,PosY)
                        setspriteimage(SGE_World_SpriteID[Depth,SprID_X,SprID_Y],SGE_TileAnimationImageID[SGE_World_Map[Depth,X,Y]])
                        inc PosX,SGE_TileSizeX
                        inc SprID_X
                    next X
                    inc PosY,SGE_TileSizeY
                    inc SprID_Y
                next Y
            endif
        next Depth
    endif
endfunction

function DemoSGE()
if GetJoystickExists() = 1
    global Joy_0_ID
    Joy_0_ID = GetRawJoystickExists(1)
endif

// InitSGE(ScreenSizeX , ScreenSizeY, TileSizeX , TileSizeY, Number of tile in world lenght , Number of tile in world height, Number of depth world)
InitSGE(320,240,16,16,400,300,0)

//charging an image containing all the tiles
// LoadTileBankImage( File Name , size of the gap between each tile)
LoadTileBankImage("GB_Tiles.png",1)

// Depth 0 with grass
    FillWorld(182,0)

    //FillZoneWorld(TileID,TopX,TopY,Lenght,Height,Depth)
    FillZoneWorld(157,10,10,10,5,0)// water
    FillZoneWorld(115,10,9,10,0,0)// border top
    FillZoneWorld(199,10,16,10,0,0)// border bottom
    FillZoneWorld(155,9,10,0,5,0)// border left
    FillZoneWorld(159,21,10,0,5,0)// border right
    AddTileToWorld(134,9,9,0)
    AddTileToWorld(138,21,9,0)
    AddTileToWorld(180,21,16,0)
    AddTileToWorld(176,9,16,0)

    FillZoneWorld(242,0,18,40,2,0)// sand
    FillZoneWorld(264,0,17,19,0,0)
    FillZoneWorld(264,22,17,19,0,0)

    FillZoneWorld(209,0,21,40,0,0)//sea
    SetTileAnimation(209,0,209,500)
    SetTileAnimation(209,1,188,200)

    FillZoneWorld(209,0,21,40,0,0)

SetWorldDepthVisible(0,1)

do
CamX = CamX + TestInputX()
CamY = CamY + TestInputY()
SetTileCameraPosition(CamX,CamY)
RenderWorld()
sync()
loop

endfunction

rem start points
        x0#=0
        y0#=400

        rem left curve points
        x1#=200
        y1#=200

        rem right curve points
        x2#=400
        y2#=200

        rem end points
        x3#=700
        y3#=400

    WHILE t# < 1
        t# = t# + 0.1 rem make this a smaller increment to slow it down, or larger to make it faster.

        rem call the bezier functions, while passing the adjusted t#
        SetSpriteX(testSprite, CubicBezierCurveX#(x1#, x2#, t#))
        SetSpriteY(testSprite, CubicBezierCurveY#(y1#, y2#, t#))
        
        Sync()
    ENDWHILE

FUNCTION CubicBezierCurveY#(y1# as float, y2# as float, t# as float)
    rem y0# is your starting point
    rem y1# is your left curve point
    rem y2# is your right curve point
    rem y3# is your destination point.
    rem t# is the current point on the curve.
    cy#=3*(y1#-y0#)
    by#=3*(y2#-y1#)-cy#
    ay#=y3#-y0#-cy#-by#
    yt#=ay#*(t#^3)+by#*(t#^2)+cy#*t#+y0#
ENDFUNCTION yt#

FUNCTION CubicBezierCurveX#(x1# as float, x2# as float, t# as float)
    rem x0# is your starting point
    rem x1# is your left curve point
    rem x2# is your right curve point
    rem x3# is your destination point.
    rem t# is the current point on the curve.
    cx#=3*(x1#-x0#)
    bx#=3*(x2#-x1#)-cx#
    ax#=x3#-x0#-cx#-bx#
    xt#=ax#*(t#^3)+bx#*(t#^2)+cx#*t#+x0#
ENDFUNCTION xt#

Function Split(text$)

   count = countStringTokens(text$, " ")
   for n = 1 to clamp(count,1,60)
        split$[n] = getStringToken(text$," ",n)
   next n
   
EndFunction

function LimitFloat(a#,min#,max#)

    if a#<min#
        a#=min#
        exitfunction a#
    endif
    if a#>max#
        a#=max#
        exitfunction a#
    endif

endfunction a#

function LimitInteger(a,min,max)

    if a<min
        a=min
        exitfunction a
    endif
    if a>max
        a=max
        exitfunction a
    endif

endfunction a

function LimitFloat(a#,min#,max#)
    if a#<min#
        a#=min#
        exitfunction a#
    endif
    if a#>max#
        a#=max#
        exitfunction a#
    endif
endfunction a#

function LimitFloat(a#,min#,max#)
    if a#<min# then exitfunction min#
    if a#>max# then exitfunction max#
endfunction a#

Type Sensor_Type
    fCentre as Float
    iSet as Integer
EndType

Global Sensor as Sensor_Type

SetVirtualResolution( 480, 480 )

Box = CreateSprite( 0 )
SetSpriteSize( Box, 50, 50 )
SetSpriteOffset( Box, 25, 25 )
SetSpritePositionByOffset( Box, 240, 240)

Sensor.iSet = 1

Do

    SetSensor( Sensor.iSet )
    SetSpritePositionByOffset( Box, GetSpriteXByOffset( Box ) + SensorX( 0.25, 0.05, 5 ), GetSpriteYByOffset( Box ) + SensorY( 0.25, 0.05, 5 ) )
    BackEnd()

Sync()
Loop

Function BackEnd()

    If GetRawKeyPressed( 27 ) then End

EndFunction

Function SetSensor( mode )

    Select mode

        Case 1

            Repeat
                Print( "Tap screen to set sensor.")
                Sensor.fCentre = GetDirectionY()
                Sync()
            Until GetPointerPressed() = 1
            Sensor.iSet = 0

        EndCase

    EndSelect
EndFunction

Function SensorY( s#, dz#, amp# )

    dY# = GetDirectionY()

    If dY# > Sensor.fCentre + s# then dY# = Sensor.fCentre + s#
    If dY# < Sensor.fCentre - s# then dY# = Sensor.fCentre - s#
    If dY# > Sensor.fCentre - dz# And dY# < Sensor.fCentre + dz# then dY# = Sensor.fCentre

    s# = 1 / s#

    dY# = dY# - Sensor.fCentre
    dY# = dY# * s#

    dY# = dY# * amp#

 EndFunction dY#

 Function SensorX( s#, dz#, amp# )

    dX# = GetDirectionX()

    If dX# > 0 - dz# And dX# < dz# then dX# = 0

    s# = 1 / s#
    dX# = dX# * s#

    dX# = dX# * amp#

 EndFunction dX#

function WordWrap(TextID as integer,MaxWidth as float)
// wraps word of a text string to a fixed length
    if gettextexists(TextID)=1
        OriginalString$ = gettextstring(TextID)
        Tokens = countstringtokens(OriginalString$," ")
        TempString$ = ""

        for TokenID=1 to Tokens
            CurrentString$ = TempString$

            //Add next word
            if len(TempString$)>0
                TempString$ = TempString$+" "+getstringtoken(OriginalString$," ",TokenID)
            else
                TempString$ = getstringtoken(OriginalString$," ",TokenID)
            endif

            settextstring(TextID,TempString$)

            if gettexttotalwidth(TextID)>MaxWidth and TokenID>1
                //string too big
                TempString$ = CurrentString$
                TempString$ = TempString$+chr(10)+getstringtoken(OriginalString$," ",TokenID)
            endif
        next TokenID
        settextstring(TextID,TempString$)
    endif
endfunction

createtext(1,"this is the text that I want to try to wrap around and around the screen so that it doesn't have any issues. Should it not wrap, then users will miss something important.")

WordWrap(1,50)

repeat
    Sync()
until GetPointerPressed() = 1

END


function WordWrap(TextID as integer,MaxWidth as float)
// wraps word of a text string to a fixed length
    if gettextexists(TextID)=1
        OriginalString$ = gettextstring(TextID)
        Tokens = countstringtokens(OriginalString$," ")
        TempString$ = ""

        for TokenID=1 to Tokens
            CurrentString$ = TempString$

            //Add next word
            if len(TempString$)>0
                TempString$ = TempString$+" "+getstringtoken(OriginalString$," ",TokenID)
            else
                TempString$ = getstringtoken(OriginalString$," ",TokenID)
            endif

            settextstring(TextID,TempString$)

            if gettexttotalwidth(TextID)>MaxWidth and TokenID>1
                //string too big
                TempString$ = CurrentString$
                TempString$ = TempString$+chr(10)+getstringtoken(OriginalString$," ",TokenID)
            endif
        next TokenID
        settextstring(TextID,TempString$)
    endif
endfunction

function WordWrap(TextID as integer,MaxWidth as float)
// wraps word of a text string to a fixed length
    if gettextexists(TextID)=1
        OriginalString$ = gettextstring(TextID)
        Tokens = countstringtokens(OriginalString$," ")
        TempString$ = ""

        for TokenID=1 to Tokens
            CurrentString$ = TempString$

            //Add next word
            if len(TempString$)>0
                TempString$ = TempString$+" "+getstringtoken(OriginalString$," ",TokenID)
            else
                TempString$ = getstringtoken(OriginalString$," ",TokenID)
            endif

            settextstring(TextID,TempString$)

            if gettexttotalwidth(TextID)>=MaxWidth and TokenID>1
                //string too big
                TempString$ = CurrentString$
                TempString$ = TempString$+chr(10)+getstringtoken(OriginalString$," ",TokenID)
            endif
        next TokenID
        settextstring(TextID,TempString$)
    endif
endfunction

function Antonstypewriter ( input$ )

    //We start of by declaring some values: "inputlen" which stores the
    //length of our input string (in characters); our ouput in "output$"
    //and finally we declare our array "chars$" with the same number of
    //items as characters in the input string. This is where we will store
    //all the separate characters in the input string in their own respective
    //array item.
    inputlen = len ( input$ )
    output$ = ""
    dim chars$[inputlen]

    //Next it is time to 'fill' our array with data from the input string,
    //we do so by using a for/next statement (a defined loop with an incrementing
    //variable) and we utilize the "mid" command which outputs specific characters
    //from a string. The "mid" command is defined as so: Mid(string,position,length),
    //'string' being the string to extract from, 'position' being the character
    //to extract (1 would be the first character and so on...) and finally
    //'length' being the amount of characters to extract.
    for i = 1 to inputlen
        chars$[i] = mid ( input$ , i , 1 )
    next i

    //Here comes the magic! these simple few lines are what actually give
    //us the 'typewriter' effect. Once again we are using a for/next statement
    //with the variable "i" being capped at "inputlen". We begin by letting
    //the program wait a random amount of milliseconds (1000ms = 1s), between
    //50 and 300 to give us an impression that the text is being typed. After
    //the 'sleep' command, we utilize the "output$" which we defined at
    //the begining of the function, essentially adding on one character at
    //a time. Then the "print" statement simply writes the contents of
    //"output$" to the screen. The final statement here, sync, draws the
    //results to the screen.
    for i = 1 to inputlen
        sleep ( random ( 50 , 300 ) )
        output$ = output$ + chars$[i]
        print ( output$ )
        sync
    next i

endfunction

function Antonstypewriter ( input$ )

    inputlen = len ( input$ )
    output$ = ""
    dim chars$[inputlen]

    for i = 1 to inputlen
        chars$[i] = mid ( input$ , i , 1 )
    next i

    for i = 1 to inputlen
        sleep ( random ( 50 , 300 ) )
        output$ = output$ + chars$[i]
        print ( output$ )
        sync
    next i

endfunction

//Some simple data keeping
Type _Antonstypewriter

    //This is the entered text.
    input as string
    //This is the ID number of our text object
    output as integer
    //This is the length of our entered text
    length as integer
    //This is the current position of our text
    pos as integer
    //This is the mode of our function, 0 sets everything up, 1 types it out
    flag as integer
    //This keeps keeps loops out of our function, by substituting timer based delays instead
    time as float
    //This provides some extra diagnostic information
    diagnostic as integer
    //This is the sound file for our key sound
    key as integer
    //This is the sound file for our space bar sound
    space as integer

EndType

//We begin by setting tfx (typewriter FX)
Global tfx as _Antonstypewriter
//We set the time extension to the current timer() value
tfx.time = timer()
//We create our Text object output
tfx.output = CreateText( "" )
//We limit the amount of text that can appear across the screen so that it wraps
SetTextMaxWidth( tfx.output, 100 )

//This enables and disables extra diagnostic info
tfx.diagnostic = 0
//This loads our sounds
tfx.key = LoadSound( "type.wav" )
tfx.space = LoadSound( "space.wav" )

//This just adds a sprite, which is designed to demonstrate that the program
//can type and perform other operations at the same time.
Sprite = CreateSprite( 0 )
SetSpriteSize( Sprite, 25, 25 )
SetSpriteOffset( Sprite, 12.5, 12.5 )
SetSpritePositionByOffset( Sprite, 50, 50 )
SetSpriteColor( Sprite, 0, 255, 128, 255 )

//***************** Main program loop *****************

Repeat

    //Here we use the Antonstypewriter function
    tfx = Antonstypewriter( tfx, "ONCE UPON A TIME THERE WAS A TOWN THAT LIVED UNDER A WOOD. The wood was deep and dark and thick. The kind of wood little boys and girls are scared to enter, especially when it started to get dark. For after it started to get dark strange things would rustle the bushes, and flap in the trees far above, or scamper across the ground so fast you could only barely glance the end of it’s tail.", 33, 450 )
    //This just rotates the sprite for us.
    SetSpriteAngle( Sprite, GetSpriteAngle( Sprite ) + 1 )

sync()
Until GetRawKeyState( 27 ) = 1
End

//This is a heavily modified version of Paronamixxe's Antonstypewriter function.
//The original used an effective and simple loop system. The problem with this
//is that it didn't allow for anything else in the program to happen.
//
//Parameters: Antonstypewriter global, text to input, min delay and max delay type speed.
Function Antonstypewriter ( temp as _Antonstypewriter, input$, min, max )

    //We begin by selecting the flag
    Select temp.flag
        //Case 0 sets up all the data, it gets the length of the string
        //Sets the flag to 1 so the next case will trigger
        //Passes our parameter text into our object text
        Case 0
            temp.length = len ( input$ )
            temp.flag = 1
            temp.input = input$
        EndCase

        //Case 0 is where all the magic happens.
        Case 1

            //We begin by testing to see if the set time is less than the current timer()
            //If the current timer is greater than time has run out.
            //We also test if our position exceeds our string length, if it does then the typing is finished.
            If temp.time < timer() and temp.pos < temp.length
                //This tracks the position of our automatic typing
                temp.pos = temp.pos + 1
                //This sets the string in our text object using left to isolate our current text.
                SetTextString( temp.output, left( temp.input, temp.pos ))
                //This block of code just converts random numbers into floats
                tmp = random( min, max )
                tmp# = tmp
                tmp# = tmp# / 1000
                //We add the random float to our time value this adjusts the typing speed
                temp.time = timer() + tmp#
                //This block tests to see if the last character was a space, if it was
                //we play the spacebar sound otherwise it's just a normal keypress.
                If mid( temp.input, temp.pos, 1 ) = " "
                    PlaySound( temp.space )
                Else
                    PlaySound( temp.key )
                EndIf
            EndIf

        EndCase

    EndSelect

    // This is just some diagnostic data I needed while bugfixing my code.
    If temp.diagnostic = 1
        print( temp.pos )
        print( temp.length )
        print( timer() )
        print( temp.time )
        print( temp.input )
        print( temp.flag )
    EndIf

endfunction temp

function scale_image(available_memblock_1,available_memblock_2,source_image,new_destination_image,destination_image_scale_x,desination_image_scale_y)
	source_image_width = GetImageWidth(source_image)
	source_image_heigth = GetImageHeight(source_image)
	
	DeleteMemblock(available_memblock_1)
	DeleteMemblock(available_memblock_2)
	CreateMemblockFromImage(available_memblock_1,source_image)

	if source_image = new_destination_image
		if GetImageExists(source_image) then DeleteImage(source_image)
	endif
	if GetImageExists(new_destination_image) then DeleteImage(new_destination_image)
	
	CreateRenderImage(new_destination_image,source_image_width * destination_image_scale_x,source_image_heigth * desination_image_scale_y,0,0)
	CreateMemblockFromImage(available_memblock_2,new_destination_image)
	
	source_image_memblock_position = 12
	destination_image_memblock_position = 12
	
	for y = 1 to source_image_heigth
		
		remember_line_start = source_image_memblock_position
		
		for repeat_line = 1 to desination_image_scale_y
		
			source_image_memblock_position = remember_line_start
		
			for x = 1 to source_image_width
						
				byte_1 = GetMemblockByte(available_memblock_1,source_image_memblock_position)
				inc source_image_memblock_position
				byte_2 = GetMemblockByte(available_memblock_1,source_image_memblock_position)
				inc source_image_memblock_position
				byte_3 = GetMemblockByte(available_memblock_1,source_image_memblock_position)
				inc source_image_memblock_position
				byte_4 = GetMemblockByte(available_memblock_1,source_image_memblock_position)
				inc source_image_memblock_position

				for draw_to_destination_memblock_x = 1 to destination_image_scale_x
					SetMemblockByte(available_memblock_2,destination_image_memblock_position,byte_1)
					inc destination_image_memblock_position
					SetMemblockByte(available_memblock_2,destination_image_memblock_position,byte_2)
					inc destination_image_memblock_position
					SetMemblockByte(available_memblock_2,destination_image_memblock_position,byte_3)
					inc destination_image_memblock_position
					SetMemblockByte(available_memblock_2,destination_image_memblock_position,byte_4)
					inc destination_image_memblock_position
				next draw_to_destination_memblock_x
					
			next x
		
		next repeat_line	
		
	next y

	CreateImageFromMemblock(new_destination_image,available_memblock_2)
	
endfunction

function SetTextToFit( txtObj as integer, width as float, AdjustIfFits as integer)

	size# = GetTextSize( txtObj )

	if GetTextTotalWidth( txtObj ) < width
		if AdjustIfFits = 0
			exitfunction
		endif

		repeat
			inc size#, 0.1
			SetTextSize( txtObj, size# )
		until GetTextTotalWidth( txtObj ) >= width
		exitfunction
	else
		repeat
			dec size#, 0.1
			SetTextSize( txtObj, size# )
		until GetTextTotalWidth( txtObj ) <= width
		exitfunction
	endif

endfunction

// Project: TextWidth
// Created: 2015-08-09

// set window properties
SetWindowTitle( "TextWidth" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )



a = CreateText( "Random Text String" )
SetTextPosition( a, 10, 250 )


SetTextSize( a, 10 )

SetTextToFit( a, 400, 1 )

do
	print( "Text Size    : " + str(GetTextSize(a)) )
	print( "Total Width  : " + str(GetTextTotalWidth(a)) )
    Sync()
loop


function SetTextToFit( txtObj as integer, width as float, AdjustIfFits as integer)

	size# = GetTextSize( txtObj )

	if GetTextTotalWidth( txtObj ) < width
		if AdjustIfFits = 0
			exitfunction
		endif

		repeat
			inc size#, 0.1
			SetTextSize( txtObj, size# )
		until GetTextTotalWidth( txtObj ) >= width
		exitfunction
	else
		repeat
			dec size#, 0.1
			SetTextSize( txtObj, size# )
		until GetTextTotalWidth( txtObj ) <= width
		exitfunction
	endif

endfunction

if getTextTotalWidth(myText) > desiredWidth
	setTextSize(MyText, currentFontSize * desiredWidth) / (getTextTotalWidth(myText))
endif

function SetTextToFit( myText, desiredWidth# )
	if getTextTotalWidth(myText) > desiredWidth#
		setTextSize(MyText, (GetTextSize( myText) * desiredWidth#) / (getTextTotalWidth(myText)))
	endif
endfunction

// Project: CNP Nodes 
// Created: 2015-10-10
// Alex Schmidt 2015 - online-arts.de


// this code can be used to create a node based tree and there is even a slim pathfinding function in it!
// There are more useful scenarios for this code!

// set window properties
SetWindowTitle( "CNP Nodes" )
SetWindowSize( 1280, 720, 0 )
SetVirtualResolution( 1280, 720 )
SetOrientationAllowed( 1, 1, 1, 1 )







#constant max_node_links 5		// this constant will set the maximum links for all nodes (from 0 to 5^^)




// Type for the pathfinder function

	type pathfinder_def
		num as integer
		list$ as string
		stat as integer
	endtype
	


// Type for the path_node array
	type path_node_def

		num as integer							// node identification
		connect as integer[max_node_links] 		// the targets will refer to path_lines

	endtype

dim path_node[] as path_node_def				// Create the path_node array






// create some nodes
	create_node(1)
	create_node(2)
	create_node(3)
	create_node(4)
	create_node(5)

// link the nodes
	create_link(1,2)
	create_link(1,3)
	create_link(2,3)
	create_link(3,4)
	create_link(3,5)




nodepath$=find_path(1,5)



// draw some information. This is just to understand the nodes better, this graphic is only for the given
// Nodes, Links and path that I use in this example

	// define debug colors
		color1=MakeColor(255,255,255)
		color2=MakeColor(0,255,0)
		color3=MakeColor(255,0,0)

	// create debug text
		text(100,500,20,"1")
		text(300,400,20,"2")
		text(500,500,20,"3")
		text(600,450,20,"4")
		text(500,650,20,"5")



do
	
	
// display node information

print("Online Arts - Node Pathfind")
	
	if path_node.length>-1
		for i=0 to path_node.length
			
			link$=""
			for x=0 to max_node_links
				if x<max_node_links then t$="," else t$=""
				link$ = link$+str(path_node[i].connect[x])+t$
			
			
			next x
			

			print("Node: "+str(path_node[i].num)+"  Link: "+link$)


		
		next i


print("===========================")
print("STARTPOINT: 1   ENDPOINT: 5")
		print("Path:   "+nodepath$)


	endif


// draw some information. This is just to understand the nodes better, this graphic is only for the given
// Nodes, Links and path that I use in this example


		// nodes
			DrawEllipse(100,500,20,20,color2,color2,0) // 1
			DrawEllipse(300,400,20,20,color1,color1,0) // 2
			DrawEllipse(500,500,20,20,color1,color1,0) // 3
			DrawEllipse(600,450,20,20,color1,color1,0) // 4
			DrawEllipse(500,650,20,20,color3,color3,0) // 5


		// links
			DrawLine(100,500,300,400,255,255,255) // 1-2
			DrawLine(300,400,500,500,255,255,255) // 2-3
			DrawLine(100,500,500,500,0,0,255) // 1-3
			DrawLine(500,500,600,450,255,255,255) // 3-4
			DrawLine(500,500,500,650,0,0,255) // 3-5



    Sync()
loop

// debug text function, just for some drawing
function text(x,y,s,t$)
	
	txt=CreateText(t$)
	SetTextSize(txt,s)
	SetTextPosition(txt,x,y)
	
endfunction


// this will create an entry inside the path_node connect array for each connection
// be shure, that the targets a and b exist, or this command will fail 

function create_link(a,b)
	
	// define node num a with target node b
	num=get_node_num(a)

	for i=0 to max_node_links
		if path_node[num].connect[i]=b then exit // this one will enshure, that there wont be two same connections
		if path_node[num].connect[i]=0
			path_node[num].connect[i]=b
			exit
		endif
	next i

	// define node num b with target node a
	num=get_node_num(b)

	for i=0 to max_node_links
		if path_node[num].connect[i]=a then exit // this one will enshure, that there wont be two same connections
		if path_node[num].connect[i]=0
			path_node[num].connect[i]=a
			exit
		endif
	next i


endfunction


// create a node (Just resize the array and define a unique number inside the new .num of path_node)
function create_node(num)

	elem=path_node.length // last element inside the array
	inc elem	          // add a new element
	path_node.length=elem // redefine the length
	
	path_node[elem].num=num	// define the number
		
endfunction


// this function can find the array index of a given node number
function get_node_num(num)
	
	for i=0 to path_node.length
		if path_node[i].num=num
					
			exitfunction i
		endif
	next i
	
endfunction -1





function find_path(sp,ep)
	
dim path_list[] as pathfinder_def




repeat

			if path_list.length=-1 // if the list is empty, we will create the first search node, that will be the startnode sp , also add sp to the curlist$, which contain a list of nodes for example: (1,3,4,6)
						
						cur_node=sp
						curlist$=curlist$+str(cur_node)
						add_to_list(curlist$,1) // add to the path list, and mark is as finished, because the node calcuation will work with this data 
							
			else
				
					// if the array length is not -1, so there is already a start node written in it. So the current node should be a node linked by the previous node(in the first run, its the start node)
					for x=0 to path_list.length
						
						if path_list[x].stat=0
						// this will inspect the list and find the last entry to the list, in the first run its the start node
						maxt=CountStringTokens(path_list[x].list$,",")
						lt$=GetStringToken(path_list[x].list$,",",maxt)
							cur_node=val(lt$)
							curlist$=path_list[x].list$
							path_list[x].stat=1 // set the list stat to finished, the node calculation will be done anyway
							num=x
							
							exit // once we got a stat=0 entry, we have all we need and jump to the node calculation
						
						endif
						
					next x
				
				
			endif

// node calculation
			for i=0 to max_node_links // max_node_links is very useful. This constant will give a dynamic size of possible links to a node
				
				

				if path_node[get_node_num( cur_node )].connect[i]>0		// if a link exist
					
					nex_node= path_node[get_node_num( cur_node )].connect[i]	// set next possible node to one of the links of the given node
					
					// if nex_node is not already in the list
					
					maxt=CountStringTokens(path_list[num].list$,",") // get the number of entrys in the list
						
						for x=1 to maxt // search list
							
							
							// the following remtext opens a direct view inside the parser
							remstart
							repeat
								print(nex_node)
								print(path_list[num].list$)
								print("===============")
								print(path_list[num].list$+","+str(nex_node))
								print("TOKEN: "+GetStringToken(path_list[num].list$,",",maxt))
								
								sync()
							until GetRawMouseRightReleased()=1
							remend
							
							
							if GetStringToken(path_list[num].list$,",",x)<>str(nex_node) // if no token inside the list is nex_node (no way back entry loop 1-2-1)
								add_to_list(curlist$+","+str(nex_node),0)
								exit
								else
									exit
							endif
						
						next x
						
					
					
					
							
					
					
					
					
				endif
				
				if nex_node=ep 
					found=1
					outpath$=curlist$+","+str(nex_node)
				endif
				
				
			next i




until found=1


// the following remtext will display all the calculated ways
remstart
	do
		print("Full List:")
		for i=0 to path_list.length
		
			print(path_list[i].list$)
			
		next i
		
		sync()
	loop
remend

undim path_list[]


	
endfunction outpath$



// this function is only used inside the find_path function, can only work if path_list array exists
function add_to_list(list$,stat)


path_list.length = path_list.length+1
path_list[path_list.length].list$=list$
path_list[path_list.length].stat=stat


endfunction

// rotates a sprite according to the pointer-position and returns the angle# (0 if limit exceeded).
// angle_modifier# is added to the calculated angle.
// 0 for angle_min# or angle_max# disables the corresponding limit.
function rotate_sprite_by_pointer(sprite_id, angle_modifier#, angle_min#, angle_max#)
	angle# = ATanFull(WorldToScreenX(GetSpriteXByOffset(sprite_id)) - GetPointerX(), WorldToScreenY(GetSpriteYByOffset(sprite_id)) - GetPointerY())
	angle# = angle# + angle_modifier#
	
	if angle_min# <> 0.0
		angle_min# = angle_min# + angle_modifier#	
		if angle# < angle_min# then exitfunction 0.0
	endif
	
	if angle_max# <> 0.0
		angle_max# = angle_max# + angle_modifier#
		if angle# > angle_max# then exitfunction 0.0
	endif

	SetSpriteAngle(sprite_id, angle#)
endfunction angle#