Sorry your browser is not supported!

// Project: Simple Simon 
// Created: 2017-01-20

// show all errors
SetErrorMode(2)

global width=1024
global height=768

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

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

global digits as string[5]
//           space  :    0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F    G    h    I    J    K    L    M    N    O   P    Q    R    S    T     U    V    W    X    Y    Z
digits[0] = "0000000000111110000111111111111000111111100001111111111111111111111110111111111011111111111111110001111110000110001100001000110001111111111001110011101111111111100011000110001100011000111111"
digits[1] = "0000000100100010000100001000011000110000100000000110001100011000110001100001000110000100001000010001001000000110010100001101111001100011000110001100011000000100100011000110001010101000100011"
digits[2] = "0000000000100010000111111111111111111111111110000111111111111111111110100001000111100111001000011111001000000111100100001010110101100011111010101111101111100100100011000110101001000101000110"
digits[3] = "0000000100100010000110000000010000100001100010000110001000011000110001100001000110000100001000110001001001000110010100001000110011100011000010011101000000100100100010101010101010100010001100"
digits[4] = "0000000000111110000111111111110000111111111110000111111000011000111110111111111011111100001111110001111110111010001111111000110001111111000001110100111111100100011100010001010100010010011111"
                                                            

type _button 
	id as integer
	size as integer
	x    as integer
	y as integer
	r as integer
	g as integer
	b as integer
	chosen as integer
endtype

global button as _button[4]
global mouse as integer
global Level = 1
global green,red,yellow,blue,white,black
global cpusequences as integer[100] // CPU sequences
global playersequences as integer[100] // Player Sequences
global currentplayersequence as integer // Each time player clicks a button, gets added here 
global currentsequence as integer // This is a sequence number to play before players turn
global playerturn as integer // 1= Player turn. 2 = CPU Turn
global gamecountdown as integer

// Lets set up some nice colours

green=makecolor(0,255,0)
red   =makecolor(255,0,0)
yellow=MakeColor(255,255,0)
blue  =makecolor(0,0,255)
white =makecolor(255,255,255)
black =makecolor(0,0,0)	
alpha = 255 // Used to fade the buttons 
	
mouse = createmouse()

gamecountdown=3
buildsequences()
setupsequences()
setupbuttons()


// This sets a timer up so we can do actions at certain time intervals
frametime#=timer()
do
	display ("MEMORY MADNESS", width/2-len("MEMORY MADNESS")/2*70, 70, 4, makecolor(0,255,255))
	display ("LEVEL" + str(level), width/2-len("LEVEL"+str(level))/2*40, 160, 2, makecolor(255,0,0))

	if gamecountdown>0
		status$=str(gamecountdown)
	else
		status$=message$
	endif
	display(status$,width/2-len(status$) * 30,height/2,2,makecolor(255,255,0))

	// used for collision checking with the buttons
	SetSpritePosition(mouse,getpointerx(),getpointery())
    

	displaybuttons()
	
	// remember the timer at line 71 - this checks now, so evey half a second it will go into the IF
	// and action the commands in there
	if timer() - frametime#>.5 // waits half a second

	
		frametime#=timer() // resets the timer to wait half a second
	
		if gamecountdown>0
			dec gamecountdown
			
		else
			message$="GO"
			anylit=0
			for a=1 to 4
				if button[value].chosen=1 then inc anylit
			next
			resetbuttons()
		
			if anylit=0 
	
				if playerturn=2 
// CPUs turn - lets go round until the amount in the CPU Sequence is filled out			
//resetbuttons()
					if currentsequence<=level
				
// Go through the sequences derived 
						value=cpusequences[Currentsequence]
						inc currentsequence
						button[value].chosen=1
					else
						if currentsequence>level
							resetbuttons()
							playerturn=1
						endif
					endif
					
				endif
			endif
		endif
	endif

	if playerturn=1 
	
		for a = 1 to 4
			if GetSpriteCollision(mouse,button[a].id) = 1
				if GetRawMouseLeftreleased()=1 

					button[a].chosen=1
					displaybuttons()
					if cpusequences[currentplayersequence] = a
					

//					print (str(currentsequence) + " - " + str(a) + " - " + str(currentplayersequence))
//					sync()
//					sleep(500)
						
						if currentplayersequence = currentsequence-1
						
							inc level
							resetbuttons()
							setupsequences()
					
						else
								inc currentplayersequence

						endif
						
					else
						message("FAIL")
						level=1
						buildsequences()
						gamecountdown=3
						resetbuttons()
						setupsequences()
					endif
					
				endif
			endif	
		next
	endif	
		
		
	
    Sync()
loop
function displaybuttons()
	
		// display the 4 buttons
	for a=1 to 4
		SetSpritePosition(button[a].id, button[a].x, button[a].y)
		
		if button[a].chosen = 1 
			SetSpriteColorAlpha(button[a].id,255)
		else 
			SetSpriteColorAlpha(button[a].id,100)
		endif
	next	

endfunction
function buildsequences()

	// Let the CPU have a new set of sequences
	for a=1 to cpusequences.length
		cpusequences[a]=random(1,4)
		
	next


endfunction

function resetbuttons()
	for a=1 to 4
		button[a].chosen=0
	next
endfunction

function setupsequences()
	
	
	// Lets empty the players sequences
	for a=1 to playersequences.length
		playersequences[a]=0
	next
		currentsequence=1
	currentplayersequence=1
	playerturn=2 // turn back to the CPU to fire the next set of sequences
	
endfunction

function setupbuttons()

	button[1].r = 0 : button[1].g = 255 : button[1].b = 0
	button[2].r = 255 : button[2].g = 0 : button[2].b = 0
	button[3].r = 255 : button[3].g = 255 : button[3].b = 0
	button[4].r = 0 : button[4].g = 0 : button[4].b = 255

	for a=1 to 4 
		button[a].chosen=0
		button[a].size = 1
		button[a].id = createbuttons()
		SetSpriteScale(button[a].id,button[a].size,button[a].size)
		SetSpriteColor(button[a].id,button[a].r, button[a].g,button[a].b,255)
	next
	button[1].x = width/2 - GetSpriteWidth( button[1].id )
	button[1].y = height/2 - GetSpriteHeight( button[1].id )
	
	button[2].x = width/2 									 
	button[2].y = height/2 - GetSpriteHeight( button[2].id)
	SetSpriteFlip(button[2].id,90,0)
	
	button[3].x = width/2
	button[3].y = height/2									  
	SetSpriteFlip(button[3].id,90,90)
  

	button[4].x = width/2 - GetSpriteWidth( button[4].id ) 
	button[4].y = height/2
	SetSpriteFlip(button[4].id,0,90)
	
	
endfunction


function createbuttons()
	color=MakeColor(255,255,255)
	render()
	
	for a=1 to 6
		DrawEllipse(200,200,200-a,200-a, color<<a, 0, 1)
	next
	DrawEllipse(200,200,200-a,200-a, color, 0, 1)
	DrawEllipse(200,200,100,100, black, black, 1)

	swap()
	
	ID = createsprite(getimage(0,0,200,200))

	

	
endfunction ID


function Createmouse()
	// This is just to create a pin point for the mouse, so it can be used for sprite collision checking
	ID = createsprite(getimage(0,0,1,1))
endfunction ID


function display(t$, x#, y#,size#,color)
    for a=1 to len(t$)
        pos=(val(mid(t$,a,1)) * 5)+11 // Numbers
        if asc(mid(t$,a,1))>60 then pos=((asc(mid(t$,a,1))-55) * 5) + 11 // Characters
        if asc(mid(t$,a,1))=32 then pos=1 //Space
        if asc(mid(t$,a,1))=58 then pos=6 // a ":"
        for b=0 to 4 //go down the digits array
            for c=0 to 4 // go along the digits array
                if mid(digits[b],pos+c,1)="1"
						
					
					DrawEllipse((x#+(a*(size#*16)) + (c*size#*2)), y#+(b*(size#*3))-10, size#+10, size#+10, color,MakeColor(a,b,c) ,val(mid(digits[b],pos+c,1) ))
				endif
            next
     
        next
    next
endfunction

// Project: Angry Blocks 
// Created: 2017-03-02
// By Easter Bunny

/*
Hacks you should totally do
1. Infinite shots
2. Player doesn't reset position on level restart
3. Design your own levels!
4. Add some sort of scoring system
*/

SetErrorMode(2)
//init stuff
SetWindowTitle( "Angry Blocks" )
SetWindowSize( 1000,625, 0 ) //use 16:10 aspect ratio
SetVirtualResolution( 160,100 )
SetOrientationAllowed( 0, 0, 1, 1 )
SetSyncRate( 0,1 ) //unlimited framerate
UseNewDefaultFonts( 1 )

SetPhysicsDebugOn()

//by default these 4 walls are on anyway so these lines are redundant
//however if you move the viewport (using SetViewOffset(x,y), the walls will automtically be removed
//so if you ever intend to move the viewport around, you should use static physics sprites for walls at the bounds of your level
SetPhysicsWallBottom(1) 
SetPhysicsWallTop(1)
SetPhysicsWallLeft(1)
SetPhysicsWallRight(1)

//I'm not sure what the default gravity is set to
//so it's best practice to manually set the gravity so you have full control over it (ie if you change it, you can change it back since you know what it is)
SetPhysicsGravity(0,150)


//it's best practice to declare your variables as this will prepare you for using more advanced languages like C++
startPad as integer
firingState as integer
levelBlocks as integer[99]
ix as float
iy as float
plr as tPlayer //set up type for player. Includes player sprite, shots remaining and firing state. Check out the type declaration at the bottom of the code




startPad=CreateSprite(0)
SetSpriteSize(startPad,10,20)
SetSpritePosition(startPad,0,80) //set to 100-20 [bottom of screen]-[height of startPad]
SetSpritePhysicsOn(startPad,1) //static
SetSpriteVisible(startPad,0) //we'll make the sprite invisible and just use the physics debug for visualisation

plr.sprite=CreateSprite(0) //use blank [white square] image
SetSpriteSize(plr.sprite,5,5)
SetSpritePosition(plr.sprite,2,75) //75=80-5 [top of startPad]-[height of player sprite]
SetSpriteVisible(plr.sprite,0)
SetSpriteShape(plr.sprite,1) //0=no shape, 1=circle, 2=box, 3=polygon
SetSpritePhysicsOn(plr.sprite,2) //1=static, 2=dynamic, 3= kinematic
SetSpritePhysicsDamping(plr.sprite,0.2) //linear movement damping, basically wind resistence
SetSpritePhysicsMass(plr.sprite,5)
SetSpritePhysicsRestitution(plr.sprite,0.7) //the 'bounciness' of the sprite
plr.shots=3
plr.firingState=0


//we're going to load the level from a file
//the file is named 'level.abl' and is located in /media
//the file format is as follows:
//first line contains the number of blocks in the levels
//there is a blank line between each of the blocks
//for each block in the level, there will be 4 lines showing the x/y/x size/y size of the block and a 5th line static if it's dynamic or static
//NOTE: The dimensions of the blocks are stored as ascii text in the file in this case. In a real game, you would store them in binary as integers
//It's done this way so you can modify the level in notepad
f=OpenToRead("level.abl")
	//read out the first line since it's a comment (go check the file)
	//if you remove the comment line in the file, then you gotta remove this line too
	ReadLine(f)
	
	n=val(ReadLine(f)) //gotta use val to convert the string '123' to the integer 123
	for k=1 to n
		ReadLine(f) //blank line between each block for formatting
		x#=valFloat(ReadLine(f))
		y#=valFloat(ReadLine(f))
		xs#=valFloat(ReadLine(f))
		ys#=valFloat(ReadLine(f))
		typ=val(ReadLine(f))
		
		levelBlocks[k]=CreateSprite(0)
		SetSpritePosition(levelBlocks[k],x#,y#)
		SetSpriteSize(levelBlocks[k],xs#,ys#)
		if typ<1 then typ=1 : if typ>2 then typ=2 //limit to static or dynamic
		SetSpritePhysicsOn(levelBlocks[k],typ)
	next
CloseFile(f)




do
	//print(ScreenFPS())
	print("Shots remaining: "+str(plr.shots))
	
	if plr.firingState=0
		Print("Click anywhere and hold")
		if GetPointerPressed()
			ix=GetPointerX()
			iy=GetPointerY()
			plr.firingState=1
		endif
	elseif plr.firingState=1
		Print("Drag then release to fire!")
		DrawLine(GetPointerX(),GetPointerY(),ix,iy,200,200,200)
		if GetPointerReleased()
			dec plr.shots,1
			SetSpritePhysicsVelocity(plr.sprite,(ix-GetPointerX())*10,(GetPointerY()-iy)*10)
			plr.firingState=2
		endif
	elseif plr.firingState=2
		if plr.shots>0
			print("Click to reset")
			if GetPointerReleased()
				SetSpritePosition(plr.sprite,2,75)
				SetSpritePhysicsVelocity(plr.sprite,0,0)
				SetSpritePhysicsAngularVelocity(plr.sprite,0)
				plr.firingState=0
			endif
		else
			print("")
			print("Game over")
			print("Click to restart game")
			
			if GetPointerReleased()
				f=OpenToRead("level.abl")
					ReadLine(f)
					n=val(ReadLine(f)) 
					for k=1 to n
						ReadLine(f) //blank line between each block for formatting
						x#=valFloat(ReadLine(f))
						y#=valFloat(ReadLine(f))
						xs#=valFloat(ReadLine(f))
						ys#=valFloat(ReadLine(f))
						typ=val(ReadLine(f))
						SetSpritePosition(levelBlocks[k],x#,y#)
						SetSpriteAngle(levelBlocks[k],0)
						SetSpritePhysicsVelocity(levelBlocks[k],0,0)
						SetSpritePhysicsAngularVelocity(levelBlocks[k],0)
					next
				CloseFile(f)
				SetSpritePosition(plr.sprite,2,75)
				SetSpritePhysicsVelocity(plr.sprite,0,0)
				SetSpritePhysicsAngularVelocity(plr.sprite,0)
				plr.shots=3
				plr.firingState=0
			endif
		endif
	endif
    
    Sync()
loop



type tPlayer
	sprite
	shots
	firingState
endtype

//file format: 7 is the number of blocks. 1st block : position 50.5,70 : size 10,30 DYNAMIC[2] ::: 2nd block : position 40.5,65 : size : size 30,5 DYNAMIC[2] etc
7

50.5
70
10
30
2

40.5
65
30
5
2

120
50
5
5
1

102.5
30
40
2
2

102.5
0
2
20
2

140
0
2
20
2

// Project: pacman 
// Created: 2017-01-16

// show all errors
SetErrorMode(2)

global mapSize as float
mapSize = 672

// set window properties
SetWindowTitle( "pacman" )
SetWindowSize( mapSize, mapSize, 0 )

// set display properties
SetVirtualResolution( mapSize, mapSize )
SetSyncRate( 60, 0 )
SetPrintSize( 16 )

// load media
LoadMedia()

// create map
CreateMap(image[0])
PlaceObjects(image[4])

// set up animation
global now       as float
global Anim      as integer
global AnimTime  as float
global FrameTime as float
Anim = 0
FrameTime = 0.25
AnimTime  = Timer() + FrameTime

//SetPhysicsDebugOn()

do
	`print("last="+str(GetRawLastKey()))
    now = Timer()
    
    ControlPlayer()
    
    EatDots()
    
    UpdateGhosts()
    
    Sync()
loop

//############################ PLAYER
// HERE WE CONTROL THE PLAYER AND ANY INTERACTIONS

#constant dir_none  0
#constant dir_left  1
#constant dir_right 2
#constant dir_up    3
#constant dir_down  4

#constant state_stopped 0
#constant state_moving  1

type playerType
	spr as integer
	state as integer
	direction as integer
	tween as integer
endtype
global player as playerType

function EatDots()
	// loop through all dots until one is close enough to 'eat'
	// then delete the sprite and play a sound
	// if a pill is eaten set ghosts running
	px# = GetSpriteXByOffset(player.spr)
	py# = GetSpriteYByOffset(player.spr)
	for i=0 to dot.length
		sx# = GetSpriteXByOffset(dot[i])
		sy# = GetSpriteYByOffset(dot[i])
		dx# = Abs(sx# - px#)
		if dx#<tileSize
			dy# = Abs(sy# - py#)
			if dy#<tileSize
				d# = Sqrt(dx#*dx#+dy#*dy#)
				if d#<tileSize*0.5
					f = GetSpriteCurrentFrame(dot[i])
					if f=2
						// pill eaten!
						SetGhostsRun()
						`PlaySound(sound.pill)
					else
						// dot eaten!
						`PlaySound(sound.dot)
					endif
					DeleteSprite(dot[i])
					dot.remove(i)
					exitfunction
				endif
			endif
		endif
	next
endfunction

function ControlPlayer()
	// get input from arrow keys
	dir = dir_none
	if GetRawKeyState(39)>0
		dir = dir_right
	else
		if GetRawKeyState(37)>0
			dir = dir_left
		else
			if GetRawKeyState(40)>0
				dir = dir_down
			else
				if GetRawKeyState(38)>0 then dir = dir_up
			endif
		endif
	endif
	
	// check direction is possible
	sx# = GetSpriteXByOffset(player.spr)
	sy# = GetSpriteYByOffset(player.spr)
	x = floor(GetSpriteXByOffset(player.spr)/tileSize)
	if x<0
		x = 20
		sx# = sx# + mapSize
		SetSpritePositionByOffset(player.spr, sx#, sy#)
	else
		if x>20
			x = 0
			sx# = sx# - mapSize
			SetSpritePositionByOffset(player.spr, sx#, sy#)
		endif
	endif
	y = floor(GetSpriteYByOffset(player.spr)/tileSize)
	
	// if player is moving check for an opening
	if player.state=state_moving
		select dir
			case dir_left, dir_right
				ok = 0
				if dir=dir_left and GetWallLeft(player.spr)=0   then ok=1
				if dir=dir_right and GetWallRight(player.spr)=0 then ok=1
				if ok>0
					ny# = tileSize*0.5 + y*tileSize
					dy# = abs(sy#-ny#)
					if dy#<tileSize*0.1
						SetSpritePositionByOffset(player.spr, sx#, ny#)
					else
						dir = dir_none
					endif
				else
					dir = dir_none
				endif
			endcase
			case dir_up, dir_down
				ok = 0
				if dir=dir_up and GetWallUp(player.spr)=0     then ok=1
				if dir=dir_down and GetWallDown(player.spr)=0 then ok=1
				if ok>0
					nx# = tileSize*0.5 + x*tileSize
					dx# = abs(sx#-nx#)
					if dx#<tileSize*0.1
						SetSpritePositionByOffset(player.spr, nx#, sy#)
					else
						dir = dir_none
					endif
				else
					dir = dir_none
				endif
			endcase
		endselect
	endif
	
	// if movement is possible set off in that direction
	select dir
		case dir_left
			if GetWallLeft(player.spr)=0
				player.direction = dir
				player.state = state_moving
			endif
		endcase
		case dir_right
			if GetWallRight(player.spr)=0
				player.direction = dir
				player.state = state_moving
			endif
		endcase
		case dir_up
			if GetWallUp(player.spr)=0
				player.direction = dir
				player.state = state_moving
			endif
		endcase
		case dir_down
			if GetWallDown(player.spr)=0
				player.direction = dir
				player.state = state_moving
			endif
		endcase
	endselect
	
	// move player sprite
	if player.state = state_moving
		select player.direction
			case dir_left
				sx = GetSpriteXByOffset(player.spr) - (tileSize/16)
				sy = GetSpriteYByOffset(player.spr)
				SetSpritePositionByOffset(player.spr, sx, sy)
				
				// stop if wall reached
				if GetWallLeft(player.spr)>0
					SetSpritePositionByOffset(player.spr, GetRayCastX()+tileSize*0.5, GetSpriteYByOffset(player.spr))
					player.state = state_stopped
					player.direction = dir_none
				endif
			endcase
			case dir_right
				sx = GetSpriteXByOffset(player.spr) + (tileSize/16)
				sy = GetSpriteYByOffset(player.spr)
				SetSpritePositionByOffset(player.spr, sx, sy)
				
				// stop if wall reached
				if GetWallRight(player.spr)>0
					SetSpritePositionByOffset(player.spr, GetRayCastX()-tileSize*0.5, GetSpriteYByOffset(player.spr))
					player.state = state_stopped
					player.direction = dir_none
				endif
			endcase
			case dir_up
				sx = GetSpriteXByOffset(player.spr)
				sy = GetSpriteYByOffset(player.spr) - (tileSize/16)
				SetSpritePositionByOffset(player.spr, sx, sy)
				
				// stop if wall reached
				if GetWallUp(player.spr)>0
					SetSpritePositionByOffset(player.spr, GetSpriteXByOffset(player.spr), GetRayCastY()+tileSize*0.5)
					player.state = state_stopped
					player.direction = dir_none
				endif
			endcase
			case dir_down
				sx = GetSpriteXByOffset(player.spr)
				sy = GetSpriteYByOffset(player.spr) + (tileSize/16)
				SetSpritePositionByOffset(player.spr, sx, sy)
				
				// stop if wall reached
				if GetWallDown(player.spr)>0
					SetSpritePositionByOffset(player.spr, GetSpriteXByOffset(player.spr), GetRayCastY()-tileSize*0.5)
					player.state = state_stopped
					player.direction = dir_none
				endif
			endcase
		endselect
	endif
endfunction

// some basic raycasting functions to check the player surroundings
function GetWallDirection(spr, dir)
	select dir
		case dir_left
			exitfunction GetWallLeft(spr)
		endcase
		case dir_right
			exitfunction GetWallRight(spr)
		endcase
		case dir_up
			exitfunction GetWallUp(spr)
		endcase
		case dir_down
			exitfunction GetWallDown(spr)
		endcase
	endselect
endfunction 0

function GetWallLeft(spr)
	x1# = GetSpriteXByOffset(spr)
	y1# = GetSpriteYByOffset(spr)
	x2# = x1# - tileSize*0.51
	y2# = y1#
	hit = PhysicsRayCastGroup(1, x1#, y1#, x2#, y2#)
endfunction hit

function GetWallRight(spr)
	x1# = GetSpriteXByOffset(spr)
	y1# = GetSpriteYByOffset(spr)
	x2# = x1# + tileSize*0.51
	y2# = y1#
	hit = PhysicsRayCastGroup(1, x1#, y1#, x2#, y2#)
endfunction hit

function GetWallUp(spr)
	x1# = GetSpriteXByOffset(spr)
	y1# = GetSpriteYByOffset(spr)
	x2# = x1#
	y2# = y1# - tileSize*0.51
	hit = PhysicsRayCastGroup(1, x1#, y1#, x2#, y2#)
endfunction hit

function GetWallDown(spr)
	x1# = GetSpriteXByOffset(spr)
	y1# = GetSpriteYByOffset(spr)
	x2# = x1#
	y2# = y1# + tileSize*0.51
	hit = PhysicsRayCastGroup(1, x1#, y1#, x2#, y2#)
endfunction hit

//############################ PLAYER

//############################ PLACEMENT
// HERE WE USE A BASIC 'PLACEMENT' IMAGE AS THE BASIS FOR
// POSITIONING CHARACTERS AND PICKUPS ON THE MAP
// THIS MEANS WE CAN CREATE NEW MAPS EASILY USING 2
// BASIC IMAGES - THE MAP AND THE PLACEMENT IMAGE

#constant dotCol MakeColor(255, 255, 255)
#constant pacCol MakeColor(0, 0, 0)
#constant gh1Col MakeColor(255, 255, 0)
#constant gh2Col MakeColor(0, 255, 255)
#constant gh3Col MakeColor(255, 0, 255)
#constant gh4Col MakeColor(255, 0, 0)
#constant pilCol MakeColor(128, 128, 128)

function PlaceObjects(placementImage)
	// create a memblock based on the image
	mem = CreateMemblockFromImage(placementImage)
	
	// loop through the pixels on the image and look
	// for specific colours which represent game objects
	// get the meta data of the image
	width = GetMemblockInt(mem, 0)
	height = GetMemblockInt(mem, 4)
	size = GetMemblockSize(mem)

	// we start at 12 because the first 12 bytes are taken up with meta data and so this is where the bitmap begins
	// we continue until size - 1 because memblocks start as index 0 and so position size is not part of the memblock
	// we step 4 each time as each pixel is represented by four bytes of data (red, green, blue, alpha)
	for c = 12 to size - 1 step 4
		red = GetMemblockByte(mem, c)
		grn = GetMemblockByte(mem, c + 1)
		blu = GetMemblockByte(mem, c + 2)
		alp = GetMemblockByte(mem, c + 3)
		
		// get pixel position
		x = (c-12) / 4
		y = 0
		while x>=width
			inc y
			x = x - width
		endwhile
		
		// look for 'solid' colour
		if alp>0
			// get pixel colour
			col = MakeColor(red, grn, blu)
			
			// position relevant object
			select col
				case pilCol
					// position a 'pill' pickup
					spr = CreateSprite(image[1])
					SetSpriteSize(spr, tileSize*0.5, tileSize*0.5)
					SetSpriteAnimation(spr, 8, 8, 2)
					SetSpriteFrame(spr, 2)
					SetSpritePositionByOffset(spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
					SetSpriteDepth(spr, 995)
					dot.insert(spr)
				endcase
				
				case dotCol
					// position a 'dot' pickup
					spr = CreateSprite(image[1])
					SetSpriteSize(spr, tileSize*0.5, tileSize*0.5)
					SetSpriteAnimation(spr, 8, 8, 2)
					SetSpriteFrame(spr, 1)
					SetSpritePositionByOffset(spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
					SetSpriteDepth(spr, 995)
					dot.insert(spr)
				endcase
				
				case pacCol
					// position pacman
					SetSpritePositionByOffset(player.spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
				endcase
				
				case gh1Col
					// position ghost 1
					SetSpritePositionByOffset(ghost[0].spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
				endcase
				
				case gh2Col
					// position ghost 2
					SetSpritePositionByOffset(ghost[1].spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
					
					// create wall
					spr = CreateSprite(0)
					SetSpriteVisible(spr, 0)
					SetSpriteSize(spr, tileSize, tileSize)
					SetSpritePhysicsOn(spr, 1)
					SetSpriteShapeBox(spr, -tileSize*0.5, -tileSize*0.5, tileSize*0.5, tileSize*0.5, 0)
					SetSpriteGroup(spr, 1)
					SetSpritePositionByOffset(spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + (y-1)*tileSize)
				endcase
				
				case gh3Col
					// position ghost 3
					SetSpritePositionByOffset(ghost[2].spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
				endcase
				
				case gh4Col
					// position ghost 4
					SetSpritePositionByOffset(ghost[3].spr, tileSize*0.5 + x*tileSize, tileSize*0.5 + y*tileSize)
				endcase
			endselect
		else
			// create wall
			spr = CreateSprite(0)
			SetSpriteVisible(spr, 0)
			SetSpriteSize(spr, tileSize, tileSize)
			SetSpritePhysicsOn(spr, 1)
			SetSpriteShapeBox(spr, -tileSize*0.5, -tileSize*0.5, tileSize*0.5, tileSize*0.5, 0)
			SetSpriteGroup(spr, 1)
			SetSpritePosition(spr, x*tileSize, y*tileSize)
		endif
	next c
	
	// delete the memblock
	DeleteMemblock(mem)
endfunction

//############################ PLACEMENT

//############################ MEDIA
// HERE WE LOAD ALL MEDIA INTO SOME SIMPLE
// ARRAYS READY FOR USE

// create array to store image IDs
global image as integer[]

function LoadMedia()
	// load each image
	image.insert(LoadImage("map.png"))
	image.insert(LoadImage("dots.png"))
	image.insert(LoadImage("pacman.png"))
	image.insert(LoadImage("ghosts.png"))
	image.insert(LoadImage("placement.png"))
	
	// remove image filtering / blur
	for i=0 to image.length
		SetImageMinFilter(image[i], 0)
		SetImageMagFilter(image[i], 0)
	next
endfunction

//############################ MEDIA

//############################ MAP
// HERE WE CREATE ALL OF THE MAIN MAP ELEMENTS

global dot as integer[]

function CreateMap(mapImage)
	// create map sprite
	global map as integer
	map = CreateSprite(image[0])
	SetSpriteSize(map, mapSize, mapSize)
	SetSpriteDepth(map, 1000)
	
	// set tile size
	global tileSize as float
	tileSize = mapSize / 21.0

	// create pacman sprite
	player.spr = CreateSprite(image[2])
	SetSpriteSize(player.spr, tileSize*0.75, tileSize*0.75)
	SetSpriteAnimation(player.spr, 13, 13, 3)
	SetSpriteFrame(player.spr, 1)
	SetSpriteDepth(player.spr, 990)
	player.direction = dir_none
	player.state = state_stopped
	
	// create ghosts
	global ghost as ghostType[]
	for g=1 to 4
		gh as ghostType
		spr = CreateSprite(image[3])
		SetSpriteGroup(spr, 2)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteShapeCircle(spr, 0, 0, tileSize*0.4)
		SetSpriteAnimation(spr, 20, 20, 40)
		SetSpriteDepth(spr, 990)
		
		// select first frame for each colour of ghost
		select g
			case 1
				SetSpriteFrame(spr, 25)
			endcase
			case 2
				SetSpriteFrame(spr, 17)
			endcase
			case 3
				SetSpriteFrame(spr, 9)
			endcase
			case 4
				SetSpriteFrame(spr, 1)
			endcase
		endselect
		
		// insert ghost into type array
		gh.spr = spr
		gh.state = state_spawn
		ghost.insert(gh)
	next
endfunction

//############################ MAP

//############################ GHOSTS
// HERE WE SET UP THE GHOSTS DATA STRUCTURES
// AND CONTROL THEIR ACTIONS USING SIMPLE AI

#constant state_spawn  0
#constant state_search 1
#constant state_chase  2
#constant state_run    3
#constant state_caught 4

type ghostType
	spr   as integer
	state as integer
	direction as integer
	startX as float
	startY as float
	playerX as float
	playerY as float
endtype
global SpawnTime as float
global RunEnd  as float
global RunTime as float
RunTime = 8.0

function UpdateGhosts()
	for g=0 to ghost.length
		x = floor(GetSpriteXByOffset(ghost[g].spr)/tileSize)
		y = floor(GetSpriteYByOffset(ghost[g].spr)/tileSize)
		if x<0
			x = 20
			SetSpritePositionByOffset(ghost[g].spr, GetSpriteXByOffset(ghost[g].spr) + mapSize, GetSpriteYByOffset(ghost[g].spr))
		else
			if x>20
				SetSpritePositionByOffset(ghost[g].spr, GetSpriteXByOffset(ghost[g].spr) - mapSize, GetSpriteYByOffset(ghost[g].spr))
			endif
		endif
		px# = tileSize*0.5 + x*tileSize
		py# = tileSize*0.5 + y*tileSize
		
		// do actions based on state
		select ghost[g].state
			case state_search, state_chase, state_run
				// random search pattern to find player
				sx = GetSpriteXByOffset(ghost[g].spr)
				sy = GetSpriteYByOffset(ghost[g].spr)
				nx = sx
				ny = sy
				
				select ghost[g].direction
					case dir_left  : nx = sx - (tileSize/16) : endcase
					case dir_right : nx = sx + (tileSize/16) : endcase
					case dir_up    : ny = sy - (tileSize/16) : endcase
					case dir_down  : ny = sy + (tileSize/16) : endcase
				endselect
				SetSpritePositionByOffset(ghost[g].spr, nx, ny)
				
				// stop if wall reached
				if GetWallDirection(ghost[g].spr, ghost[g].direction)>0
					SetSpritePositionByOffset(ghost[g].spr, px#, py#)
					if ghost[g].state=state_search
						FindRandomDirection(g)
					else
						if ghost[g].state=state_chase
							FindPlayerDirection(g, 1)
						else
							FindPlayerDirection(g, 0)
						endif
					endif
					ghost[g].startX = px#
					ghost[g].startY = py#
				else
					// if junction reached decide whether to use
					// first check ghost has travelled at least one tile
					travelX# = sx - ghost[g].startX
					travelY# = sy - ghost[g].startY
					d# = Sqrt(travelX#*travelX#+travelY#*travelY#)
					if d#>tileSize*0.5
						// check for valid junction
						checkLR = 0
						if ghost[g].direction=dir_up or ghost[g].direction=dir_down
							dy# = abs(sy-py#)
							if dy#<tileSize*0.1 then checkLR = 1
						endif
						checkUD = 0
						if ghost[g].direction=dir_left or ghost[g].direction=dir_right
							dx# = abs(sx-px#)
							if dx#<tileSize*0.1 then checkUD = 1
						endif
						
						// decide whether to take left / right junction
						if checkLR>0
							lft  = GetWallLeft(ghost[g].spr)=0
							rght = GetWallRight(ghost[g].spr)=0
							ok = lft
							if ok=0 then ok = rght
							ok = Random(0,ok)
							if ok>0
								cy# = tileSize*0.5 + y*tileSize
								dy# = abs(GetSpriteYByOffset(ghost[g].spr)-sy)
								if dy#<tileSize*0.1
									if ghost[g].state=state_search
										SetSpritePositionByOffset(ghost[g].spr, sx, cy#)
										if lft>0 and rght>0
											r = Random(0,1)
											if r=0
												ghost[g].direction = dir_left
											else
												ghost[g].direction = dir_right
											endif
										else
											if lft>0
												ghost[g].direction = dir_left
											else
												ghost[g].direction = dir_right
											endif
										endif
									else
										if ghost[g].state=state_chase
											FindPlayerDirection(g, 1)
										else
											FindPlayerDirection(g, 0)
										endif
									endif
									ghost[g].startX = px#
									ghost[g].startY = py#
								endif
							endif
						endif
						
						// decide whether to take up / down junction
						if checkUD>0
							up   = GetWallUp(ghost[g].spr)=0
							down = GetWallDown(ghost[g].spr)=0
							ok = up
							if ok=0 then ok = down
							ok = Random(0,ok)
							if ok>0
								cx# = tileSize*0.5 + x*tileSize
								dx# = abs(GetSpriteXByOffset(ghost[g].spr)-sx)
								if dx#<tileSize*0.1
									if ghost[g].state=state_search
										SetSpritePositionByOffset(ghost[g].spr, cx#, sy)
										if up>0 and down>0
											r = Random(0,1)
											if r=0
												ghost[g].direction = dir_up
											else
												ghost[g].direction = dir_down
											endif
										else
											if up>0
												ghost[g].direction = dir_up
											else
												ghost[g].direction = dir_down
											endif
										endif
									else
										if ghost[g].state=state_chase
											FindPlayerDirection(g, 1)
										else
											FindPlayerDirection(g, 0)
										endif
									endif
									ghost[g].startX = px#
									ghost[g].startY = py#
								endif
							endif
						endif
					endif
				endif
				
				// check for visible player
				plx# = GetSpriteXByOffset(player.spr)
				ply# = GetSpriteYByOffset(player.spr)
				dx# = plx# - sx
				dy# = ply# - sy
				d# = Sqrt(dx#*dx#+dy#*dy#)
				if d#>tileSize*0.5
					if ghost[g].state<>state_run
						hit = PhysicsRayCastGroup(1, sx, sy, plx#, ply#)
						if hit=0
							ghost[g].state = state_chase
							ghost[g].playerX = plx#
							ghost[g].playerY = ply#
						endif
					endif
				else
					if ghost[g].state<>state_run
						Message("GAME OVER!")
						end
					else
						ghost[g].state = state_caught
						SetSpriteFrame(ghost[g].spr, 37)
					endif
				endif
			endcase
			
			case state_spawn
				// wait in queue to get started
				if now>SpawnTime
					if x=9
						if GetSpriteHitGroup(2, px# + tileSize, py#)=0
							SetSpritePositionByOffset(ghost[g].spr, px# + tileSize, py#)
						endif
					endif
					if x=10
						if GetSpriteHitGroup(2, px#, py# - tileSize)=0
							SetSpritePositionByOffset(ghost[g].spr, px#, py# - tileSize)
							if y=8
								ghost[g].state = state_search
								ghost[g].direction = Random(1,2)
								ghost[g].startX = px#
								ghost[g].startY = py# - tileSize
							endif
						endif
					endif
					if x=11
						if GetSpriteHitGroup(2, px# - tileSize, py#)=0
							SetSpritePositionByOffset(ghost[g].spr, px# - tileSize, py#)
						endif
					endif
				endif
			endcase
		endselect
	next
	if now>SpawnTime
		SpawnTime = now + 1.0
	endif
endfunction

function FindPlayerDirection(g, towards)
	// find best direction to playerXY
	sx# = GetSpriteXByOffset(ghost[g].spr)
	sy# = GetSpriteYByOffset(ghost[g].spr)
	dx# = ghost[g].playerX - sx#
	dy# = ghost[g].playerY - sy#
	pref1 = 0
	pref2 = 0
	pref3 = 0
	pref4 = 0
	if towards=1
		if Abs(dx#)<Abs(dy#)
			if dy#>0
				pref1 = dir_down
				pref4 = dir_up
			else
				pref1 = dir_up
				pref4 = dir_down
			endif
			if dx#>0
				pref2 = dir_right
				pref3 = dir_left
			else
				pref2 = dir_left
				pref3 = dir_right
			endif
		else
			if dx#>0
				pref1 = dir_right
				pref4 = dir_left
			else
				pref1 = dir_left
				pref4 = dir_right
			endif
			if dy#>0
				pref2 = dir_down
				pref3 = dir_up
			else
				pref2 = dir_up
				pref3 = dir_down
			endif
		endif
	else
		if Abs(dx#)<Abs(dy#)
			if dy#>0
				pref1 = dir_up
				pref4 = dir_down
			else
				pref1 = dir_down
				pref4 = dir_up
			endif
			if dx#>0
				pref2 = dir_left
				pref3 = dir_right
			else
				pref2 = dir_right
				pref3 = dir_left
			endif
		else
			if dx#>0
				pref1 = dir_left
				pref4 = dir_right
			else
				pref1 = dir_right
				pref4 = dir_left
			endif
			if dy#>0
				pref2 = dir_up
				pref3 = dir_down
			else
				pref2 = dir_down
				pref3 = dir_up
			endif
		endif
	endif
	
	dir = 0
	dir = GetPrefAvailable(g, pref1)
	if dir=0 then dir = GetPrefAvailable(g, pref2)
	if dir=0 then dir = GetPrefAvailable(g, pref3)
	if dir=0 then dir = GetPrefAvailable(g, pref4)
	
	ghost[g].direction = dir
	ghost[g].startX = sx#
	ghost[g].startY = sy#
endfunction

function GetPrefAvailable(g, pref)
	dir = 0
	if pref=dir_left and dir=0
		if GetWallLeft(ghost[g].spr)=0
			dir = dir_left
		endif
	endif
	if pref=dir_right and dir=0
		if GetWallRight(ghost[g].spr)=0
			dir = dir_right
		endif
	endif
	if pref=dir_up and dir=0
		if GetWallUp(ghost[g].spr)=0
			dir = dir_up
		endif
	endif
	if pref=dir_down and dir=0
		if GetWallDown(ghost[g].spr)=0
			dir = dir_down
		endif
	endif
endfunction dir

function FindRandomDirection(g)
	// find new direction
	sx# = GetSpriteXByOffset(ghost[g].spr)
	sy# = GetSpriteYByOffset(ghost[g].spr)
	x = floor(sx#/tileSize)
	y = floor(sy#/tileSize)
	done = 0
	repeat
		newD = Random(1, 4)
		if newD<>ghost[g].direction
			select newD
				case dir_left
					if ghost[g].direction<>dir_right
						if GetWallLeft(ghost[g].spr)=0
							done = newD
						endif
					endif
				endcase
				case dir_right
					if ghost[g].direction<>dir_left
						if GetWallRight(ghost[g].spr)=0
							done = newD
						endif
					endif
				endcase
				case dir_up
					if ghost[g].direction<>dir_down
						if GetWallUp(ghost[g].spr)=0
							done = newD
						endif
					endif
				endcase
				case dir_down
					if ghost[g].direction<>dir_up
						if GetWallDown(ghost[g].spr)=0
							done = newD
						endif
					endif
				endcase
			endselect
		endif
	until done>0
	ghost[g].direction = done
endfunction

function SetGhostsRun()
	RunEnd = now + RunTime
	for g=0 to ghost.length
		SetSpriteFrame(ghost[g].spr, 33)
		if ghost[g].state = state_chase
			ghost[g].state = state_run
		else
			ghost[g].state = state_search
		endif
	next
endfunction

//############################ GHOSTS

// Project: GunRun 
// Created: 2017-03-14

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "GunRun" )
SetWindowSize( 1024, 660, 0 )

// set display properties
SetVirtualResolution( 1024, 660 )
SetOrientationAllowed( 0, 0, 1, 1 )
SetSyncRate( 60, 0 )
UseNewDefaultFonts( 1 )
SetPrintSize(18)

// set up main variables and constants
#constant mode_menu      0
#constant mode_game      1
#constant mode_game_over 2
global MODE as integer
MODE = mode_menu

global HIGHSCORE as integer
HIGHSCORE = 0

// load game data
LoadGame()

// create the menu
InitMenu()

`SetPhysicsDebugOn()

do
    `Print( "fps: " + Str(ScreenFPS(), 0) )
	GetInput()
    
    // state engine for current game state
    select MODE
		case mode_menu
			UpdateMenu()
		endcase
		
		case mode_game
			UpdateGame()
		endcase
		
		case mode_game_over
			if GetPointerPressed()>0
				DeleteMenu()
				InitMenu()
			endif
		endcase
	endselect
	
	UpdateAllTweens(GetFrameTime())
    
    Sync()
loop

//####################################### MAP
// Creates and updates the maze / map

#constant tileSize 60
global nextTile as integer

function UpdateMap()
	w = 20
	h = 11
	if game.x>nextTile
		nextTile = nextTile + tileSize*2
		for i=0 to game.spr.length
			if GetSpriteX(game.spr[i])<nextTile-tileSize*4
				DeleteSprite(game.spr[i])
				game.spr.remove(i)
				dec i
			endif
		next
		
		cx = nextTile/tileSize + w
		// create borders and blocks
		spr = CreateSprite(0)
		SetSpritePosition(spr, cx*tileSize, 0)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		SetSpriteGroup(spr, 1)
		SetSpriteShape(spr, 2)
		game.spr.insert(spr)
		spr = CreateSprite(0)
		SetSpritePosition(spr, (cx+1)*tileSize, 0)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		SetSpriteGroup(spr, 1)
		SetSpriteShape(spr, 2)
		game.spr.insert(spr)
		spr = CreateSprite(0)
		SetSpritePosition(spr, cx*tileSize, (h-1)*tileSize)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		SetSpriteGroup(spr, 1)
		SetSpriteShape(spr, 2)
		game.spr.insert(spr)
		spr = CreateSprite(0)
		SetSpritePosition(spr, (cx+1)*tileSize, (h-1)*tileSize)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		SetSpriteGroup(spr, 1)
		SetSpriteShape(spr, 2)
		game.spr.insert(spr)
		for y=2 to h-3 step 2
			spr = CreateSprite(0)
			SetSpritePosition(spr, cx*tileSize, y*tileSize)
			SetSpriteSize(spr, tileSize, tileSize)
			SetSpriteColor(spr, 128, 128, 128, 255)
			SetSpriteGroup(spr, 1)
			SetSpriteShape(spr, 2)
			game.spr.insert(spr)
		next
	
		// create maze
		e = Random(0,4)
		for a=0 to 4
			b = Random(0,5)
			if b=1 or b=e
				spr = CreateSprite(0)
				SetSpritePosition(spr, cx*tileSize, (1 + (a*2))*tileSize)
				SetSpriteSize(spr, tileSize, tileSize)
				SetSpriteColor(spr, 128, 128, 128, 255)
				SetSpriteGroup(spr, 1)
				SetSpriteShape(spr, 2)
				game.spr.insert(spr)
			endif
		next
		for y=2 to h-3 step 2
			b = Random(0,1)
			if b=1
				spr = CreateSprite(0)
				SetSpritePosition(spr, (cx+1)*tileSize, y*tileSize)
				SetSpriteSize(spr, tileSize, tileSize)
				SetSpriteColor(spr, 128, 128, 128, 255)
				SetSpriteGroup(spr, 1)
				SetSpriteShape(spr, 2)
				game.spr.insert(spr)
			endif
		next
		
		// create dots
		for x=cx to cx+1
			for y=1 to h-1
				if GetSpriteHitGroup(1, x*tileSize+tileSize*0.5, y*tileSize+tileSize*0.5)=0
					spr = CreateSprite(0)
					SetSpritePositionByOffset(spr, x*tileSize+tileSize*0.5, y*tileSize+tileSize*0.5)
					SetSpriteSize(spr, tileSize*0.25, tileSize*0.25)
					SetSpriteColor(spr, 255, 255, 0, 255)
					SetSpriteGroup(spr, 2)
					SetSpriteShape(spr, 2)
					SetSpriteDepth(spr, 100)
					game.spr.insert(spr)
				endif
			next
		next
	endif
endfunction

function CreateMap()
	w = 20
	h = 11
	
	// create borders and blocks
	for x=0 to w-1
		spr = CreateSprite(0)
		SetSpritePosition(spr, x*tileSize, 0)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		game.spr.insert(spr)
	next
	for x=0 to w-1
		spr = CreateSprite(0)
		SetSpritePosition(spr, x*tileSize, (h-1)*tileSize)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		game.spr.insert(spr)
	next
	for y=1 to h-2
		spr = CreateSprite(0)
		SetSpritePosition(spr, 0, y*tileSize)
		SetSpriteSize(spr, tileSize, tileSize)
		SetSpriteColor(spr, 128, 128, 128, 255)
		game.spr.insert(spr)
	next
	for x=2 to w-1 step 2
		for y=2 to h-3 step 2
			spr = CreateSprite(0)
			SetSpritePosition(spr, x*tileSize, y*tileSize)
			SetSpriteSize(spr, tileSize, tileSize)
			SetSpriteColor(spr, 128, 128, 128, 255)
			game.spr.insert(spr)
		next
	next
	
	// create maze
	for x=2 to w-1 step 2
		e = Random(0,4)
		for a=0 to 4
			b = Random(0,5)
			if b=1 or b=e
				spr = CreateSprite(0)
				SetSpritePosition(spr, x*tileSize, (1 + (a*2))*tileSize)
				SetSpriteSize(spr, tileSize, tileSize)
				SetSpriteColor(spr, 128, 128, 128, 255)
				game.spr.insert(spr)
			endif
		next
	next
	for x=1 to w-1 step 2
		for y=2 to h-3 step 2
			b = Random(0,1)
			if b=1
				spr = CreateSprite(0)
				SetSpritePosition(spr, x*tileSize, y*tileSize)
				SetSpriteSize(spr, tileSize, tileSize)
				SetSpriteColor(spr, 128, 128, 128, 255)
				game.spr.insert(spr)
			endif
		next
	next
	
	for i=0 to game.spr.length
		SetSpriteGroup(game.spr[i], 1)
		SetSpriteShape(game.spr[i], 2)
	next
		
	// create dots
	for x=1 to w-1
		for y=1 to h-1
			if GetSpriteHitGroup(1, x*tileSize+tileSize*0.5, y*tileSize+tileSize*0.5)=0
				spr = CreateSprite(0)
				SetSpritePositionByOffset(spr, x*tileSize+tileSize*0.5, y*tileSize+tileSize*0.5)
				SetSpriteSize(spr, tileSize*0.25, tileSize*0.25)
				SetSpriteColor(spr, 255, 255, 0, 255)
				SetSpriteGroup(spr, 2)
				SetSpriteShape(spr, 2)
				SetSpriteDepth(spr, 100)
				game.spr.insert(spr)
			endif
		next
	next
	
	nextTile = -tileSize*2
endfunction

//####################################### MAP

//####################################### INPUT
// gets user input from keyboard only currently

type inputType
	U as integer
	D as integer
	L as integer
	R as integer
endtype
global input as inputType

function GetInput()
	`print(str(GetRawLastKey()))
	input.U = GetRawKeyState(38)
	input.D = GetRawKeyState(40)
	input.L = GetRawKeyState(37)
	input.R = GetRawKeyState(39)
endfunction

//####################################### INPUT

//####################################### PLAYER
// creates and controls the player based on user input

type playerType
	spr  as integer
	mode as integer
	tween as integer
	position as integer[1]
endtype
global player as playerType

function UpdatePlayer()
	select player.mode
		case 0
			// not moving
			GetNewDirection()
		endcase
		case 1,2,3,4
			if GetTweenSpritePlaying(player.tween, player.spr)=0
				DeleteTween(player.tween)
				player.mode = 0
				GetNewDirection()
			endif
		endcase
	endselect
	for i=0 to game.spr.length
		if GetSpriteGroup(game.spr[i])=2
			dx# = abs(GetSpriteXByOffset(player.spr) - GetSpriteXByOffset(game.spr[i]))
			if dx#<tileSize*0.4
				dy# = abs(GetSpriteYByOffset(player.spr) - GetSpriteYByOffset(game.spr[i]))
				if dy#<tileSize*0.4
					DeleteSprite(game.spr[i])
					game.spr.remove(i)
					dec i
					game.score = game.score + 10
					SetTextString(game.txt[1], "Score: "+str(game.score))
				endif
			endif
		endif
	next
	
	if WorldToScreenX(GetSpriteX(player.spr))<0
		game.lives = game.lives-1
		if game.lives=0
			DeleteGame()
			MODE = mode_game_over
			
			msg$ = "Game Over"
			if game.score>HIGHSCORE
				msg$ = msg$ + chr(10) + "New Highscore!!"
				HIGHSCORE = game.score
				SaveGame()
			endif
			txt = CreateText(msg$)
			SetTextSize(txt, 64)
			SetTextPosition(txt, 512, 300-GetTextTotalHeight(txt)*0.5)
			SetTextAlignment(txt, 1)
			FixTextToScreen(txt, 1)
			menu.txt.insert(txt)
			SetViewOffset(0,0)
		else
			lives = game.lives
			score = game.score
			DeleteGame()
			InitGame()
			game.lives = lives
			game.score = score
			SetTextString(game.txt[0], "Lives: "+str(lives))
			SetTextString(game.txt[1], "Score: "+str(score))
		endif
	endif
endfunction

function GetNewDirection()
	dirx = input.R-input.L
	if dirx=0
		diry = input.D-input.U
	endif
	if dirx>0 then dirx=1
	if dirx<0 then dirx=-1
	if diry>0 then diry=1
	if diry<0 then diry=-1
	if abs(dirx)+abs(diry)>0
		player.mode = GetDirectionValid(player.position[0], player.position[1], dirx, diry)
		if player.mode<>0
			player.position[0] = player.position[0] + dirx
			player.position[1] = player.position[1] + diry
			x1# = GetSpriteXByOffset(player.spr)
			y1# = GetSpriteYByOffset(player.spr)
			x2# = x1#
			y2# = y1#
			select player.mode
				case 1 : y2# = y1#-tileSize : endcase
				case 2 : y2# = y1#+tileSize : endcase
				case 3 : x2# = x1#-tileSize : endcase
				case 4 : x2# = x1#+tileSize : endcase
			endselect
			f# = game.acc*0.055
			v# = 0.5 - f#
			if v#<0.05 then v# = 0.05
			t = CreateTweenSprite(v#)
			SetTweenSpriteXByOffset(t, x1#, x2#, 0)
			SetTweenSpriteYByOffset(t, y1#, y2#, 0)
			PlayTweenSprite(t, player.spr, 0)
			player.tween = t
		endif
	endif
endfunction

function CreatePlayer()
	spr = CreateSprite(0)
	SetSpriteDepth(spr, 50)
	SetSpriteColor(spr, 0, 0, 255, 255)
	SetSpriteSize(spr, tileSize*0.8, tileSize*0.8)
	SetSpritePositionByOffset(spr, tileSize*3.5, 330)
	player.spr = spr
	player.mode = 0
	player.position[0] = 3
	player.position[1] = 5
endfunction

function GetDirectionValid(x, y, dirx, diry)
	d = 0
	x1# = x*tileSize + tileSize*0.5
	y1# = y*tileSize + tileSize*0.5
	x2# = x1# + dirx*tileSize
	y2# = y1# + diry*tileSize
	hit = GetSpriteHitGroup(1, x2#, y2#)
	if hit=0
		if dirx>0 then d = 4
		if dirx<0 then d = 3
		if diry>0 then d = 2
		if diry<0 then d = 1
	endif
endfunction d

//####################################### PLAYER

//####################################### GAME
// creates and runs the game

type gameType
	x     as float
	acc   as float
	speed as float
	lives as integer
	score as integer
	txt   as integer[]
	spr   as integer[]
endtype
global game as gameType

function UpdateGame()
	game.x = game.x + GetFrameTime()*game.speed*game.acc
	SetViewOffset(game.x, 0)
	UpdatePlayer()
	UpdateMap()
	game.acc = game.acc + GetFrameTime()*0.1
	`print("GAME SPEED: "+str(game.acc))
endfunction

function InitGame()
	game.x     = -tileSize
	game.acc   = 1.0
	game.speed = 40
	game.lives = 3
	game.score = 0
	SetViewOffset(game.x, 0)
	
	txt = CreateText("Lives: 3")
	SetTextAlignment(txt, 0)
	SetTextSize(txt, 32)
	SetTextPosition(txt, 0, 0)
	FixTextToScreen(txt, 1)
	game.txt.insert(txt)
	
	txt = CreateText("Score: 0")
	SetTextAlignment(txt, 2)
	SetTextSize(txt, 32)
	SetTextPosition(txt, 1024, 0)
	FixTextToScreen(txt, 1)
	game.txt.insert(txt)
	
	CreateMap()
	
	CreatePlayer()
	
	MODE = mode_game
endfunction

function DeleteGame()
	for i=0 to game.txt.length
		DeleteText(game.txt[i])
	next
	game.txt.length = -1
	for i=0 to game.spr.length
		DeleteSprite(game.spr[i])
	next
	game.spr.length = -1
	DeleteSprite(player.spr)
endfunction

//####################################### GAME

//####################################### MENU
// creates and deletes menu

type menuType
	txt as integer[]
	spr as integer[]
endtype
global menu as menuType

function UpdateMenu()
	if GetPointerPressed()>0
		if GetTextHitTest(menu.txt[0], GetPointerX(), GetPointerY())>0
			// Start
			DeleteMenu()
			InitGame()
		endif
		
		if MODE=mode_menu
			if GetTextHitTest(menu.txt[1], GetPointerX(), GetPointerY())>0
				// Quit
				end
			endif
		endif
	endif
endfunction

function InitMenu()
	txt = CreateText("Start")
	SetTextAlignment(txt, 1)
	SetTextSize(txt, 64)
	SetTextPosition(txt, 512, 300-128)
	menu.txt.insert(txt)
	
	txt = CreateText("Quit")
	SetTextAlignment(txt, 1)
	SetTextSize(txt, 64)
	SetTextPosition(txt, 512, 300-32)
	menu.txt.insert(txt)
	
	txt = CreateText("Highscore: " + str(HIGHSCORE))
	SetTextAlignment(txt, 1)
	SetTextSize(txt, 64)
	SetTextPosition(txt, 512, 300+64)
	menu.txt.insert(txt)
	
	MODE = mode_menu
endfunction

function DeleteMenu()
	for i=0 to menu.txt.length
		DeleteText(menu.txt[i])
	next
	menu.txt.length = -1
	for i=0 to menu.spr.length
		DeleteSprite(menu.spr[i])
	next
	menu.spr.length = -1
endfunction

//####################################### MENU

//####################################### FILE
// loads and saves game data

#constant gamefile "gamedata.dat"

function LoadGame()
	if GetFileExists(gamefile)>0
		fn = OpenToRead(gamefile)
		HIGHSCORE = ReadInteger(fn)
		CloseFile(fn)
	endif
endfunction

function SaveGame()
	fn = OpenToWrite(gamefile)
	WriteInteger(fn, HIGHSCORE)
	CloseFile(fn)
endfunction

//####################################### FILE

// Project: Frogger Template by fubarpk
// Created: 2017-03-22
#constant xMax=1024
#constant yMax=600
#constant timePerGame=120
// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "Frogger" )
SetWindowSize( xMax,yMax,0)
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( xMax, yMax ) // doesn't have to match the window
SetOrientationAllowed( 0, 0, 1, 1 ) // 
//SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

playFrogger()
end

function playFrogger()
deleteSprite(900)
//createSprite(900,ellipse)
createSprite(900,0)
setSpritecolor(900,0,0,0,255)
SetSpriteSize(900,xMax,yMax)
SetSpriteDepth(900,9997)
//SetSpritePositionByOffset(900,xMax/2,yMax/2)
//DeleteSprite(901)
repeat
	Print ("My Frogger template click mouse to Play")
	sync()
until GetPointerState() = 1 //click mouse to play

high=0:score=0:bonusTime=0
bonusTime$="Time Left :"+str(bonusTime)
CreateText(1,bonusTime$)
SetTextSize(1,40)
SetTextPosition(1,10,0)
myHigh$="High :"+str(high)
CreateText(2,myHigh$)
SetTextSize(2,40)
SetTextDepth(2,0)
SetTextPosition(2,600,0)
myScore$="Score:"+str(score)
CreateText(3,myScore$)
SetTextSize(3,40)
SetTextDepth(3,0)
SetTextPosition(3,820,0)

frogSpr = CreateSprite(0)
SetSpriteSize(frogSpr,64,64)
changeFrogColor(frogSpr,1)

SetSpriteDepth(frogSpr,15)
do
	elapsedTime#=Timer()
	resetTimer()

	repeat
		SetSpriteDepth(900,10000)
		
		score=crossRoadLevel(frogSpr,score)
		if high<score then high = score
		myScore$="Score:"+str(score):myHigh$="High :"+str(high)
		SetTextString(2,myHigh$):SetTextString(3,myScore$)

		sync()
		//resetTimer()
		score=crossRiverLevel(frogSpr,score)
		if high<score then high = score
		myScore$="Score:"+str(score):myHigh$="High :"+str(high)
		SetTextString(2,myHigh$):SetTextString(3,myScore$)
		//SetSpriteDepth(901,9998):SetSpriteDepth(902,9999)
	
		SetSpriteAngle(frogSpr,0)
		sync()
		elapsedTime#=Timer()
	until elapsedTime#>timePerGame //limited time per attempt
	sync()
	setSpritecolor(900,0,0,0,255)
	gameOver()
	score=0:changeFrogColor(frogSpr,1)
	myScore$="Score:"+str(score)
	SetTextString(3,myScore$)
loop
endfunction 

function crossRoadLevel(frogSpr as integer,score as integer)
setSpritecolor(900,150,150,150,255)
for num = 1 to 5
	DeleteSprite(num):deleteSprite(num+5):deleteSprite(num+10)
	DeleteSprite(num+15):DeleteSprite(num+20)
	rem top road moving right cars and trucks
	createSprite(num,0)
	SetSpriteSize(num,60,128)
	SetSpriteColor(num,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num,90)
	createSprite(num+5,0)
	SetSpriteSize(num+5,60,148)
	SetSpriteColor(num+5,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+5,90)
	rem bottom road moving left cars and trucks
	createSprite(num+10,0)
	SetSpriteSize(num+10,60,128)
	SetSpriteColor(num+10,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+10,270)
	createSprite(num+15,0)
	SetSpriteSize(num+15,60,148)
	SetSpriteColor(num+15,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+15,270)
	placeVehicles(num)
next num

changeColor=placeBonusFruit(500)

SetSpriteDepth(frogSpr,15)

SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
x#=GetSpriteXByOffset (frogSpr)
y#=GetSpriteYByOffset (frogSpr)
newx#=0:newy#=0
time#=timer()
repeat 
until timer()-time#>1
FrogAnimNum=1
SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
//PlaySprite( frogSpr, 10, 0, FrogAnimNum, FrogAnimNum )	
SetSpriteAngle(frogSpr,0)
bonusTime=timePerGame-timer()
while GetSpriteYByOffset(frogSpr)-35>0 and bonusTime >0
	bonusTime$="Time Left :"+str(bonusTime)
	SetTextString(1,bonusTime$)

	//if mouse pointer is down then move frogSpr towards it
	if GetPointerState() = 1
		//if GetSpritePlaying(frogSpr)=0 then PlaySprite( frogSpr, 5, 0, frogAnimNum,frogAnimNum+2 )
		ft# = getFrameTime()*2
		x#=GetPointerX():y# = GetPointerY()
		cx#=GetSpriteXByOffset(frogSpr):cy# = getSpriteYbyOffset(frogSpr)
		newx# = cx#-(cx#-x#)*ft#:newy# = cy#-(cy#-y#)*ft#
		SetSpriteAngle(frogSpr,getAngle(x#,y#,cx# ,cy#))
    	SetSpritePositionByOffset(frogSpr,newx#,newy#)
	endif
	//if GetSpritePlaying(frogSpr)=0 then PlaySprite( frogSpr, 6, 0, frogAnimNum,frogAnimNum )
    if moveVehicles(frogSpr)=1 
		//if GetSoundInstancePlaying(1)=0 then playSound(1,100,0)
		time#=timer()
		repeat 
			a=moveVehicles(frogSpr)
			sync()
		until timer()-time#>1
		SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
		SetSpriteAngle(frogSpr,0)
    endif
 	If GetSpriteCollision(frogSpr,500)=1 and GetSpriteVisible(500)=1 
		changeFrogColor(frogSpr,changeColor)
		score=score+250
		myScore$="Score:"+str(score)
		SetTextString(3,myScore$)
		SetSpriteVisible(500,0)
		//if GetSoundInstancePlaying(2)=0 then PlaySound(2)
	endif 
    //Print( ScreenFPS() )
    bonusTime=timePerGame-timer()
	Sync()
endwhile
if bonusTime>0 then score=score+(10*bonusTime)
endfunction score   


function crossRiverLevel(frogSpr as integer,score as integer)
setSpritecolor(900,0,0,140,255)		
rem y=105:y=210:y=395:y=495
for num = 1 to 5
	DeleteSprite(num):deleteSprite(num+5):deleteSprite(num+10)
	DeleteSprite(num+15):DeleteSprite(num+20)
	rem top road moving 
	createSprite(num,0)
	SetSpriteColor(num,139,69,19,255)
	SetSpriteSize(num,128,64)
	SetSpriteDepth(num,20)
	
	createSprite(num+5,0)
	SetSpriteColor(num+5,139,69,19,255)
	SetSpriteSize(num+5,186,64)
	SetSpriteDepth(num+5,20)

	rem bottom river moving left Logs
	CreateSprite(num+10,0)
	SetSpriteColor(num+10,139,69,19,255)
	SetSpriteSize(num+10,186,64)
	SetSpriteDepth(num+10,20)
	
	CreateSprite(num+15,0)
	SetSpriteColor(num+15,139,69,19,255)
	SetSpriteSize(num+15,128,64)
	SetSpriteDepth(num+15,20)
	
	rem 5 crocodiles
	CreateSprite(num+20,0)
	SetSpriteColor(num+20,128,128,128,255)
	SetSpriteSize(num+20,128,64)
	SetSpriteDepth(num+20,20)
	placeLogs(num)
next num	
//change colour of frog if eats fruit
changeColor=placeBonusFruit(500)
SetSpriteDepth(frogSpr,15)

//SetSpriteAnimation(frogSpr,96,96,18)
//PlaySprite( frogSpr, 10, 0, FrogAnimNum, FrogAnimNum )	

time#=timer()
repeat 
until timer()-time#>1	
SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
//PlaySprite( frogSpr, 10, 0, FrogAnimNum, FrogAnimNum )	
SetSpriteAngle(frogSpr,0)
bonusTime=timePerGame-timer()
while GetSpriteYByOffset(frogSpr)-35>0 and bonusTime >0
	bonusTime$="Time Left :"+str(bonusTime)
	SetTextString(1,bonusTime$)
		//if mouse pointer is down then move frogSpr towards it
	if GetPointerState() = 1
		//if GetSpritePlaying(frogSpr)=0 then PlaySprite( frogSpr, 5, 0, frogAnimNum,frogAnimNum+2 )
		ft# = getFrameTime()*2
		x#=GetPointerX():y# = GetPointerY()
		cx#=GetSpriteXByOffset(frogSpr):cy# = getSpriteYbyOffset(frogSpr)
		newx# = cx#-(cx#-x#)*ft#:newy# = cy#-(cy#-y#)*ft#
		SetSpriteAngle(frogSpr,getAngle(x#,y#,cx# ,cy#))
    	SetSpritePositionByOffset(frogSpr,newx#,newy#)
	endif
	//if GetSpritePlaying(frogSpr)=0 then PlaySprite( frogSpr, 6, 0, frogAnimNum,frogAnimNum )
	rem move logs go here 30 568
	//a=moveLogs(frogSpr)
	if moveLogs(frogSpr)=0 and GetSpriteYByOffset(frogSpr)<536 and GetSpriteYByOffset(frogSpr)>50
		//if GetSoundInstancePlaying(3)=0 then PlaySound(3)
		time#=timer()
		repeat 
			a=moveLogs(frogSpr)
			sync()	
		until timer()-time#>1
		SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
		SetSpriteAngle(frogSpr,0)
	endif
	if GetSpriteXByOffset(frogSpr)<0 or GetSpriteXByOffset(frogSpr)>xMax
		//if GetSoundInstancePlaying(3)=0 then PlaySound(3):rem change later
		time#=timer()
		repeat 
			a=moveLogs(frogSpr)
			sync()	
		until timer()-time#>1
		SetSpritePositionByOffset(frogSpr,xMax/2,yMax-40)
		SetSpriteAngle(frogSpr,0)
	endif
	If GetSpriteCollision(frogSpr,500)=1 and GetSpriteVisible(500)=1 
		changeFrogColor(frogSpr,changeColor)
		score=score+250
		myScore$="Score:"+str(score)
		SetTextString(3,myScore$)
		SetSpriteVisible(500,0)
		//if GetSoundInstancePlaying(2)=0 then PlaySound(2)
	endif 
	bonusTime=timePerGame-timer()
	sync()
endwhile  
if bonusTime>0 then score=score+(10*bonusTime)
endfunction score


function getAngle(x1#, y1#, x2#, y2#)
    result# = ATanFull(x1# - x2#, y1# - y2#)
endfunction result# 

function placeVehicles(num as integer)
//randomly place vehicles watching/repeating for collisions
rem y=105:y=210:y=395:y=495
SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
SetSpritePositionByOffset(num+10,random2(xMax,xMax*2),395)
SetSpritePositionByOffset(num+15,random2(xMax,xMax*2),495)

for check= 1 to num
	while GetSpriteCollision(num,check)=1 and num <> check
		SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
		check=1
	endwhile
	while GetSpriteCollision(num+5,check+5)=1 and num <> check
		SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
		check=1
	endwhile
	while GetSpriteCollision(num+10,check+10)=1 and num <> check
		SetSpritePositionByOffset(num+10,random2(0,xMax*2),395)
		check=1
	endwhile
	while GetSpriteCollision(num+15,check+15)=1 and num <> check
		SetSpritePositionByOffset(num+15,random2(0,xMax*2),495)
		check=1
	endwhile
next check	
endfunction

function moveVehicles(frogSpr as integer)
collision=0
for num = 1 to 5
	SetSpritePositionByOffset(num,(GetSpriteXByOffset(num)+4),GetSpriteYByOffset(num))
	if GetSpriteXByOffset(num)>xMax*2 then SetSpritePositionByOffset(num,-xMax,GetSpriteYByOffset(num))
	if GetSpriteCollision( frogSpr, num ) then collision=1 
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+5,(GetSpriteXByOffset(num+5)+4),GetSpriteYByOffset(num+5))
	if GetSpriteXByOffset(num+5)>xMax*2 then SetSpritePositionByOffset(num+5,-xMax,GetSpriteYByOffset(num+5))
	if GetSpriteCollision( frogSpr, num+5 ) then collision=1
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+10,(GetSpriteXByOffset(num+10))-4,GetSpriteYByOffset(num+10))
	if GetSpriteXByOffset(num+10)<-xMax then SetSpritePositionByOffset(num+10,xMax*2,GetSpriteYByOffset(num+10))
	if GetSpriteCollision( frogSpr, num+10 ) then collision=1 
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+15,(GetSpriteXByOffset(num+15))-4,GetSpriteYByOffset(num+15))
	if GetSpriteXByOffset(num+15)<-xMax then SetSpritePositionByOffset(num+15,xMax*2,GetSpriteYByOffset(num+15))
	if GetSpriteCollision( frogSpr, num+15 ) then collision=1 
next num
if collision=1 then PlaySprite( frogSpr, 6, 0, 6, 6 )
endfunction collision

function moveLogs(frogSpr as integer)
collision=0	
for num = 1 to 5
	SetSpritePositionByOffset(num,(GetSpriteXByOffset(num)+4),GetSpriteYByOffset(num))
	if GetSpriteXByOffset(num)>xMax*2 then SetSpritePositionByOffset(num,-xMax,GetSpriteYByOffset(num))
	if GetSpriteCollision( frogSpr, num ) 
		SetSpritePositionByOffset(frogSpr,GetSpriteXByOffset(frogSpr)+4,GetSpriteYByOffset(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+5,(GetSpriteXByOffset(num+5)+4),GetSpriteYByOffset(num+5))
	if GetSpriteXByOffset(num+5)>xMax*2 then SetSpritePositionByOffset(num+5,-xMax,GetSpriteYByOffset(num+5))
	if GetSpriteCollision( frogSpr, num+5 ) 
		SetSpritePositionByOffset(frogSpr,GetSpriteXByOffset(frogSpr)+4,GetSpriteYByOffset(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+10,(GetSpriteXByOffset(num+10))-4,GetSpriteYByOffset(num+10))
	if GetSpriteXByOffset(num+10)<-xMax then SetSpritePositionByOffset(num+10,xMax*2,GetSpriteYByOffset(num+10))
	if GetSpriteCollision( frogSpr, num+10 ) 
		SetSpritePositionByOffset(frogSpr,GetSpriteXByOffset(frogSpr)-4,GetSpriteYByOffset(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+15,(GetSpriteXByOffset(num+15))-4,GetSpriteYByOffset(num+15))
	if GetSpriteXByOffset(num+15)<-xMax then SetSpritePositionByOffset(num+15,xMax*2,GetSpriteYByOffset(num+15))
	if GetSpriteCollision( frogSpr, num+15 ) 
		SetSpritePositionByOffset(frogSpr,GetSpriteXByOffset(frogSpr)-4,GetSpriteYByOffset(frogSpr)) 
		collision=1
	endif
next num
rem crocdiles
for num = 1 to 5
	SetSpritePositionByOffset(num+20,(GetSpriteXByOffset(num+20)+2),GetSpriteYByOffset(num+20))
	if GetSpriteXByOffset(num+20)>xMax*2 then SetSpritePositionByOffset(num+20,-xMax,GetSpriteYByOffset(num+20))
	if GetSpriteCollision( frogSpr, num+20 ) 
		SetSpritePositionByOffset(frogSpr,GetSpriteXByOffset(frogSpr)+2,GetSpriteYByOffset(frogSpr)) 
		collision=1
	endif
next num
endfunction collision 


function createEllipse()
    Render()
    DrawEllipse(10,10,10,10,MakeColor(255,255,255),MakeColor(255,255,255),1)
    Swap()
    img = getimage(0,0,22,22)
    sync()
endfunction img

function placeBonusFruit(spr as integer)
If getSpriteExists(spr) then DeleteSprite(spr)	
CreateSprite(spr,createEllipse())
SetSpritePositionByOffset(spr,random(10,xMax-10),yMax/2)
SetSpriteDepth (spr,20)
ran=random (1,5)
select ran:
	case 1:
		SetSpriteColor(spr,113,161,25,255):rem green
	endcase
	case 2:
		SetSpriteColor(spr,92,92,255,255):rem blue
	endcase
	case 3:
		SetSpriteColor(spr,190,152,0,255):rem gold
	endcase
	case 4:
		SetSpriteColor(spr,168,35,168,255):rem Purple
	endcase
	case 5:
		SetSpriteColor(spr,246,125,0,255):rem Orange
	endcase
endselect
color=ran	
endfunction color	

function changeFrogColor(spr as integer,num)
select num:
	case 1:
		SetSpriteColor(spr,113,161,25,255):rem green
	endcase
	case 2:
		SetSpriteColor(spr,92,92,255,255):rem blue
	endcase
	case 3:
		SetSpriteColor(spr,190,152,0,255):rem gold
	endcase
	case 4:
		SetSpriteColor(spr,168,35,168,255):rem Purple
	endcase
	case 5:
		SetSpriteColor(spr,246,125,0,255):rem Orange
	endcase
endselect	
endfunction

function placeLogs(num as integer)
//randomly place logs crocs etc repeating for collisions
rem y=105:y=210:y=395:y=495
SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
SetSpritePositionByOffset(num+10,random2(xMax,xMax*2),395)
SetSpritePositionByOffset(num+15,random2(xMax,xMax*2),495)
SetSpritePositionByOffset(num+20,random2(-xMax,xMax),302)


for check= 1 to num
	while GetSpriteCollision(num,check)=1 and num <> check
		SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
		check=1
	endwhile
	while GetSpriteCollision(num+5,check+5)=1 and num <> check
		SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
		check=1
	endwhile
	while GetSpriteCollision(num+10,check+10)=1 and num <> check
		SetSpritePositionByOffset(num+10,random2(0,xMax*2),395)
		check=1
	endwhile
	while GetSpriteCollision(num+15,check+15)=1 and num <> check
		SetSpritePositionByOffset(num+15,random2(0,xMax*2),495)
		check=1
	endwhile
	while GetSpriteCollision(num+20,check+20)=1 and num <> check
		SetSpritePositionByOffset(num+20,random2(-xMax,xMax),302)
		check=1
	endwhile
next check	
endfunction

function gameOver()
	SetTextVisible(1,0)
	time#=timer()
	repeat 
	until timer()-time#>1
	ClearScreen()
    repeat
		Print("Game Over click mouse to continue") 
		sync()
    until GetPointerPressed() = 1
    SetTextVisible(1,1)	
endfunction

// Project: Frogger Template by fubarpk
// Created: 2017-03-22
#constant KEY_LEFT  =  37 //the left arrow key scancode
#constant KEY_UP =  38    //the up arrow key scancode
#constant KEY_RIGHT = 39  //the right arrow key scancode
#constant KEY_DOWN  =  40 //the down arrow key scancode
#constant xMax=1024
#constant yMax=600
#constant timePerGame=120
// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "Frogger" )
SetWindowSize( xMax,yMax,0)
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( xMax, yMax ) // doesn't have to match the window
SetOrientationAllowed( 0, 0, 1, 1 ) // 
//SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

playFrogger()
end

function playFrogger()
deleteSprite(900)
//createSprite(900,ellipse)
createSprite(900,0)
setSpritecolor(900,0,0,0,255)
SetSpriteSize(900,xMax,yMax)
SetSpriteDepth(900,9997)
//SetSpritePositionByOffset(900,xMax/2,yMax/2)
//DeleteSprite(901)
repeat
	Print ("My Frogger template click space to Play")
	sync()
until GetRawKeyPressed(32) = 1 //click mouse to play

high=0:score=0:bonusTime=0
bonusTime$="Time Left :"+str(bonusTime)
CreateText(1,bonusTime$)
SetTextSize(1,40)
SetTextPosition(1,10,0)
myHigh$="High :"+str(high)
CreateText(2,myHigh$)
SetTextSize(2,40)
SetTextDepth(2,0)
SetTextPosition(2,600,0)
myScore$="Score:"+str(score)
CreateText(3,myScore$)
SetTextSize(3,40)
SetTextDepth(3,0)
SetTextPosition(3,820,0)

frogSpr = CreateSprite(0)
SetSpriteSize(frogSpr,64,64)
changeFrogColor(frogSpr,1)

SetSpriteDepth(frogSpr,15)
do
	elapsedTime#=Timer()
	resetTimer()

	repeat
		SetSpriteDepth(900,10000)
		
		score=crossRoadLevel(frogSpr,score)
		if high<score then high = score
		myScore$="Score:"+str(score):myHigh$="High :"+str(high)
		SetTextString(2,myHigh$):SetTextString(3,myScore$)

		sync()
		//resetTimer()
		score=crossRiverLevel(frogSpr,score)
		if high<score then high = score
		myScore$="Score:"+str(score):myHigh$="High :"+str(high)
		SetTextString(2,myHigh$):SetTextString(3,myScore$)
		//SetSpriteDepth(901,9998):SetSpriteDepth(902,9999)
	
		SetSpriteAngle(frogSpr,0)
		sync()
		elapsedTime#=Timer()
	until elapsedTime#>timePerGame //limited time per attempt
	sync()
	setSpritecolor(900,0,0,0,255)
	gameOver()
	score=0:changeFrogColor(frogSpr,1)
	myScore$="Score:"+str(score)
	SetTextString(3,myScore$)
loop
endfunction 

function crossRoadLevel(frogSpr as integer,score as integer)
setSpritecolor(900,150,150,150,255)
for num = 1 to 5
	DeleteSprite(num):deleteSprite(num+5):deleteSprite(num+10)
	DeleteSprite(num+15):DeleteSprite(num+20)
	rem top road moving right cars and trucks
	createSprite(num,0)
	SetSpriteSize(num,60,128)
	SetSpriteColor(num,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num,90)
	createSprite(num+5,0)
	SetSpriteSize(num+5,60,148)
	SetSpriteColor(num+5,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+5,90)
	rem bottom road moving left cars and trucks
	createSprite(num+10,0)
	SetSpriteSize(num+10,60,128)
	SetSpriteColor(num+10,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+10,270)
	createSprite(num+15,0)
	SetSpriteSize(num+15,60,148)
	SetSpriteColor(num+15,Random(1,255),Random(1,255),Random(1,255),255)
	SetSpriteAngle(num+15,270)
	placeVehicles(num)
next num
changeColor=placeBonusFruit(500)
SetSpriteDepth(frogSpr,15)
time#=timer()
repeat 
until timer()-time#>1
FrogAnimNum=1
x#=xMax/2:y#=yMax-40
SetSpritePosition(frogSpr,x#,y#)
bonusTime=timePerGame-timer()
while GetSpriteYByOffset(frogSpr)-35>0 and bonusTime >0
	bonusTime$="Time Left :"+str(bonusTime)
	SetTextString(1,bonusTime$)

	x#=GetSpriteX(frogspr):y#=GetSpriteY(frogSpr)
	if GetRawKeyState (KEY_Up)
		y#=y#-5
	endif
	if GetRawKeyState (KEY_Down)
		y#=y#+5
	endif
	if GetRawKeyState (KEY_Left)
		x#=x#-5
	endif
	if GetRawKeyState (KEY_Right)
		x#=x#+5
	endif
   	SetSpritePosition(frogSpr,x#,y#)
	
	if moveVehicles(frogSpr)=1
		x#=xMax/2:y#=yMax-40
		SetSpritePosition(frogSpr,x#,y#)
	endif 
	
	If GetSpriteCollision(frogSpr,500)=1 and GetSpriteVisible(500)=1 
		changeFrogColor(frogSpr,changeColor)
		score=score+250
		myScore$="Score:"+str(score)
		SetTextString(3,myScore$)
		SetSpriteVisible(500,0)
	endif 
    bonusTime=timePerGame-timer()
	Sync()
endwhile
if bonusTime>0 then score=score+(10*bonusTime)
endfunction score   


function crossRiverLevel(frogSpr as integer,score as integer)
setSpritecolor(900,0,0,140,255)		
for num = 1 to 5
	DeleteSprite(num):deleteSprite(num+5):deleteSprite(num+10)
	DeleteSprite(num+15):DeleteSprite(num+20)
	rem top road moving 
	createSprite(num,0)
	SetSpriteColor(num,139,69,19,255)
	SetSpriteSize(num,128,64)
	SetSpriteDepth(num,20)
	
	createSprite(num+5,0)
	SetSpriteColor(num+5,139,69,19,255)
	SetSpriteSize(num+5,186,64)
	SetSpriteDepth(num+5,20)

	rem bottom river moving left Logs
	CreateSprite(num+10,0)
	SetSpriteColor(num+10,139,69,19,255)
	SetSpriteSize(num+10,186,64)
	SetSpriteDepth(num+10,20)
	
	CreateSprite(num+15,0)
	SetSpriteColor(num+15,139,69,19,255)
	SetSpriteSize(num+15,128,64)
	SetSpriteDepth(num+15,20)
	
	rem 5 crocodiles
	CreateSprite(num+20,0)
	SetSpriteColor(num+20,128,128,128,255)
	SetSpriteSize(num+20,128,64)
	SetSpriteDepth(num+20,20)
	placeLogs(num)
next num	
//change colour of frog if eats fruit
changeColor=placeBonusFruit(500)
SetSpriteDepth(frogSpr,15)

time#=timer()
repeat 
until timer()-time#>1
x#=xMax/2:y#=yMax-40
SetSpritePosition(frogSpr,x#,y#)	
bonusTime=timePerGame-timer()
while GetSpriteYByOffset(frogSpr)-35>0 and bonusTime >0
	bonusTime$="Time Left :"+str(bonusTime)
	SetTextString(1,bonusTime$)
	
	x#=GetSpriteX(frogspr):y#=GetSpriteY(frogSpr)
	if GetRawKeyState (KEY_Up)
		y#=y#-5
	endif
	if GetRawKeyState (KEY_Down)
		y#=y#+5
	endif
	if GetRawKeyState (KEY_Left)
		x#=x#-5
	endif
	if GetRawKeyState (KEY_Right)
		x#=x#+5
	endif
   	SetSpritePosition(frogSpr,x#,y#)
	if moveLogs(frogSpr)=0 and GetSpriteY(frogSpr)<yMax-80 
		if y#>40 
			x#=xMax/2:y#=yMax-40
			SetSpritePosition(frogSpr,x#,y#)
		endif	
	endif	
	if x#<-40 or x#>xMax 
		x#=xMax/2:y#=yMax-40
		SetSpritePosition(frogSpr,x#,y#)		
	endif
	
	If GetSpriteCollision(frogSpr,500)=1 and GetSpriteVisible(500)=1 
		changeFrogColor(frogSpr,changeColor)
		score=score+250
		myScore$="Score:"+str(score)
		SetTextString(3,myScore$)
		SetSpriteVisible(500,0)	
	endif 
	bonusTime=timePerGame-timer()
	sync()
endwhile  
if bonusTime>0 then score=score+(10*bonusTime)
endfunction score

function placeVehicles(num as integer)
//randomly place vehicles watching/repeating for collisions
rem y=105:y=210:y=395:y=495
SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
SetSpritePositionByOffset(num+10,random2(xMax,xMax*2),395)
SetSpritePositionByOffset(num+15,random2(xMax,xMax*2),495)

for check= 1 to num
	while GetSpriteCollision(num,check)=1 and num <> check
		SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
		check=1
	endwhile
	while GetSpriteCollision(num+5,check+5)=1 and num <> check
		SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
		check=1
	endwhile
	while GetSpriteCollision(num+10,check+10)=1 and num <> check
		SetSpritePositionByOffset(num+10,random2(0,xMax*2),395)
		check=1
	endwhile
	while GetSpriteCollision(num+15,check+15)=1 and num <> check
		SetSpritePositionByOffset(num+15,random2(0,xMax*2),495)
		check=1
	endwhile
next check	
endfunction

function moveVehicles(frogSpr as integer)
collision=0
for num = 1 to 5
	SetSpritePositionByOffset(num,(GetSpriteXByOffset(num)+4),GetSpriteYByOffset(num))
	if GetSpriteXByOffset(num)>xMax*2 then SetSpritePositionByOffset(num,-xMax,GetSpriteYByOffset(num))
	if GetSpriteCollision( frogSpr, num ) then collision=1 
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+5,(GetSpriteXByOffset(num+5)+4),GetSpriteYByOffset(num+5))
	if GetSpriteXByOffset(num+5)>xMax*2 then SetSpritePositionByOffset(num+5,-xMax,GetSpriteYByOffset(num+5))
	if GetSpriteCollision( frogSpr, num+5 ) then collision=1
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+10,(GetSpriteXByOffset(num+10))-4,GetSpriteYByOffset(num+10))
	if GetSpriteXByOffset(num+10)<-xMax then SetSpritePositionByOffset(num+10,xMax*2,GetSpriteYByOffset(num+10))
	if GetSpriteCollision( frogSpr, num+10 ) then collision=1 
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+15,(GetSpriteXByOffset(num+15))-4,GetSpriteYByOffset(num+15))
	if GetSpriteXByOffset(num+15)<-xMax then SetSpritePositionByOffset(num+15,xMax*2,GetSpriteYByOffset(num+15))
	if GetSpriteCollision( frogSpr, num+15 ) then collision=1 
next num
endfunction collision

function moveLogs(frogSpr as integer)
collision=0	
for num = 1 to 5
	SetSpritePositionByOffset(num,(GetSpriteXByOffset(num)+4),GetSpriteYByOffset(num))
	if GetSpriteXByOffset(num)>xMax*2 then SetSpritePositionByOffset(num,-xMax,GetSpriteYByOffset(num))
	if GetSpriteCollision( frogSpr, num ) 
		SetSpritePosition(frogSpr,GetSpriteX(frogSpr)+4,GetSpriteY(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+5,(GetSpriteXByOffset(num+5)+4),GetSpriteYByOffset(num+5))
	if GetSpriteXByOffset(num+5)>xMax*2 then SetSpritePositionByOffset(num+5,-xMax,GetSpriteYByOffset(num+5))
	if GetSpriteCollision( frogSpr, num+5 ) 
		SetSpritePosition(frogSpr,GetSpriteX(frogSpr)+4,GetSpriteY(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+10,(GetSpriteXByOffset(num+10))-4,GetSpriteYByOffset(num+10))
	if GetSpriteXByOffset(num+10)<-xMax then SetSpritePositionByOffset(num+10,xMax*2,GetSpriteYByOffset(num+10))
	if GetSpriteCollision( frogSpr, num+10 ) 
		SetSpritePosition(frogSpr,GetSpriteX(frogSpr)-4,GetSpriteY(frogSpr)) 
		collision=1
	endif
next num
for num = 1 to 5
	SetSpritePositionByOffset(num+15,(GetSpriteXByOffset(num+15))-5,GetSpriteYByOffset(num+15))
	if GetSpriteXByOffset(num+15)<-xMax then SetSpritePositionByOffset(num+15,xMax*2,GetSpriteYByOffset(num+15))
	if GetSpriteCollision( frogSpr, num+15 ) 
		SetSpritePosition(frogSpr,GetSpriteX(frogSpr)-4,GetSpriteY(frogSpr)) 
		collision=1
	endif
next num
rem crocodiles
for num = 1 to 5
	SetSpritePositionByOffset(num+20,(GetSpriteXByOffset(num+20)+2),GetSpriteYByOffset(num+20))
	if GetSpriteXByOffset(num+20)>xMax*2 then SetSpritePositionByOffset(num+20,-xMax,GetSpriteYByOffset(num+20))
	if GetSpriteCollision( frogSpr, num+20 ) 
		SetSpritePosition(frogSpr,GetSpriteX(frogSpr)+2,GetSpriteY(frogSpr)) 
		collision=1
	endif
next num
endfunction collision 

function createEllipse()
    Render()
    DrawEllipse(10,10,10,10,MakeColor(255,255,255),MakeColor(255,255,255),1)
    Swap()
    img = getimage(0,0,22,22)
    sync()
endfunction img

function placeBonusFruit(spr as integer)
If getSpriteExists(spr) then DeleteSprite(spr)	
CreateSprite(spr,createEllipse())
SetSpritePositionByOffset(spr,random(10,xMax-10),yMax/2)
SetSpriteDepth (spr,20)
ran=random (1,5)
select ran:
	case 1:
		SetSpriteColor(spr,113,161,25,255):rem green
	endcase
	case 2:
		SetSpriteColor(spr,92,92,255,255):rem blue
	endcase
	case 3:
		SetSpriteColor(spr,190,152,0,255):rem gold
	endcase
	case 4:
		SetSpriteColor(spr,168,35,168,255):rem Purple
	endcase
	case 5:
		SetSpriteColor(spr,246,125,0,255):rem Orange
	endcase
endselect
color=ran	
endfunction color	

function changeFrogColor(spr as integer,num)
select num:
	case 1:
		SetSpriteColor(spr,113,161,25,255):rem green
	endcase
	case 2:
		SetSpriteColor(spr,92,92,255,255):rem blue
	endcase
	case 3:
		SetSpriteColor(spr,190,152,0,255):rem gold
	endcase
	case 4:
		SetSpriteColor(spr,168,35,168,255):rem Purple
	endcase
	case 5:
		SetSpriteColor(spr,246,125,0,255):rem Orange
	endcase
endselect	
endfunction

function placeLogs(num as integer)
//randomly place logs crocs etc repeating for collisions
SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
SetSpritePositionByOffset(num+10,random2(xMax,xMax*2),395)
SetSpritePositionByOffset(num+15,random2(xMax,xMax*2),495)
SetSpritePositionByOffset(num+20,random2(-xMax,xMax),302)
for check= 1 to num
	while GetSpriteCollision(num,check)=1 and num <> check
		SetSpritePositionByOffset(num,random2(-xMax,xMax),105)
		check=1
	endwhile
	while GetSpriteCollision(num+5,check+5)=1 and num <> check
		SetSpritePositionByOffset(num+5,random2(-xMax,xMax),210)
		check=1
	endwhile
	while GetSpriteCollision(num+10,check+10)=1 and num <> check
		SetSpritePositionByOffset(num+10,random2(0,xMax*2),395)
		check=1
	endwhile
	while GetSpriteCollision(num+15,check+15)=1 and num <> check
		SetSpritePositionByOffset(num+15,random2(0,xMax*2),495)
		check=1
	endwhile
	while GetSpriteCollision(num+20,check+20)=1 and num <> check
		SetSpritePositionByOffset(num+20,random2(-xMax,xMax),302)
		check=1
	endwhile
next check	
endfunction

function gameOver()
	SetTextVisible(1,0)
	time#=timer()
	repeat 
	until timer()-time#>1
	ClearScreen()
    repeat
		Print("Game Over click mouse to continue") 
		sync()
    until GetPointerPressed() = 1
    SetTextVisible(1,1)	
endfunction