Sorry your browser is not supported!

// Project: spritebreak 
// Created: 2018-12-07

// show all errors
SetErrorMode(2)

#constant screenwidth = 1024
#constant screenheight = 768

// set window properties
SetWindowTitle( "spritebreak" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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


type _platform
	spr
	x#
	y#
endtype
platform as _platform[screenwidth,screenheight]


for x=0 to screenwidth
	for y=screenheight/2-30 to screenheight/2+30
		platform[x,y].spr = CreateSprite(0)
		platform[x,y].x# = x 
		platform[x,y].y# = y
	next
	
next

	

do

	for x=0 to screenwidth
		for y=screenheight/2-30 to screenheight/2+30
			SetSpritePosition(platform[x,y].spr,platform[x,y].x#,platform[x,y].y#)
		next
	next
	

	if GetRawKeyPressed(32) 
		r=random(0,screenwidth)
		w=40
		for y=screenheight/2-30 to screenheight/2
			if r-w>0 and r+w<screenwidth
				for x=r-w to r+w
					SetSpriteVisible(platform[x,y].spr,0)
				//screen
				next
			endif
			dec w,2
		next
	endif
		
    Print("Press Space")

    Print( ScreenFPS() )
    Sync()
loop

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)


// set window properties
SetWindowTitle( "imagebreak" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

type _blocks
	x
	y
	value
	color
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x
	y
endtype
global player as _player[]
pl as _player
global homex, homey


createmaps(100,100)

playeroutcount=0
playerincount=0
currentplayerindex=0
levelcounter=5 // how many lemmings on this level

framestep#=timer()
do
	
	for playerindex = 0 to player.length	
		if released=1
			if GetSpriteExists(player[playerindex].spr)=1
				SetSpritePosition(player[playerindex].spr,player[playerindex].x, player[playerindex].y)
		
		
	
				if blocks[player[playerindex].x/10, (player[playerindex].y+30)/10].value=0
					inc player[playerindex].y,10
			
				else
					inc player[playerindex].x,2
				endif

				if blocks[player[playerindex].x/10, (player[playerindex].y+30)/10].value=2 // home
					inc playerincount
					dec playeroutcount
					DeleteSprite(player[playerindex].spr)
				endif

			endif
		endif
	next
	
	if playerincount>=levelcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc levelcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>.5)
		if released=1
			if currentplayerindex<levelcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,10,30)
				player.insert(pl)
				player[currentplayerindex].x=homex * 10
				player[currentplayerindex].y=homey * 10
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
	displaymap(100,100)
	
	print("OUT" + str(playeroutcount) + " - IN " + str(playerincount))
	
	
	Render2DFront()
    Print( ScreenFPS() )
    Sync()
loop

function displaymap(sizex, sizey)
	pixelsize=10
	
	for x=0 to sizex
		for y=0 to sizey
			c=blocks[x,y].color
			if blocks[x,y].value<>0
				DrawBox(blocks[x,y].x * pixelsize,blocks[x,y].y * pixelsize, (blocks[x,y].x*pixelsize) + pixelsize, (blocks[x,y].y*pixelsize) + pixelsize,c,c,c,c,1)
			endif
		next
	next
	
endfunction

function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				blocks[x,y].color=MakeColor(random(0,255),random(0,255),random(0,255))
				blocks[x,y].x = x
				blocks[x,y].y = y
				
	//		endif
		next
	next

// Create a home
	r=random(sizex/2,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
				blocks[x,y].color=MakeColor(0,random(150,250),0)
				blocks[x,y].x = x
				blocks[x,y].y = y
			
		next
	next

// create a exit
	r=random(0,sizex/2-10)
	for x=r to r+10
		for y=sizey/2/2 to sizey/2/2+2
				blocks[x,y].value=3
				blocks[x,y].color=MakeColor(0,random(150,250),random(150,250))
				blocks[x,y].x = x
				blocks[x,y].y = y
				homex=x
				homey=y
		next
	next
	
endfunction

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768

// set window properties
SetWindowTitle( "Lemmings" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global playeroutcount, playerincount
global mouse, mousecross, mousegrabbed
global homex, homey

// info area
global infotitle, playerintext, playerouttext, timetext, infotitle1

playersizey=30
playeroutcount=0
playerincount=0
currentplayerindex=0
levelcounter=50 // how many lemmings on this level


type _blocks
	x
	y

//values - 1=Floor, 2-Home to next level, 3 - Entry, 4-obsticle, 5-climbingfloor

	value
	color
	
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x#
	y#
	speed
	direction // 0-left 1-right - 2-down
	down // 0-yes 1-no
	action$ // walking/digging/exploding/
endtype
global player as _player[]
pl as _player

buildmouse()

buildinfoarea()

createmaps(100,100)

released=1

framestep#=timer()
do
	
	
	for playerindex = 0 to player.length	
		
		if released=1
			
			
			
			
			if GetSpriteCollision(mousecross,player[playerindex].spr) =1 
				SetSpritePosition(mousegrabbed,getpointerx()-25,getpointery()-25)
				SetSpritePosition(mousecross,1000,1000)
				SetTextString(infotitle,player[playerindex].action$ + " " + str(playerindex+1))

				if GetRawMouseLeftPressed()
					player[playerindex].action$="Digger"
					
				endif

				if GetRawMouseRightPressed()
					player[playerindex].action$="Builder"
					
				endif
				
			else
					SetSpritePosition(mousecross,getpointerx()-25,getpointery()-25)
					SetSpritePosition(mousegrabbed,1000,1000)

			endif

			if player[playerindex].action$="Digger"
				SetSpritePosition(player[playerindex].spr,player[playerindex].x#, player[playerindex].y#)
			
				
				player[playerindex].down=1
				player[playerindex].speed=0
				inc player[playerindex].y#,.2
				
				

				blocks[(floor(player[playerindex].x#)/10)-1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)+1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)	, (floor((player[playerindex].y#+playersizey)/10))+1].value=0
			endif


			if player[playerindex].action$="Builder"
			
			
				dec player[playerindex].y#,.05
				if player[playerindex].direction=0 
					dec player[playerindex].x#,.1
				else
					inc player[playerindex].x#,.1
				
				endif
						
				
				
				
				for ax=-1 to 1
					for ay=-1 to 1
						blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].value=5
						blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].color=MakeColor(0,random(150,250),0)
						blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].x=(player[playerindex].x#+ax)/10
						blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].y=(player[playerindex].y#+playersizey-ay)/10
					next
				next
				
			endif


	
			if player[playerindex].action$="Walker"
				

			endif
			if GetSpriteExists(player[playerindex].spr)=1
					SetSpritePosition(player[playerindex].spr,player[playerindex].x#, player[playerindex].y#)
						
						
					if floor(player[playerindex].x#)/10>0 and floor(player[playerindex].y#+playersizey)/10>0 
						
						if blocks[floor(player[playerindex].x#)/10, floor(player[playerindex].y#+playersizey)/10].value=0 // starting 
							player[playerindex].down=0
							player[playerindex].speed=5
							player[playerindex].direction=0
							player[playerindex].action$="Walker"
						else
							player[playerindex].down=1
							player[playerindex].speed=1
							player[playerindex].direction=-1
						
//						if blocks[floor(player[playerindex].x#)/10, floor(player[playerindex].y#+(playersizey))/10].value=5 // climbing floor
							if blocks[(floor(player[playerindex].x#)/10)	, (floor((player[playerindex].y#+playersizey-1)/10))].value=5

								dec player[playerindex].y#,1
							endif
						
							if blocks[floor(player[playerindex].x#+5)/10, floor((player[playerindex].y#+playersizey-1))/10].value=4 or blocks[floor(player[playerindex].x#)/10, floor((player[playerindex].y#))/10].value=1 // hit a wall or floor sides
							
								if player[playerindex].action$="Builder" then player[playerindex].action$="Walker"
								player[playerindex].direction = -player[playerindex].direction
							endif

							if blocks[floor(player[playerindex].x#)/10, floor((player[playerindex].y#)+playersizey)/10].value=2 // home
								inc playerincount
								dec playeroutcount
								player[playerindex].x#=1000
								player[playerindex].y#=1000
					
							endif
						endif
						
					endif

				endif

			endif
			if player[playerindex].direction=1 then dec player[playerindex].x#,player[playerindex].speed
			if player[playerindex].direction=-1 then inc player[playerindex].x#,player[playerindex].speed
			if player[playerindex].down=0 then	inc player[playerindex].y#,player[playerindex].speed
	next
	
	if playerincount>=levelcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc levelcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>.5)
		if released=1
			if currentplayerindex<levelcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,10,playersizey)
				player.insert(pl)
				player[currentplayerindex].x#=homex * 10
				player[currentplayerindex].y#=homey * 10
				player[currentplayerindex].direction =1
				player[currentplayerindex].speed =2
				player[currentplayerindex].action$ ="Walker"
			
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
	displaymap(100,100)
	
	SetTextString(playerouttext,"OUT " + str(playeroutcount))
	SetTextString(playerintext,"IN " + str(playerincount))
	
	
	Render2DFront()
    Print( ScreenFPS() )
    Sync()
loop

function buildinfoarea()
	playerintext = CreateText("IN")
	playerouttext = CreateText("OUT")
	infotitle = createtext("DIGGER")
	infotitle1 = createtext("Press Left Button for Digging, Right Button for Building")
	timetext = CreateText("TIME")
	
	SetTextSize(playerintext,50)
	SetTextSize(playerouttext,50)
	SetTextSize(infotitle,50)
	SetTextSize(timetext,50)
	SetTextSize(infotitle1,20)
	
	
	
endfunction

function buildmouse()
	mousegrabbed = createsprite(createmousegrabbed(30,30))
mousecross = createsprite(createmousecross(30,30))
mouse=mousecross

endfunction
function createmousegrabbed(sizex,sizey)

	swap()
		DrawBox(0,0,sizex-1,sizey-1,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	render()
	img = GetImage(0,0,sizex,sizey)
	
	

endfunction img

function createmousecross(sizex,sizey)

	swap()
		DrawBox(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),1)
		DrawLine(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,0,0),MakeColor(255,255,0))
		DrawLine(0		,100+sizey/2,sizex	,100+sizey/2,MakeColor(255,0,0),MakeColor(255,255,0))
	render()
	img = GetImage(0,100,sizex,100+sizey)
	
	

endfunction img



function displaymap(sizex, sizey)
	pixelsize=10
	
	for x=0 to sizex
		for y=0 to sizey
			c=blocks[x,y].color
			if blocks[x,y].value<>0
				DrawBox(blocks[x,y].x * pixelsize,blocks[x,y].y * pixelsize, (blocks[x,y].x*pixelsize) + pixelsize, (blocks[x,y].y*pixelsize) + pixelsize,c,c,c,c,1)
			endif
		next
	next
	
	
	SetTextPosition(infotitle,50,screenheight-100)
	SetTextPosition(playerouttext,350,screenheight-100)
	SetTextPosition(playerintext,500,screenheight-100)
	SetTextPosition(timetext,700,screenheight-100)
	
	SetTextPosition(infotitle1,screenwidth/2-GetTextTotalWidth(infotitle1)/2,screenheight-20)
	
endfunction

function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey-35
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				if y=sizey/2 or y=sizey/2+1
					 blocks[x,y].color=MakeColor(0,random(100,155),0)
				else
					 blocks[x,y].color=MakeColor(random(140,150),random(100,110),random(35,45))
				endif
				blocks[x,y].x = x
				blocks[x,y].y = y
				
	//		endif
		next
	next

	
// Create a home
	r=random(sizex-10,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
				blocks[x,y].color=MakeColor(0,random(150,250),0)
				blocks[x,y].x = x
				blocks[x,y].y = y
			
		next
	next


// create a obsticle
	r=random(sizex-20,sizex-10)
	for x=r to r+2
		for y=sizey/2-10 to sizey/2
				blocks[x,y].value=4 // obsticle
				blocks[x,y].color=MakeColor(0,random(150,250),random(150,250))
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next



// create a entry
	r=random(0,sizex/2-10)
	for x=r to r+10
		for y=10 to 12
				blocks[x,y].value=3 // entry
				blocks[x,y].color=MakeColor(0,random(150,250),random(150,250))
				blocks[x,y].x = x
				blocks[x,y].y = y
				homex=x-5
				homey=y
		next
	next



// border	
	for x=0 to 1
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
				blocks[x,y].color=MakeColor(random(150,250),random(150,250),random(150,250))
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
	for x=sizex-1 to sizex
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
				blocks[x,y].color=MakeColor(random(150,250),random(150,250),random(150,250))
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
endfunction

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768

// set window properties
SetWindowTitle( "Lemmings" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global playeroutcount, playerincount
global mouse, mousecross, mousegrabbed
global homex, homey
global pixelsize=5

// info area
global infotitle, playerintext, playerouttext, timetext, infotitle1

playersizex=5
playersizey=playersizex+5

playeroutcount=0
playerincount=0
currentplayerindex=0
lemmingcounter=3 // how many lemmings on this level


type _blocks
	x
	y

//values - 1=Floor, 2-Home to next level, 3 - Entry, 4-obsticle, 5-climbingfloor

	value
	red
	green
	blue
	
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x#
	y#
	speed#
	direction // 0-left 1-right - 2-down
	down // 0-yes 1-no
	action$ // walking/digging/exploding/
endtype
global player as _player[]
pl as _player

buildmouse()

buildinfoarea()

createmaps(200,200)

released=1

framestep#=timer()
do
	
	
	for playerindex = 0 to player.length	
		
		if released=1
			SetSpritePosition(player[playerindex].spr,player[playerindex].x#, player[playerindex].y#)
			
			
			
			// check colliion with the mouse
			if GetSpriteCollision(mousecross,player[playerindex].spr) =1 
				SetSpritePosition(mousegrabbed,getpointerx()-25,getpointery()-25)
				SetSpritePosition(mousecross,1000,1000)
				SetTextString(infotitle,player[playerindex].action$ + " " + str(playerindex+1))

				if GetRawMouseLeftPressed()
					player[playerindex].action$="Digger"
					
				endif

				if GetRawMouseRightPressed()
					player[playerindex].action$="Builder"
					
				endif
				
			else
					SetSpritePosition(mousecross,getpointerx()-25,getpointery()-25)
					SetSpritePosition(mousegrabbed,1000,1000)

			endif


// check actions

			if player[playerindex].action$="Digger"
				inc player[playerindex].y#,.2
				blocks[(floor(player[playerindex].x#)/10)-1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)+1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)	, (floor((player[playerindex].y#+playersizey)/10))+1].value=0
			else


				if player[playerindex].action$="Builder"
					dec player[playerindex].y#,.5

					if player[playerindex].direction=1
						inc player[playerindex].x#,1
					else
						dec player[playerindex].x#,1
					endif
					
					ax=0
					ay=1
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].value=5
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].red=0
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].green=random(150,250)
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].blue=0
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].x=((player[playerindex].x#)/10)+ax
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].y=((player[playerindex].y#+playersizey-ay)/10)+ay
				else
					if player[playerindex].action$="Climbing"
						dec player[playerindex].y#,1

						if player[playerindex].direction=1
							inc player[playerindex].x#,1
						else
							dec player[playerindex].x#,1
						endif
					
					else
						
						if player[playerindex].action$="Falling"
						
							inc player[playerindex].y#,1
					
						else
							if player[playerindex].action$="Walker"
							
								if player[playerindex].direction=1
									inc player[playerindex].x#,1
								else
									dec player[playerindex].x#,1
								endif
							

							endif
								

			
							endif
						endif
					endif
				endif	
		endif

// collision tests
		bx = floor(player[playerindex].x#)/pixelsize
		by = floor(player[playerindex].y#)/pixelsize
		py = playersizey / pixelsize
		
		
		if blocks[ bx, by+py ].value=0 // in an empty area so drop one
			inc player[playerindex].y#
		endif
			if blocks[ bx, by+py+1 ].value=1 // hit floor
				if player[playerindex].action$<>"Builder" then player[playerindex].action$="Walker"
			endif

				for a=bx-1 to bx+1

					if blocks[ a, by].value=4 // hit obstical
						player[playerindex].action$="Walker"
						player[playerindex].direction = -player[playerindex].direction
					endif

					if blocks[ a, by].value=5 // hit building blocks
						if player[playerindex].action$<>"Builder" 
							player[playerindex].action$="Climbing"
							
						endif
					endif
		
				next
			
		

	

	next
	
	print(GetRawLastKey())
	
	if GetRawKeyPressed(76) // level up
		// fade screen
		repeat
			for x=0 to 200
				for y=0 to 200
					dec blocks[x,y].red,10
					dec blocks[x,y].green,10
					dec blocks[x,y].blue,10
					
					if blocks[x,y].red<0 then blocks[x,y].red=0
					if blocks[x,y].green<0 then blocks[x,y].green=0
					if blocks[x,y].blue<0 then blocks[x,y].blue=0
					

				next
			next	
			
			displaymap(200,200)
			sync()
			
		until blocks[x,y].red<>0 and blocks[x,y].green<>0 and blocks[x,y].blue<>0
	
	endif
	if playerincount>=lemmingcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc lemmingcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>2)
		if released=1
			if currentplayerindex<lemmingcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,playersizex,playersizey)
				player.insert(pl)
				player[currentplayerindex].x#=homex * 10
				player[currentplayerindex].y#=homey * 10
				player[currentplayerindex].direction =1
				player[currentplayerindex].speed# =2
				player[currentplayerindex].action$ ="Falling"
			
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
	displaymap(200,200)
	
	SetTextString(playerouttext,"OUT " + str(playeroutcount))
	SetTextString(playerintext,"IN " + str(playerincount))
	
	
	Render2DFront()
    Print( ScreenFPS() )
    Sync()
loop

function buildinfoarea()
	playerintext = CreateText("IN")
	playerouttext = CreateText("OUT")
	infotitle = createtext("DIGGER")
	infotitle1 = createtext("Press Left Button for Digging, Right Button for Building")
	timetext = CreateText("TIME")
	
	SetTextSize(playerintext,50)
	SetTextSize(playerouttext,50)
	SetTextSize(infotitle,50)
	SetTextSize(timetext,50)
	SetTextSize(infotitle1,20)
	
	
	
endfunction

function buildmouse()
	mousegrabbed = createsprite(createmousegrabbed(30,30))
mousecross = createsprite(createmousecross(30,30))
mouse=mousecross

endfunction
function createmousegrabbed(sizex,sizey)

	swap()
		DrawBox(0,0,sizex-1,sizey-1,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	render()
	img = GetImage(0,0,sizex,sizey)
	
	

endfunction img

function createmousecross(sizex,sizey)

	swap()
		DrawBox(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),1)
		DrawLine(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,0,0),MakeColor(255,255,0))
		DrawLine(0		,100+sizey/2,sizex	,100+sizey/2,MakeColor(255,0,0),MakeColor(255,255,0))
	render()
	img = GetImage(0,100,sizex,100+sizey)
	
	

endfunction img



function displaymap(sizex, sizey)
	
	for x=0 to sizex
		for y=0 to sizey
			c=MakeColor(blocks[x,y].red,blocks[x,y].green,blocks[x,y].blue)
			if blocks[x,y].value<>0
				DrawBox(blocks[x,y].x * pixelsize,blocks[x,y].y * pixelsize, (blocks[x,y].x*pixelsize) + pixelsize, (blocks[x,y].y*pixelsize) + pixelsize,c,c,c,c,1)
			endif
		next
	next
	
	
	SetTextPosition(infotitle,50,screenheight-100)
	SetTextPosition(playerouttext,350,screenheight-100)
	SetTextPosition(playerintext,500,screenheight-100)
	SetTextPosition(timetext,700,screenheight-100)
	
	SetTextPosition(infotitle1,screenwidth/2-GetTextTotalWidth(infotitle1)/2,screenheight-20)
	
endfunction

function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey-35
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				if y=sizey/2 or y=sizey/2+1
					blocks[x,y].red = 0
					blocks[x,y].green = random(100,155)
					blocks[x,y].blue = 0
				else
					blocks[x,y].red = random(140,150)
					blocks[x,y].green = random(100,110)
					blocks[x,y].blue = random(35,45)

				endif
				blocks[x,y].x = x
				blocks[x,y].y = y
				
	//		endif
		next
	next

	
// Create a home
	r=random(sizex-10,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = 0
				blocks[x,y].x = x
				blocks[x,y].y = y
			
		next
	next


// create a obsticle
	r=random(sizex/2,sizex/2+20)
	for x=r to r+2
		for y=sizey/2-10 to sizey/2
				blocks[x,y].value=4 // obsticle

					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next



// create a entry
	r=random(0,sizex/2)
	for x=r to r+10
		for y=30 to 32
				blocks[x,y].value=3 // entry
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

				blocks[x,y].x = x
				blocks[x,y].y = y
				homex=x-5
				homey=y
		next
	next



// border	
	for x=0 to 1
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
	for x=sizex-1 to sizex
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
endfunction

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768

// set window properties
SetWindowTitle( "Lemmings" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global playeroutcount, playerincount
global mouse, mousecross, mousegrabbed
global homex, homey

global worldsizex=1024
global worldsizey=100
global pixelsize=10

// info area
global infotitle, playerintext, playerouttext, timetext, infotitle1

playersizex=5
playersizey=playersizex+5

playeroutcount=0
playerincount=0
currentplayerindex=0
lemmingcounter=3 // how many lemmings on this level


type _blocks
	x
	y

//values - 1=Floor, 2-Home to next level, 3 - Entry, 4-obsticle, 5-climbingfloor

	value
	red
	green
	blue
	
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x#
	y#
	speed#
	direction // 0-left 1-right - 2-down
	down // 0-yes 1-no
	action$ // walking/digging/exploding/
endtype
global player as _player[]
pl as _player

buildmouse()

buildinfoarea()

createmaps(worldsizex,worldsizey)

released=1

framestep#=timer()
SetRawMousePosition(screenwidth/2,screenwidth/2)
SetRawMouseVisible(0)
do

	
	
	for playerindex = 0 to player.length	
		
		if released=1


			SetSpritePosition(player[playerindex].spr,player[playerindex].x#, player[playerindex].y#)


			
			
			
			// check colliion with the mouse
			if GetSpriteCollision(mousecross,player[playerindex].spr) =1 
				SetSpritePosition(mousegrabbed,getpointerx()-25,getpointery()-25)
				SetSpritePosition(mousecross,1000,1000)
				SetTextString(infotitle,player[playerindex].action$ + " " + str(playerindex+1))

				if GetRawMouseLeftPressed()
					player[playerindex].action$="Digger"
					
				endif

				if GetRawMouseRightPressed()
					player[playerindex].action$="Builder"
					
				endif
				
			else
					SetSpritePosition(mousecross,getpointerx()-25,getpointery()-25)
					SetSpritePosition(mousegrabbed,1000,1000)

			endif


// check actions

			if player[playerindex].action$="Digger"
				inc player[playerindex].y#,.2
				blocks[(floor(player[playerindex].x#)/10)-1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)+1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)	, (floor((player[playerindex].y#+playersizey)/10))+1].value=0
			else


				if player[playerindex].action$="Builder"
					dec player[playerindex].y#,.5

					if player[playerindex].direction=1
						inc player[playerindex].x#,1
					else
						dec player[playerindex].x#,1
					endif
					
					ax=0
					ay=1
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].value=5
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].red=0
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].green=random(150,250)
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].blue=0
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].x=((player[playerindex].x#)/10)+ax
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].y=((player[playerindex].y#+playersizey-ay)/10)+ay
				else
					if player[playerindex].action$="Climbing"
						dec player[playerindex].y#,1

						if player[playerindex].direction=1
							inc player[playerindex].x#,1
						else
							dec player[playerindex].x#,1
						endif
					
					else
						
						if player[playerindex].action$="Falling"
						
							inc player[playerindex].y#,1
					
						else
							if player[playerindex].action$="Walker"
							
								if player[playerindex].direction=1
									inc player[playerindex].x#,1
								else
									dec player[playerindex].x#,1
								endif
							

							endif
								

			
							endif
						endif
					endif
				endif	
		endif

// collision tests
		bx = floor(player[playerindex].x#)/pixelsize
		by = floor(player[playerindex].y#)/pixelsize
		py = playersizey / pixelsize
		
		
		if blocks[ bx, by+py ].value=0 // in an empty area so drop one
			inc player[playerindex].y#
		endif
			if blocks[ bx, by+py+1 ].value=1 // hit floor
				if player[playerindex].action$<>"Builder" then player[playerindex].action$="Walker"
			endif

				for a=bx-1 to bx+1

					if blocks[ a, by].value=4 // hit obstical
						player[playerindex].action$="Walker"
						player[playerindex].direction = -player[playerindex].direction
					endif

					if blocks[ a, by].value=5 // hit building blocks
						if player[playerindex].action$<>"Builder" 
							player[playerindex].action$="Climbing"
							
						endif
					endif
		
				next
			
		

	

	next
	
	print(GetRawLastKey())
	
	if GetRawKeyPressed(76) // level up
		// fade screen
		escape=0
		repeat
			for x=0 to 200
				for y=0 to 200
					dec blocks[x,y].red,10
					dec blocks[x,y].green,10
					dec blocks[x,y].blue,10
					
					if blocks[x,y].red<0 then blocks[x,y].red=0
					if blocks[x,y].green<0 then blocks[x,y].green=0
					if blocks[x,y].blue<0 then blocks[x,y].blue=0
					
					if blocks[x,y].red = 0 and blocks[x,y].green = 0 and blocks[x,y].blue = 0 then escape=1 

				next
			next	
			
			print(escape)
			displaymap(200,200)
			sync()
			
		until escape<>1
		exit
		createmaps(200,200)
		
	
	endif
	if playerincount>=lemmingcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc lemmingcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>2)
		if released=1
			if currentplayerindex<lemmingcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,playersizex,playersizey)
				player.insert(pl)
				player[currentplayerindex].x#=homex * 10
				player[currentplayerindex].y#=homey * 10
				player[currentplayerindex].direction =1
				player[currentplayerindex].speed# =2
				player[currentplayerindex].action$ ="Falling"
			
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
	displaymap(worldsizex,worldsizey)
	
	SetTextString(playerouttext,"OUT " + str(playeroutcount))
	SetTextString(playerintext,"IN " + str(playerincount))
	
	
	Render2DFront()
    Print( ScreenFPS() )
    Sync()
loop

function buildinfoarea()
	playerintext = CreateText("IN")
	playerouttext = CreateText("OUT")
	infotitle = createtext("DIGGER")
	infotitle1 = createtext("Press Left Button for Digging, Right Button for Building")
	timetext = CreateText("TIME")
	
	SetTextSize(playerintext,50)
	SetTextSize(playerouttext,50)
	SetTextSize(infotitle,50)
	SetTextSize(timetext,50)
	SetTextSize(infotitle1,20)
	
	
	
endfunction

function buildmouse()
	mousegrabbed = createsprite(createmousegrabbed(30,30))
mousecross = createsprite(createmousecross(30,30))
mouse=mousecross

endfunction
function createmousegrabbed(sizex,sizey)

	swap()
		DrawBox(0,0,sizex-1,sizey-1,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	render()
	img = GetImage(0,0,sizex,sizey)
	
	

endfunction img

function createmousecross(sizex,sizey)

	swap()
		DrawBox(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),1)
		DrawLine(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,0,0),MakeColor(255,255,0))
		DrawLine(0		,100+sizey/2,sizex	,100+sizey/2,MakeColor(255,0,0),MakeColor(255,255,0))
	render()
	img = GetImage(0,100,sizex,100+sizey)
	
	

endfunction img



function displaymap(sizex, sizey)
	
	for x=0 to sizex
		for y=0 to sizey
			c=MakeColor(blocks[x,y].red,blocks[x,y].green,blocks[x,y].blue)
			if blocks[x,y].value<>0
				DrawBox(blocks[x,y].x * pixelsize,blocks[x,y].y * pixelsize, (blocks[x,y].x*pixelsize) + pixelsize, (blocks[x,y].y*pixelsize) + pixelsize,c,c,c,c,1)
			endif
		next
	next
	
	
	SetTextPosition(infotitle,50,screenheight-100)
	SetTextPosition(playerouttext,350,screenheight-100)
	SetTextPosition(playerintext,500,screenheight-100)
	SetTextPosition(timetext,700,screenheight-100)
	
	SetTextPosition(infotitle1,screenwidth/2-GetTextTotalWidth(infotitle1)/2,screenheight-20)
	
endfunction

function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey-35
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				if y=sizey/2 or y=sizey/2+1
					blocks[x,y].red = 0
					blocks[x,y].green = random(100,155)
					blocks[x,y].blue = 0
				else
					blocks[x,y].red = random(140,150)
					blocks[x,y].green = random(100,110)
					blocks[x,y].blue = random(35,45)

				endif
				blocks[x,y].x = x
				blocks[x,y].y = y
				
	//		endif
		next
	next

	
// Create a home
	r=random(sizex-10,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = 0
				blocks[x,y].x = x
				blocks[x,y].y = y
			
		next
	next


// create a obsticle
	r=random(sizex/2,sizex/2+20)
	for x=r to r+2
		for y=sizey/2-10 to sizey/2
				blocks[x,y].value=4 // obsticle

					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next



// create a entry
	r=random(0,30)
	for x=r to r+10
		for y=30 to 32
				blocks[x,y].value=3 // entry
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

				blocks[x,y].x = x
				blocks[x,y].y = y
				homex=x-5
				homey=y
		next
	next



// border	
	for x=0 to 1
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
	for x=sizex-1 to sizex
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
				blocks[x,y].x = x
				blocks[x,y].y = y
		next
	next
	
endfunction

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768

// set window properties
SetWindowTitle( "Lemmings" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 0, 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

global playeroutcount, playerincount
global mouse, mousecross, mousegrabbed
global homex, homey

global worldsizex=1024
global worldsizey=100
global pixelsize=10
playersizex=pixelsize
playersizey=playersizex+5

// info area
global infotitle, playerintext, playerouttext, timetext, infotitle1


playeroutcount=0
playerincount=0
currentplayerindex=0
lemmingcounter=3 // how many lemmings on this level


type _blocks
//values - 1=Floor, 2-Home to next level, 3 - Entry, 4-obsticle, 5-climbingfloor
	value
	red
	green
	blue
	
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x#
	y#
	speed#
	direction // 0-left 1-right - 2-down
	down // 0-yes 1-no
	action$ // walking/digging/exploding/
endtype
global player as _player[]
pl as _player

buildmouse()

buildinfoarea()

createmaps(worldsizex,worldsizey)

released=1

framestep#=timer()
SetRawMousePosition(screenwidth/2,screenwidth/2)
SetRawMouseVisible(0)
offset=500
do

	
	
	for playerindex = 0 to player.length	
		
		if released=1


			SetSpritePosition(player[playerindex].spr,player[playerindex].x#, player[playerindex].y#)


			
			
			
			// check colliion with the mouse
			if GetSpriteCollision(mousecross,player[playerindex].spr) =1 
				SetSpritePosition(mousegrabbed,getpointerx()-25,getpointery()-25)
				SetSpritePosition(mousecross,1000,1000)
				SetTextString(infotitle,player[playerindex].action$ + " " + str(playerindex+1))

				if GetRawMouseLeftPressed()
					player[playerindex].action$="Digger"
					
				endif

				if GetRawMouseRightPressed()
					player[playerindex].action$="Builder"
					
				endif
				
			else
					SetSpritePosition(mousecross,getpointerx()-25,getpointery()-25)
					SetSpritePosition(mousegrabbed,1000,1000)

			endif


// check actions

			if player[playerindex].action$="Digger"
				inc player[playerindex].y#,.2
				blocks[(floor(player[playerindex].x#)/10)-1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)+1	, (floor((player[playerindex].y#+playersizey)/10))].value=0
				blocks[(floor(player[playerindex].x#)/10)	, (floor((player[playerindex].y#+playersizey)/10))+1].value=0
			else


				if player[playerindex].action$="Builder"
					dec player[playerindex].y#,.5

					if player[playerindex].direction=1
						inc player[playerindex].x#,1
					else
						dec player[playerindex].x#,1
					endif
					
					ax=0
					ay=1
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].value=5
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].red=0
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].green=random(150,250)
					blocks[(floor(player[playerindex].x#+ax)/10)	, (floor((player[playerindex].y#+playersizey-ay)/10))].blue=0
				else
					if player[playerindex].action$="Climbing"
						dec player[playerindex].y#,1

						if player[playerindex].direction=1
							inc player[playerindex].x#,1
						else
							dec player[playerindex].x#,1
						endif
					
					else
						
						if player[playerindex].action$="Falling"
						
							inc player[playerindex].y#,1
					
						else
							if player[playerindex].action$="Walker"
							
								if player[playerindex].direction=1
									inc player[playerindex].x#,1
								else
									dec player[playerindex].x#,1
								endif
							

							endif
								

			
							endif
						endif
					endif
				endif	
		endif

// collision tests
		bx = floor(player[playerindex].x#)/pixelsize
		by = floor(player[playerindex].y#)/pixelsize
		py = playersizey / pixelsize
		
		
		if blocks[ bx, by+py ].value=0 // in an empty area so drop one
			inc player[playerindex].y#
		endif
			if blocks[ bx, by+py+1 ].value=1 // hit floor
				if player[playerindex].action$<>"Builder" then player[playerindex].action$="Walker"
			endif

				for a=bx-1 to bx+1

					if blocks[ a, by].value=4 // hit obstical
						player[playerindex].action$="Walker"
						player[playerindex].direction = -player[playerindex].direction
					endif

					if blocks[ a, by].value=5 // hit building blocks
						if player[playerindex].action$<>"Builder" 
							player[playerindex].action$="Climbing"
							
						endif
					endif
		
				next
			
		

	

	next
	
	print(GetRawLastKey())
	
	if GetRawKeyPressed(76) // level up
		// fade screen
		escape=0
		repeat
			for x=0 to 200
				for y=0 to 200
					dec blocks[x,y].red,10
					dec blocks[x,y].green,10
					dec blocks[x,y].blue,10
					
					if blocks[x,y].red<0 then blocks[x,y].red=0
					if blocks[x,y].green<0 then blocks[x,y].green=0
					if blocks[x,y].blue<0 then blocks[x,y].blue=0
					
					if blocks[x,y].red = 0 and blocks[x,y].green = 0 and blocks[x,y].blue = 0 then escape=1 

				next
			next	
			
			print(escape)
			displaymap(200,200,0)
			sync()
			
		until escape<>1
		exit
		createmaps(200,200)
		
	
	endif
	if playerincount>=lemmingcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc lemmingcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>2)
		if released=1
			if currentplayerindex<lemmingcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,playersizex,playersizey)
				SetSpriteColor(pl.spr, 0,0,255,255)
				player.insert(pl)
				player[currentplayerindex].x#=homex * 10
				player[currentplayerindex].y#=homey * 10
				player[currentplayerindex].direction =1
				player[currentplayerindex].speed# =2
				player[currentplayerindex].action$ ="Falling"
			
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
    // if the pointer goes towards the left or right of the screen, then scroll the map with the offset variable
    if getpointerx()>screenwidth-100 then dec offset,1
    if getpointerx()<100 then inc offset,1
    
	displaymap(100,100,offset)
	
	SetTextString(playerouttext,"OUT " + str(playeroutcount))
	SetTextString(playerintext,"IN " + str(playerincount))
	
	
	Render2DFront()
    Print( ScreenFPS() )
    Sync()
loop

function buildinfoarea()
	playerintext = CreateText("IN")
	playerouttext = CreateText("OUT")
	infotitle = createtext("DIGGER")
	infotitle1 = createtext("Press Left Button for Digging, Right Button for Building")
	timetext = CreateText("TIME")
	
	SetTextSize(playerintext,50)
	SetTextSize(playerouttext,50)
	SetTextSize(infotitle,50)
	SetTextSize(timetext,50)
	SetTextSize(infotitle1,20)
	
	
	
endfunction

function buildmouse()
	mousegrabbed = createsprite(createmousegrabbed(30,30))
mousecross = createsprite(createmousecross(30,30))
mouse=mousecross

endfunction
function createmousegrabbed(sizex,sizey)

	swap()
		DrawBox(0,0,sizex-1,sizey-1,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	render()
	img = GetImage(0,0,sizex,sizey)
	
	

endfunction img

function createmousecross(sizex,sizey)

	swap()
		DrawBox(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),1)
		DrawLine(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,0,0),MakeColor(255,255,0))
		DrawLine(0		,100+sizey/2,sizex	,100+sizey/2,MakeColor(255,0,0),MakeColor(255,255,0))
	render()
	img = GetImage(0,100,sizex,100+sizey)
	
	

endfunction img



function displaymap(sizex, sizey, offset)
	
//	if sizex*pixelsize>screenwidth then sizex=screenwidth/pixelsize
	print(sizex)
	for x=0 to sizex
		for y=0 to sizey
			o=offset

			if x+o=>0 and x+o<1024
//print(x+o)
				if blocks[x+o,y].value<>0
					c=MakeColor(blocks[x+o,y].red,blocks[x+o,y].green,blocks[x+o,y].blue)
//					print (c)
					DrawBox(x * pixelsize,y * pixelsize,(x*pixelsize) + pixelsize, (y*pixelsize) + pixelsize,c,c,c,c,1)
				endif
			endif
		next
//		sync()
	next
	
	
	SetTextPosition(infotitle,50,screenheight-100)
	SetTextPosition(playerouttext,350,screenheight-100)
	SetTextPosition(playerintext,500,screenheight-100)
	SetTextPosition(timetext,700,screenheight-100)
	
	SetTextPosition(infotitle1,screenwidth/2-GetTextTotalWidth(infotitle1)/2,screenheight-20)
	
endfunction

function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey-35
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				if y=sizey/2 or y=sizey/2+1
					blocks[x,y].red = 0
					blocks[x,y].green = random(100,155)
					blocks[x,y].blue = 0
				else
					blocks[x,y].red = random(140,150)
					blocks[x,y].green = random(100,110)
					blocks[x,y].blue = random(35,45)

				endif
				
	//		endif
		next
	next

	
// Create a home
	r=random(sizex-10,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = 0
			
		next
	next


// create a load of randomised obsticle
	for a=0 to 400
		rminx=random(random(0,40),random(1,40))
		rmaxx=random(rminx,random(0,40))
		rminy=random(random(0,40),random(1,40))
		rmaxy=random(rminy,sizey/2)
		
		rxstart=random(0,sizex-100)
		rystart=random(0,sizey/2-40)
		
		rc= random(0,4)
		
		for x=rxstart+rminx to rxstart+rmaxx
			
			
			
			for y=rystart+rminy to rystart+rmaxy
				blocks[x,y].value=4 // obsticle

				if rc=0 // tint of white
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = random(200,250)
				endif

				if rc=1 // tint of blue
					blocks[x,y].red = 0
					blocks[x,y].green = 0
					blocks[x,y].blue = random(200,250)
				endif

				if rc=2 // tint of green
					blocks[x,y].red = 0
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = 0
				endif

				if rc=3 // tint of yellow
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = 0
				endif

				if rc=4 // tint of red
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = 0
					blocks[x,y].blue = 0
				endif

			next
		next
	next



// create a entry
	r=sizex/2 // place it in the middle of the world
	for x=r to r+10
		for y=30 to 32
				blocks[x,y].value=3 // entry
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

		next
	next
	homex=r/pixelsize
	homey=33


// border	
	for x=0 to 1
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
		next
	next
	
	for x=sizex-1 to sizex
		for y=0 to sizey/2
				blocks[x,y].value=4 // obsticle
					blocks[x,y].red = random(150,250)
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)
		next
	next
	
endfunction

// Project: imagebreak 
// Created: 2018-12-08

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768

// set window properties
SetWindowTitle( "Lemmings" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 0, 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

global playeroutcount, playerincount
global mouse, mousecross, mousegrabbed
global homex, homey

global worldsizex=screenwidth
global worldsizey=100
global viewportsizex=200
global viewportsizey=100
//global smallerpixelsizemap=1
global pixelsize=10
playersizex=pixelsize
playersizey=playersizex+10

// info area
global infotitle, playerintext, playerouttext, timetext, infotitle1


playeroutcount=0
playerincount=0
currentplayerindex=0
lemmingcounter=2 // how many lemmings on this level


type _blocks
//values - 1=Floor, 2-Home to next level, 3 - Entry, 4-obsticle, 5-climbingfloor
	value
	red
	green
	blue
	
endtype
global blocks as _blocks[1024,768]

type _player
	spr
	x#
	y#
	speed#
	direction // 0-left 1-right - 2-down
	down // 0-yes 1-no
	action$ // walking/digging/exploding/
endtype
global player as _player[]
pl as _player

buildmouse()

buildinfoarea()

createmapsImage("test.png")

//createmaps(worldsizex,worldsizey)
mapsprite = createsprite(buildsmallermap())
// build map from a PNG file


released=1

framestep#=timer() // TIME counter
actionDIGGERstep#=timer() // frame timer for each lemming that does a job
actionBUILDERstep#=timer() // frame timer for each lemming that does a job


SetRawMousePosition(screenwidth/2,screenwidth/2)
SetRawMouseVisible(0)
offset=500
do
	// display the image gnerated spriite of the world
	displaymapsprite(mapsprite,Offset)
	
	
	for playerindex = 0 to player.length	
		
		if released=1


			SetSpritePosition(player[playerindex].spr,(offset/pixelsize)+ player[playerindex].x#, player[playerindex].y#)
			SetSpritePosition(mousecross,getpointerx(),getpointery())


			
			
			
			// check colliion with the mouse
			if GetSpriteCollision(mousecross,player[playerindex].spr) =1 
				SetTextString(infotitle,player[playerindex].action$ + " " + str(playerindex+1))

				if GetRawMouseLeftPressed()
					player[playerindex].action$="Digger"
					
				endif

				if GetRawMouseRightPressed()
					player[playerindex].action$="Builder"
					
				endif
				
	
			endif


// check actions

			if player[playerindex].action$="Digger"
				
				if (timer()-actionDIGGERstep#)>.2 // 2 milliseconds to dig 
					actionDIGGERstep#=timer()
					inc player[playerindex].y#,2
					// work out where the leemming is in the world
					bx = (floor(player[playerindex].x#)/10)
					by = (floor((player[playerindex].y#+playersizey)/10))
					o = offset + (playersizex/2)
				
					// remove the surrounding blocks of it
					blocks[ o+bx-1, by ].value=0
					blocks[ o+bx+1, by ].value=0
					blocks[ o+bx, by+1].value=0
					blocks[ o+bx, by].value=0
				endif
			endif

			if player[playerindex].action$="Builder"

				if (timer()-actionBUILDERstep#)>1 // 2 milliseconds to build 
					actionBUILDERstep#=timer()

					dec player[playerindex].y#,pixelsize/2

					if player[playerindex].direction=1
						inc player[playerindex].x#,pixelsize
					else
						dec player[playerindex].x#,pixelsize
					endif
					
					bx = (floor(player[playerindex].x#)/10)
					by = (floor((player[playerindex].y#+playersizey)/10))
					o = offset + (playersizex/2)
			
					ax=0
					ay=1	
						//create 2 blocks for a platform in front of the lemm
					blocks[o+bx+1, by].value=5
					blocks[o+bx+1, by].red=0
					blocks[o+bx+1, by].green=random(150,250)
					blocks[o+bx+1, by].blue=0
					blocks[o+bx+2, by].value=5
					blocks[o+bx+2, by].red=0
					blocks[o+bx+2, by].green=random(150,250)
					blocks[o+bx+2, by].blue=0

				endif
			endif
			if player[playerindex].action$="Climbing"
				dec player[playerindex].y#,1

				if player[playerindex].direction=1
					inc player[playerindex].x#,1
				else
					dec player[playerindex].x#,1
				endif
					
			endif
								
			if player[playerindex].action$="Falling"
						
				inc player[playerindex].y#,1
					
			endif
			if player[playerindex].action$="Walker"
				if player[playerindex].direction=1
			//		inc player[playerindex].x#,1
				else
			//		dec player[playerindex].x#,1
				endif
			endif

		

// collision tests
		bx = floor(player[playerindex].x#)/pixelsize
		by = floor(player[playerindex].y#)/pixelsize
		py = playersizey / pixelsize
		
		
		if blocks[ bx, by+py ].value=0 // in an empty area so drop one
//			inc player[playerindex].y#
		endif
			if blocks[ bx, by+py+1 ].value=1 or blocks[ bx, by+py+1 ].value=5 // hit floor or platform
				if player[playerindex].action$<>"Builder" and player[playerindex].action$<>"Digger" then player[playerindex].action$="Walker"
			endif

				for a=bx-1 to bx+1
					if a>=0
						if blocks[ a, by].value=4 // hit obstical
							player[playerindex].action$="Walker"
							player[playerindex].direction = -player[playerindex].direction
						endif

						if blocks[ a, by].value=5 // hit building blocks
						if player[playerindex].action$<>"Builder" 
								player[playerindex].action$="Climbing"
							
							endif
						endif
					endif
				next
			
		
	endif
	

	next
	
	//print(GetRawLastKey())
	
	if GetRawKeyPressed(76) // level up
		// fade screen
		escape=0
		repeat
			for x=0 to 100
				for y=0 to 100
					dec blocks[offset+x,y].red,10
					dec blocks[offset+x,y].green,10
					dec blocks[offset+x,y].blue,10
					
					if blocks[offset+x,y].red<0 then blocks[offset+x,y].red=0
					if blocks[offset+x,y].green<0 then blocks[offset+x,y].green=0
					if blocks[offset+x,y].blue<0 then blocks[offset+x,y].blue=0
					
					if blocks[offset+x,y].red = 0 and blocks[offset+x,y].green = 0 and blocks[offset+x,y].blue = 0 then escape=1 

				next
			next	
			
			print(escape)
			displaymap(200,200,0)
			sync()
			
		until escape<>1
		exit
		createmaps(200,200)
		
	
	endif
	if playerincount>=lemmingcounter
		// LEVEL UP
		print ("LEVEL UP")
		sync()
		sleep(1000)
		createmaps(100,100)
		playerincount=0
		playeroutcount=0
		currentplayerindex=0
		inc lemmingcounter
		released=0
	endif
		
	
    if GetRawMouseLeftPressed()
		released=1
		
    endif
    
    if (timer()-framestep#>.5)
		if released=1
			if currentplayerindex<lemmingcounter
				framestep#=timer()
				pl.spr=CreateSprite(0)
				SetSpriteSize(pl.spr,playersizex,playersizey)
				SetSpriteColor(pl.spr, 0,0,255,255)
				player.insert(pl)
				player[currentplayerindex].x#=homex * 10
				player[currentplayerindex].y#=homey * 10
				player[currentplayerindex].direction =1
				player[currentplayerindex].speed# =2
				player[currentplayerindex].action$ ="Falling"
			
				inc currentplayerindex
				inc playeroutcount
			endif
		else
			print ("PRESS LEFT MOUSE BUTTON TO START")
		endif
	endif
    
    // if the pointer goes towards the left or right of the screen, then scroll the map with the offset variable
    if getpointerx()>screenwidth-100 then inc offset,1
    if getpointerx()<100 then dec offset,1
    if GetRawKeyState(37) then dec Offset
    if GetRawKeyState(39) then inc Offset
    
    
    
	displaymap(viewportsizex,viewportsizey,offset)
	
	SetTextString(playerouttext,"OUT " + str(playeroutcount))
	SetTextString(playerintext,"IN " + str(playerincount))
	
	
	Render2Dback()
    //Print( ScreenFPS() )
    Sync()
loop

function displaymapsprite(mapsprite,offset)
	SetSpritePosition(mapsprite,0,0)
	SetSpriteDepth(mapsprite,0)
	//Render2DBack()
	for a=0 to 3
		drawbox(a,a,screenwidth-a,70-a,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	next
	for a=3 to 6
		DrawBox(offset+a,a,offset+viewportsizex/2-a,70-a,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),0)
	next
	
	
	
endfunction
function buildinfoarea()
	playerintext = CreateText("IN")
	playerouttext = CreateText("OUT")
	infotitle = createtext("DIGGER")
	infotitle1 = createtext("Press Left Button for Digging, Right Button for Building")
	timetext = CreateText("TIME")
	
	SetTextSize(playerintext,50)
	SetTextSize(playerouttext,50)
	SetTextSize(infotitle,50)
	SetTextSize(timetext,50)
	SetTextSize(infotitle1,20)
	
	
	
endfunction

function buildmouse()
	mousegrabbed = createsprite(createmousegrabbed(30,30))
mousecross = createsprite(createmousecross(30,30))
mouse=mousecross

	SetSpriteDepth(mousegrabbed,1000)
	SetSpriteDepth(mousecross,1000)
	
endfunction
function createmousegrabbed(sizex,sizey)

	swap()
		DrawBox(0,0,sizex-1,sizey-1,MakeColor(255,0,0),MakeColor(255,255,0),MakeColor(0,255,0),MakeColor(0,0,255),0)
	render()
	img = GetImage(0,0,sizex,sizey)
	
	

endfunction img

function createmousecross(sizex,sizey)

	swap()
		DrawBox(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),1)
		DrawLine(sizex/2,100		,sizex/2,100+sizey,MakeColor(255,0,0),MakeColor(255,255,0))
		DrawLine(0		,100+sizey/2,sizex	,100+sizey/2,MakeColor(255,0,0),MakeColor(255,255,0))
	render()
	img = GetImage(0,100,sizex,100+sizey)
	
	

endfunction img



function displaymap(sizex, sizey, offset)
	
	for x=0 to sizex
		for y=0 to sizey
			o=offset

			if x+o=>0 and x+o<worldsizex
				if blocks[x+o,y].value<>0
					c=MakeColor(blocks[x+o,y].red,blocks[x+o,y].green,blocks[x+o,y].blue)
					DrawBox(x * pixelsize,y * pixelsize,(x*pixelsize) + pixelsize, (y*pixelsize) + pixelsize,c,c,c,c,1)
				endif
			endif
		next
	next
	
	
	SetTextPosition(infotitle,50,screenheight-100)
	SetTextPosition(playerouttext,350,screenheight-100)
	SetTextPosition(playerintext,500,screenheight-100)
	SetTextPosition(timetext,700,screenheight-100)
	
	SetTextPosition(infotitle1,screenwidth/2-GetTextTotalWidth(infotitle1)/2,screenheight-20)
	
endfunction


function buildsmallermap()
	
	
	swap()
	//blank the area first
	DrawBox(0,0,screenwidth,viewportsizey,MakeColor(0,0,0),MakeColor(0,0,0),MakeColor(0,0,0),MakeColor(0,0,0),1)
	for x=0 to screenwidth
		for y=10 to viewportsizey
			o=0
			if x+o=>0 and x+o<worldsizex
//print(x+o)
				if blocks[x+o,y].value<>0
					c=MakeColor(blocks[x+o,y].red,blocks[x+o,y].green,blocks[x+o,y].blue)
//					print (c)
					DrawBox(x ,y ,x+1, y+1,c,c,c,c,1)
				endif
			endif
		next
//		sync()
	next
	render()
	img = GetImage(0,0,screenwidth,viewportsizey)	

endfunction img

function createmapsImage(filename$)
	
    img = LoadImage(filename$)
      
    memblockid = CreateMemblockFromImage (img)
    imgwidth = GetMemblockInt(memblockid, 0)
    imgheight = GetMemblockInt(memblockid, 4)
      
      
    size=GetMemblockSize(memblockid)
  
	x=0 : y=0
    for offset=12 to size-4 step 4
        
		r=GetMemblockByte(memblockid, offset)
        g=GetMemblockByte(memblockid, offset+1)
        b=GetMemblockByte(memblockid, offset+2)
        a=GetMemblockByte(memblockid, offset+3)
        
        blocks[x,y].red = r
        blocks[x,y].green=g
        blocks[x,y].blue=b
        
        if r=0 and g=0 and b=0 
			blocks[x,y].value=0      
         else
    		blocks[x,y].value=1      
		endif
          
          
         inc x
         if x>=worldsizex
			 x=0
			 inc y
		endif
		if y>=worldsizey
			x=0
			y=0
		endif
          
    next
      
    deleteimage (img)
      
    img = CreateImageFromMemblock(memblockid)
    DeleteMemblock(memblockid)
  
  
endfunction 
	



function createmaps(sizex,sizey)
	player.length=-1
	
	//empty the world
	
	for x=0 to sizex
		for y=0 to sizey
			blocks[x,y].value=0
		next
	next
	
	
	
	// build floor
	for x=0 to sizex
		for y=sizey/2 to sizey-35
	//		if random(0,1)= 1 
				blocks[x,y].value=1
				if y=sizey/2 or y=sizey/2+1
					blocks[x,y].red = 0
					blocks[x,y].green = random(100,155)
					blocks[x,y].blue = 0
				else
					blocks[x,y].red = random(140,150)
					blocks[x,y].green = random(100,110)
					blocks[x,y].blue = random(35,45)

				endif
				
	//		endif
		next
	next

	
// Create a home
	r=random(sizex-10,sizex-5)
	for x=r to r+5
		for y=sizey/2-5 to sizey/2
				blocks[x,y].value=2
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = 0
			
		next
	next


// create a load of randomised obsticle
	for a=0 to 100
		rminx=random(random(0,40),random(1,40))
		rmaxx=random(rminx,random(0,40))
		
		rminy=random(random(0,40),random(0,40))
		rmaxy=random(rminy,sizey/2)
		
		rxstart=random(100,sizex-100)
		rystart=random(100,sizey/2-40)
		
		rc= random(0,4)
		
		for x=rxstart+rminx to rxstart+rmaxx
			
			
			
			for y=100 to 100+rmaxy
				blocks[x,y].value=4 // obsticle

				if rc=0 // tint of white
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = random(200,250)
				endif

				if rc=1 // tint of blue
					blocks[x,y].red = 0
					blocks[x,y].green = 0
					blocks[x,y].blue = random(200,250)
				endif

				if rc=2 // tint of green
					blocks[x,y].red = 0
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = 0
				endif

				if rc=3 // tint of yellow
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = random(200,250)
					blocks[x,y].blue = 0
				endif

				if rc=4 // tint of red
					blocks[x,y].red = random(200,250)
					blocks[x,y].green = 0
					blocks[x,y].blue = 0
				endif

			next
		next
	next



// create a entry
	r=sizex/2 // place it in the middle of the world
	for x=r to r+10
		for y=30 to 32
				blocks[x,y].value=3 // entry
					blocks[x,y].red = 0
					blocks[x,y].green = random(150,250)
					blocks[x,y].blue = random(150,250)

		next
	next
	homex=r/pixelsize
	homey=33

endfunction

// Project: ImagePixelRemove 
// Created: 2018-12-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "ImagePixelRemove" )
SetWindowSize( 640, 480, 1 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 640, 480 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global background_spr, background_image, background_memblock
global background_imgwidth, background_imgheight



// load and create initialise the background picture for ammendments

loadbackground("test.png")


do
	SetSpritePosition(background_spr, 0,0)


	if GetRawMouseLeftState()
		
		removepixel(getpointerx(),getpointery())
		SetSpriteImage(background_spr, background_image)
		
	endif


	if GetRawKeyPressed(27)
		disposeeverything()
	endif
	
    Print( ScreenFPS() )
    Sync()
loop

function loadbackground(filename$)
	background_image = LoadImage(filename$)
	background_memblock = CreateMemblockFromImage (background_image)
	background_imgwidth = GetMemblockInt(background_memblock, 0)
	background_imgheight = GetMemblockInt(background_memblock, 4)

	// set the background as a sprite to view on screen
	background_spr = CreateSprite(background_image)
endfunction

function removepixel( X, Y)
	// updte the loaded memblock
	
	
	print(background_imgwidth)
	
	for ay=-5 to 5
		for ax=-ay to ay

			offset = 12 + ((((Y+ay) * background_imgwidth) + (X+ax)) * 4)

			SetMemblockByte(background_memblock, offset   ,0)
			SetMemblockByte(background_memblock, offset+1 ,0)
			SetMemblockByte(background_memblock, offset+2 ,0)
			SetMemblockByte(background_memblock, offset+3 ,255)
		next
	next

background_image = CreateImageFromMemblock(background_memblock)
endfunction


function disposeeverything()
	DeleteMemblock(background_memblock)
	DeleteSprite(background_spr)
	DeleteImage(background_image)
	end	
	
endfunction

// Project: ImagePixelRemove 
// Created: 2018-12-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "ImagePixelRemove" )
SetWindowSize( 640, 480, 1 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 640, 480 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global background_spr, background_image, background_memblock
global background_imgwidth, background_imgheight



// load and create initialise the background picture for ammendments

loadbackground("test.png")

lemming=CreateSprite(0)
lemmingsizey=10

SetSpriteSize(lemming,5,lemmingsizey)
lemx=50
lemy=10



do
	SetSpritePosition(background_spr, 0,0)
	
	SetSpritePosition(lemming,lemx,lemy)

	

	if GetRawMouseLeftState()
		
		removepixel(getpointerx(),getpointery())
		SetSpriteImage(background_spr, background_image)
		
	endif


	if getpixelcolor(lemx,lemy+lemmingsizey) = MakeColor(0,0,0)
		inc lemy
	endif
	if GetRawKeyPressed(27)
		disposeeverything()
	endif
	
    Print( ScreenFPS() )
    Sync()
loop

function loadbackground(filename$)
	background_image = LoadImage(filename$)
	background_memblock = CreateMemblockFromImage (background_image)
	background_imgwidth = GetMemblockInt(background_memblock, 0)
	background_imgheight = GetMemblockInt(background_memblock, 4)

	// set the background as a sprite to view on screen
	background_spr = CreateSprite(background_image)
endfunction

function getpixelcolor( X, Y)
	offset = 12 + (((Y * background_imgwidth) + X) * 4)

	r=GetMemblockByte(background_memblock, offset)
	g=GetMemblockByte(background_memblock, offset+1)
	b=GetMemblockByte(background_memblock, offset+2)

	c = MakeColor(r,g,b)
endfunction c


function removepixel( X, Y)
	// updte the loaded memblock
	
	
	print(background_imgwidth)
	
	for ay=-5 to 5
		for ax=-5 to 5

			offset = 12 + ((((Y-ay) * background_imgwidth) + (X+ax)) * 4)

			SetMemblockByte(background_memblock, offset   ,0)
			SetMemblockByte(background_memblock, offset+1 ,0)
			SetMemblockByte(background_memblock, offset+2 ,0)
			SetMemblockByte(background_memblock, offset+3 ,255)
		next
	next

background_image = CreateImageFromMemblock(background_memblock)
endfunction


function disposeeverything()
	DeleteMemblock(background_memblock)
	DeleteSprite(background_spr)
	DeleteImage(background_image)
	end	
	
endfunction

// Project: ImagePixelRemove 
// Created: 2018-12-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "ImagePixelRemove" )
SetWindowSize( 640, 480, 1 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 640, 480 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
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

global background_spr, background_image, background_memblock
global background_imgwidth, background_imgheight


type _lemmings
	x#
	y#
	spr
	sizey
	sizex
endtype
global lemmings as _lemmings[]


// load and create initialise the background picture for ammendments

loadbackground("test.png")


create_a_lemming()


framestep#=timer()

do
	SetSpritePosition(background_spr, 0,0)
	


	for lemmingcounter=0 to lemmings.length
			
		SetSpritePosition(lemmings[lemmingcounter].spr,lemmings[lemmingcounter].x#,lemmings[lemmingcounter].y#)

		if getpixelcolor(lemmings[lemmingcounter].x#,lemmings[lemmingcounter].y#+lemmings[lemmingcounter].sizey) = MakeColor(0,0,0)
			inc lemmings[lemmingcounter].y#
		else
			inc lemmings[lemmingcounter].x#
		endif
	next

// check things on frame rate timers
	if (timer()-framestep#)>1
		framestep#=timer()
		create_a_Lemming()
	endif


// check keyboard stuff	



	if GetRawKeyPressed(27)
		disposeeverything()
	endif
	
    Print( ScreenFPS() )
    Sync()
loop


function create_a_Lemming()
	lemm as _lemmings
	
	lemm.spr=CreateSprite(0)
	lemm.sizex=5
	lemm.sizey=10

	SetSpriteSize(lemm.spr,5,lemm.sizey)
	lemm.x#=50
	lemm.y#=10
	
	lemmings.insert(lemm)
	
endfunction



// Background pixel get and retreive stuff

function loadbackground(filename$)
	background_image = LoadImage(filename$)
	background_memblock = CreateMemblockFromImage (background_image)
	background_imgwidth = GetMemblockInt(background_memblock, 0)
	background_imgheight = GetMemblockInt(background_memblock, 4)

	// set the background as a sprite to view on screen
	background_spr = CreateSprite(background_image)
endfunction

function getpixelcolor( X, Y)
	offset = 12 + (((Y * background_imgwidth) + X) * 4)

	r=GetMemblockByte(background_memblock, offset)
	g=GetMemblockByte(background_memblock, offset+1)
	b=GetMemblockByte(background_memblock, offset+2)

	c = MakeColor(r,g,b)
endfunction c


function removepixel( X, Y)
	// updte the loaded memblock
	
	
	print(background_imgwidth)
	
	for ay=-5 to 5
		for ax=-5 to 5

			offset = 12 + ((((Y-ay) * background_imgwidth) + (X+ax)) * 4)

			SetMemblockByte(background_memblock, offset   ,0)
			SetMemblockByte(background_memblock, offset+1 ,0)
			SetMemblockByte(background_memblock, offset+2 ,0)
			SetMemblockByte(background_memblock, offset+3 ,255)
		next
	next

background_image = CreateImageFromMemblock(background_memblock)
endfunction


function disposeeverything()
	DeleteMemblock(background_memblock)
	DeleteSprite(background_spr)
	DeleteImage(background_image)
	end	
	
endfunction

 
Function pickColor(X,Y)
    local color,img 
    //color as integer
    rem prepare image grab area
    clearScreen()
    render()
   
    img = getImage(X,Y,X+1,Y+1)
   
    rem create memblock
      
    mem = createMemblockfromImage(img)
   
    rem get memblock data
    r = getMemblockbyte(mem,12):rem gets red channel data
    g = getMemblockbyte(mem,13):rem gets green channel data
    b = getMemblockbyte(mem,14):rem gets blue channel data
   
      
    rem tidy up
    deletememblock(mem)
    deleteimage(img)
    clearScreen()
    color = makeColor(r,g,b)
    //color=0
endfunction color

function pickColor2( X, Y)
	offset = 12 + (((Y * background_imgwidth) + X) * 4)

	r=GetMemblockByte(background_memblock, offset)
	g=GetMemblockByte(background_memblock, offset+1)
	b=GetMemblockByte(background_memblock, offset+2)

	c = MakeColor(r,g,b)
endfunction c

// Project: Lemmings Remake on App Game Kit 
// Created: 2018-12-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "Lemmings V3" )
SetWindowSize( 640, 480, 1 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 640, 480 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 60, 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

global background_spr, background_image, background_memblock
global background_imgwidth, background_imgheight
global background_x=0


global worldsizex#=2048
global worldsizey#=320


type _lemmings
	x#
	y#
	direction // -1 left, 1 - right
	spr
	sizey
	sizex
endtype
global lemmings as _lemmings[]


// load and create initialise the background picture for ammendments

loadbackground("test.png")

framestep#=timer()

do
	SetSpritePosition(background_spr, background_x,00)
	

	for lemmingcounter=0 to lemmings.length
			
		SetSpritePosition(lemmings[lemmingcounter].spr,lemmings[lemmingcounter].x#+background_x,lemmings[lemmingcounter].y#)

		// check feet of lemm in case hit floor
		if getpixelcolor(lemmings[lemmingcounter].x#,lemmings[lemmingcounter].y#+lemmings[lemmingcounter].sizey) = MakeColor(0,0,0)
			inc lemmings[lemmingcounter].y#
		else
			if lemmings[lemmingcounter].direction=1
				inc lemmings[lemmingcounter].x#
			else
				dec lemmings[lemmingcounter].x#
			endif
		endif


		// check middle of the lemm incase hits an obsiticle
		if getpixelcolor(lemmings[lemmingcounter].x#+lemmings[lemmingcounter].sizex*2,lemmings[lemmingcounter].y#+(lemmings[lemmingcounter].sizey-1)) <> MakeColor(0,0,0)

			lemmings[lemmingcounter].direction = -lemmings[lemmingcounter].direction
		endif



 		// check middle of the lemm to see if reached home - home pixel is pure white pixel (255,255,255)
		if getpixelcolor(lemmings[lemmingcounter].x#+lemmings[lemmingcounter].sizex*2,lemmings[lemmingcounter].y#+(lemmings[lemmingcounter].sizey-1)) = MakeColor(255,255,255)
			SetSpriteVisible(lemmings[lemmingcounter].spr,0)
			
		endif


	next


	checkkeyboardinputs()
	


// check things on frame rate timers
	if (timer()-framestep#)>1 // every one second produce a lemming
		framestep#=timer()
		create_a_Lemming()
	endif

    Print( ScreenFPS() )
    Sync()
loop


// **********************************************
// Keyboard Controller functions
// **********************************************

// check keyboard stuff	
function checkkeyboardinputs()
	
	if GetRawMouseLeftState() then removepixel(getpointerx(),getpointery())
	
	if GetRawMouseRightState() then setpixelcolor(getpointerx(),getpointery(), 255,0,0,255)
	
	if GetRawKeyPressed(27) then disposeeverything()		// ESCAPE key
	
	if GetRawKeyState(37)  then dec background_x			// LEFT_CURSOR_KEY
		
	if GetRawKeyState(39)  then inc background_x			// RIGHT_CURSOR_KEY
	

endfunction

// **********************************************
// End of Keyboard Controller functions
// **********************************************



// **********************************************
// Lemmings actions, creations functions
// **********************************************
// does exactly what it says in the function name
function create_a_Lemming()
	lemm as _lemmings
	
	lemm.spr=CreateSprite(0) // this is a testing sprite (your own sprites can be used)
	
	lemm.sizex=8  // used for memory image checking for pixels
	lemm.sizey=10 // used for memory image checking for pixels

	lemm.x#=54    // starting location X
	lemm.y#=110    // starting location Y

	lemm.direction=1 // start by going right


	SetSpritePosition(lemm.spr,lemm.x#,lemm.y#)
	SetSpriteSize(lemm.spr,5,lemm.sizey)
	SetSpriteColor(lemm.spr,0,0,255,255)
	
	lemmings.insert(lemm)
	
endfunction
// **********************************************
// End of Lemmings actions, creations functions
// **********************************************


// ************************************************
//  Landscape generator
// ************************************************
function generatebackground(sizex#,sizey#, red,green,blue, density)
	
	color=MakeColor(0,0,0)
	white = MakeColor(255,255,255)
	swap()
    drawbox(0,0,sizex#, sizey#, color, color,color,color, 1)
//    drawbox(0,0,sizex#, sizey#, white, white, white, white, 0)

    render()
    img = getimage(0,0,sizex#, sizey#)
      
    background_memblock = CreateMemblockFromImage (img)
    background_imgwidth = GetMemblockInt(background_memblock, 0)
    background_imgheight = GetMemblockInt(background_memblock, 4)
      
      
        size=GetMemblockSize(background_memblock)
  
// create greass layer
	for x=0 to sizex#
		for y=sizey#/2-random(0,10) to sizey#/2+random(0,10)

			offset = 12 + (((Y * background_imgwidth) + X) * 4)
			
			strength=random(1,density)

			
			SetMemblockByte(background_memblock, offset,   red-strength)
			SetMemblockByte(background_memblock, offset+1, green-strength)
			setMemblockByte(background_memblock, offset+2, blue-strength)
			setMemblockByte(background_memblock, offset+3, 254) // 254 is air, can move in it
		next
	next

	red = 90 : green= 77 : blue = 65
// create unerground
	for x=0 to sizex#
		for y=sizey#/2 to sizey#

			offset = 12 + (((Y * background_imgwidth) + X) * 4)
			
			strength=random(1,density)

			
			SetMemblockByte(background_memblock, offset,   red-strength)
			SetMemblockByte(background_memblock, offset+1, green-strength)
			setMemblockByte(background_memblock, offset+2, blue-strength)
			setMemblockByte(background_memblock, offset+3, 255) // 255 is rock and such like / obsticle
		next
	next

      
    deleteimage (img)
      
    Background_image = CreateImageFromMemblock(background_memblock)
//    DeleteMemblock(memblockid)
  

	
	
endfunction 


// ************************************************
// Memory management 
// ************************************************
// Background pixel get and retreive stuff

// Load a background image
function loadbackground(filename$)
//	background_image = LoadImage(filename$)

	generatebackground(worldsizex#,worldsizey#,0,200,0,200)

//	background_memblock = CreateMemblockFromImage (background_image)
//	background_imgwidth = GetMemblockInt(background_memblock, 0)
//	background_imgheight = GetMemblockInt(background_memblock, 4)

	// set the background as a sprite to view on screen
	background_spr = CreateSprite(background_image)
endfunction


// Get a pixel color - which will provide what the color is on the loaded image it is at any
// given location
// a lemming can move on a completely blank area
function getpixelcolor( X, Y)
	offset = 12 + (((Y * background_imgwidth) + X) * 4)

	r=GetMemblockByte(background_memblock, offset)
	g=GetMemblockByte(background_memblock, offset+1)
	b=GetMemblockByte(background_memblock, offset+2)

	c = MakeColor(r,g,b)
endfunction c


// Testing of creating a pixel - not used for lemmings but could be good in a paint package app
function setpixelcolor( X, Y, red, green, blue, alpha)

	for ay=-5 to 5
		for ax=-5 to 5

			offset = 12 + ((((Y-ay) * background_imgwidth) + (X+ax)) * 4)
			SetMemblockByte(background_memblock, offset,   red)
			SetMemblockByte(background_memblock, offset+1, green)
			setMemblockByte(background_memblock, offset+2, blue)
			setMemblockByte(background_memblock, offset+3, alpha)
		next
	next

	background_image = CreateImageFromMemblock(background_memblock)
	SetSpriteImage(background_spr,background_image)

endfunction 


// a lemming can destroy the landscape, so this is used for that
function removepixel( X, Y)
	
	// create a wider space to destroy (or make black)
	for ay=-5 to 5
		for ax=-5 to 5

			offset = 12 + ((((Y-ay) * background_imgwidth) + (X+ax)) * 4)

			SetMemblockByte(background_memblock, offset   ,0)
			SetMemblockByte(background_memblock, offset+1 ,0)
			SetMemblockByte(background_memblock, offset+2 ,0)
			SetMemblockByte(background_memblock, offset+3 ,255)
		next
	next

	background_image = CreateImageFromMemblock(background_memblock)
	SetSpriteImage(background_spr,background_image)
	
endfunction

// clean up the app

function disposeeverything()
	DeleteMemblock(background_memblock)
	DeleteSprite(background_spr)
	DeleteImage(background_image)
	end	
	
endfunction


// ***************************************
// End of memmory management 
// ***************************************

// Project: spritemodellor 
// Created: 2018-12-13

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0

// set window properties
SetWindowTitle( "spritemodellor" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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

global background_memblock, red, green, blue, palette,mouse, maxframes=0



global initialsizex=32
global initialsizey=32


global buttons as integer[10]

type _animationframes
	spritesizex
	spritesizey
	spr
	image
	memblock
endtype
global sprites as _animationframes[32]	

dim dataforsprite [initialsizex, initialsizey]


createpalleteandmouse()

setupspritedata()




addbuttons(1,50,730,60,"New",255,255,0)
addbuttons(2,150,730,60,"Open",255,255,0)
addbuttons(3,250,730,60,"Save",255,255,0)
addbuttons(4,350,730,60,"Apply",255,255,0)
addbuttons(5,450,730,60,"Prev",255,255,0)
addbuttons(6,550,730,60,"Next",255,255,0)
addbuttons(7,650,730,60,"Copy",255,255,0)
addbuttons(8,750,730,60,"Play",255,255,0)
addbuttons(9,850,730,60,"Clear",255,255,0)


animationframestep#=timer()
currentsprite=0
animationframe=0
player=-1
do
	SetSpritePosition(mouse, getpointerx(), getpointery())
	SetSpritePosition(palette,650,200)	

// color selector	
	if GetSpriteCollision(mouse,palette)
		getpixelcolor(getpointerx(),getpointery())
		if GetRawMouseLeftState() 
			selectcolor = MakeColor(activecolorred,activecolorgreen,activecolorblue)
			selectcolorred = red
			selectcolorgreen = green
			selectcolorblue = blue		
		endif
		activecolorred = red
		activecolorgreen=green
		activecolorblue = blue
		colorselected = MakeColor(activecolorred,activecolorgreen,activecolorblue)	
	endif
	DrawBox(700,610,1000,640,colorselected,colorselected,colorselected,colorselected,1)
	DrawBox(700,650,1000,680,selectcolor,selectcolor,selectcolor,selectcolor,1)





// draw large grids for srite
	originx=50
	originy=90
	
	
	size=18

	spritenumber=0
    for x=0 to sprites[spritenumber].spritesizex
		for y=0 to sprites[spritenumber].spritesizey
			
			ax=originx + (x * size)
			ay=originy + (y * size)
			DrawBox( ax ,ay , ax+size,ay+size,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),0)
			SetSpritePosition(dataforsprite[x,y], ax, ay)
			SetSpriteSize(dataforsprite[x,y],size,size)
			
			if GetSpriteCollision(mouse,dataforsprite[x,y])
				if GetRawMouseLeftState()
					SetSpriteColor(dataforsprite[x,y],selectcolorred,selectcolorgreen,selectcolorblue,255)
					
				endif
				if GetRawMouseRightState()
					SetSpriteColor(dataforsprite[x,y],0,0,0,255)
					
				endif
			endif
			
			
			
		next
	next
	
	
// draw the smaller version of the sprite and the animation frames
	
	originx=800
	originy=100
spritenumber=0
    for x=0 to sprites[spritenumber].spritesizex
		for y=0 to sprites[spritenumber].spritesizey
			cr = GetSpriteColorRed(dataforsprite[x,y])
			cg = GetSpriteColorGreen(dataforsprite[x,y])
			cb = GetSpriteColorBlue(dataforsprite[x,y])
			c = MakeColor(cr,cg,cb)
			ax =originx + x 
			ay = originy + y 
			DrawBox(ax ,ay, ax+1,ay+1,c,c,c,c,1)

			
		next
	next
	

// draw the sprites animation steps along the top	
	originx=50
	originy=10
	spritenumber=0
	for y=0 to 25
		for x=0 to 25
			if spritenumber<sprites.length 
				ax= originx+(x * (sprites[spritenumber].spritesizex+5))
				ay= originy + (y * (sprites[spritenumber].spritesizex+5))
				SetSpritePosition(sprites[spritenumber].spr,ax,ay)
	
				// draw box around the currentsprite, so we know which one we working with
				if spritenumber=currentsprite then DrawBox(ax,ay,ax+sprites[spritenumber].spritesizex,ay+sprites[spritenumber].spritesizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),0)
			
				
			endif
			inc spritenumber
		next
	next

	



	if GetVirtualButtonPressed(4)=1
		applyimage(currentsprite)
	endif
	
// Goto previous frame
	if GetVirtualButtonPressed(5)=1
			
		dec currentsprite
	endif
	
// GO TO NEXT FRAME
	if GetVirtualButtonPressed(6)=1
		applyimage(currentsprite)
		inc maxframes
		inc currentsprite
	endif


// COPY
	if GetVirtualButtonPressed(7)=1
		inc maxframes
		inc currentsprite

		applyimage(currentsprite)

	endif


	if GetVirtualButtonPressed(8)=1
		player=-player
		
		if player=-1
			for a=0 to sprites.length
				SetSpriteVisible(sprites[a].spr,1)
			next
		endif

	endif
	
	if GetVirtualButtonPressed(9) = 1
		spritenumber=0
		for x=0 to sprites[spritenumber].spritesizex
			for y=0 to sprites[spritenumber].spritesizey
				SetSpriteColor(dataforsprite[x,y],0,0,0,255)
			next
		next
	
			
	endif
	

	if player=1
		if (timer()-animationframestep#>.01)
			animationframestep#=timer()
			inc animationframe
			if animationframe>maxframes-1 then animationframe=0
		
			for a=0 to maxframes-1
				SetSpritePosition(sprites[a].spr,760,100)
				SetSpriteVisible(sprites[a].spr,0)
			next
				SetSpriteVisible(sprites[animationframe].spr,1)
		endif
	
	endif
	
	
	
	
//
	if GetRawKeyPressed(27) then end

	Render2DBack()
    Sync()
loop


function setupspritedata()
	
	
for spritenumber=0 to sprites.length
	for x=0 to initialsizex
		for y=0 to initialsizey
			sprites[spritenumber].spr = CreateSprite(0)
			sprites[spritenumber].spritesizex = initialsizex
			sprites[spritenumber].spritesizey = initialsizey
			setspritecolor(sprites[spritenumber].spr,0,0,0,255)
			SetSpriteSize(sprites[spritenumber].spr,initialsizex,initialsizey)
			SetSpriteColor(sprites[spritenumber].spr,255,255,255,255)


		next
	next
	
next
for x=0 to initialsizex
	for y=0 to initialsizey
			dataforsprite[x,y] = CreateSprite(0)
			SetSpriteSize(dataforsprite[x,y],initialsizex,initialsizey)
			SetSpriteColor(dataforsprite[x,y],0,0,0,255)
			inc spritenumber
		next
	next

for spritenumber=0 to sprites.length
	applyimage(spritenumber)
next

endfunction

function createpalleteandmouse()
	//create palette
swap()

	DrawBox(0,0,200,100,MakeColor(0,0,0),MakeColor(255,0,0),MakeColor(255,255,255),MakeColor(0,255,255),1)
	DrawBox(0,100,200,200,MakeColor(255,255,255),MakeColor(0,255,255),MakeColor(0,0,255),MakeColor(0,255,255),1)

	DrawBox(0,200,200,300,MakeColor(0,0,255),MakeColor(0,255,255),MakeColor(255,255,0),MakeColor(255,0,255),1)

	DrawBox(0,300,200,400,MakeColor(255,255,0),MakeColor(255,0,255),MakeColor(255,255,255),MakeColor(0,0,0),1)

	DrawBox(200,0,400,100,MakeColor(255,0,0),MakeColor(0,255,0),MakeColor(0,255,255),MakeColor(255,255,255),1)
	DrawBox(200,100,400,200,MakeColor(0,255,255),MakeColor(255,255,255),MakeColor(0,255,255),MakeColor(255,255,255),1)
	DrawBox(200,200,400,300,MakeColor(0,255,255),MakeColor(255,255,255),MakeColor(255,0,255),MakeColor(0,255,0),1)
	DrawBox(200,300,400,400,MakeColor(255,0,255),MakeColor(0,255,0),MakeColor(0,0,0),MakeColor(0,0,0),1)


	render()
	palette = CreateSprite(GetImage(0,0,400,400))
	background_memblock = CreateMemblockFromImage(palette)


	mouse= CreateSprite(getimage(0,0,1,1))
	SetSpriteSize(mouse,1,1)

endfunction

function applyimage(currentsprite)
				sprites[currentsprite].image = getimage(0,0,sprites[currentsprite].spritesizex+1,sprites[currentsprite].spritesizey+1)
			sprites[currentsprite].memblock = CreateMemblockFromImage (sprites[currentsprite].image)
			background_imgwidth = GetMemblockInt(sprites[currentsprite].memblock, 0)
			background_imgheight = GetMemblockInt(sprites[currentsprite].memblock, 4)
			
			for xx=0 to sprites[currentsprite].spritesizex
				for yy=0 to sprites[currentsprite].spritesizey
					offset = 12 + (((Yy * background_imgwidth) + Xx) * 4)
			
					cr = GetSpriteColorRed(dataforsprite[xx,yy])
					cg = GetSpriteColorGreen(dataforsprite[xx,yy])
					cb = GetSpriteColorBlue(dataforsprite[xx,yy])
					SetMemblockByte(sprites[currentsprite].memblock, offset,   cr)
					SetMemblockByte(sprites[currentsprite].memblock, offset+1, cg)
					setMemblockByte(sprites[currentsprite].memblock, offset+2, cb)
					setMemblockByte(sprites[currentsprite].memblock, offset+3, 254) // 254 is air, can move in it
				next
			next


      
//		deleteimage (img)
      
		sprites[currentsprite].image = CreateImageFromMemblock(sprites[currentsprite].memblock)
		//DeleteMemblock(background_memblock)
  
		SetSpriteImage(sprites[currentsprite].spr,sprites[currentsprite].image)
endfunction

// Get a pixel color - which will provide what the color is on the loaded image it is at any
// given location
// a lemming can move on a completely blank area
function getpixelcolor( X, Y)
	offset = 12 + ((((Y-getspritey(palette)) * GetSpriteWidth(palette)) + (X-getspritex(palette))) * 4)
	
	if offset>0 
		print(y-getspritey(palette))
		print(x-getspritex(palette))
		print(offset)

		red=GetMemblockByte(background_memblock, offset)
		green=GetMemblockByte(background_memblock, offset+1)
		blue=GetMemblockByte(background_memblock, offset+2)
	endif
	
endfunction 

function addbuttons(id,x,y,size,name$,colorred,colorgreen,colorblue)
	

    AddVirtualButton(id,x,y,size)
    SetVirtualButtonAlpha(id,255)
    SetVirtualButtonColor(id,colorred,colorgreen,colorblue)
    SetVirtualButtonText(id,name$)
    //GetVirtualButtonExists
    //GetVirtualButtonPressed
    //GetVirtualButtonReleased
    //GetVirtualButtonState
    //SetButtonScreenPosition
    //SetVirtualButtonActive
    //SetVirtualButtonImageDown
    //SetVirtualButtonImageUp
    //SetVirtualButtonPosition
//    SetVirtualButtonSize(

    
endfunction

swap
for x = 1 to 16 
    for y=1 to 16
        draw sprite at x and y in increments of its size
    next
next
render
img = getimage(0,0, fullsizex, fullsizey)

function savespritesheet()
	
	// how many are there
	// maxsprites
	
	// what size is each one
	// spritesizex
	// spritesizey
	
	// lets build an image based on the size

// resync()

	sync()

// draw all the frames in the upper left corner
	spritenumber=0
	for y=0 to 16
		for x=0 to 16
			if spritenumber<maxframes
				
				SetSpritePosition(sprites[spritenumber].spr,x*32,y*32)
			endif
			inc spritenumber
		next
	next

// Rensync everything to to the back buffer

	sync()
	render()

// Only grab the portion we want

	img = getimage(0,0,maxframes * 32,32)

// Save
	SaveImage(img,"test.png")	

	
	
endfunction

// Project: spritemodellor 
// Created: 2018-12-13

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0

// set window properties
SetWindowTitle( "spritemodellor" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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

//SetErrorMode(1)
global background_memblock, red, green, blue, palette,mouse, maxframes=0



global initialsizex=32
global initialsizey=32


global buttons as integer[10]

type _animationframes
	spritesizex
	spritesizey
	spr
	image
	memblock
endtype
global sprites as _animationframes[32]	

dim dataforsprite [initialsizex, initialsizey]


createpalleteandmouse()

setupspritedata()






addbuttons(1,50,730,60,"New",255,255,0)
addbuttons(2,150,730,60,"Open",255,255,0)
addbuttons(3,250,730,60,"Save",255,255,0)
addbuttons(4,350,730,60,"Apply",255,255,0)
addbuttons(5,450,730,60,"Prev",255,255,0)
addbuttons(6,550,730,60,"Next",255,255,0)
addbuttons(7,650,730,60,"Copy",255,255,0)
addbuttons(8,750,730,60,"Play",255,255,0)
addbuttons(9,850,730,60,"Clear",255,255,0)


animationframestep#=timer()
currentsprite=0 : maxframes=1
animationframe=0
player=-1
do
	SetSpritePosition(mouse, getpointerx(), getpointery())
	SetSpritePosition(palette,650,200)	

// color selector	
	if GetSpriteCollision(mouse,palette)
		getpixelcolor(getpointerx(),getpointery())
		if GetRawMouseLeftState() 
			selectcolor = MakeColor(activecolorred,activecolorgreen,activecolorblue)
			selectcolorred = red
			selectcolorgreen = green
			selectcolorblue = blue		
		endif
		activecolorred = red
		activecolorgreen=green
		activecolorblue = blue
		colorselected = MakeColor(activecolorred,activecolorgreen,activecolorblue)	
	endif
	DrawBox(700,610,1000,640,colorselected,colorselected,colorselected,colorselected,1)
	DrawBox(700,650,1000,680,selectcolor,selectcolor,selectcolor,selectcolor,1)





// draw large grids for srite
	originx=50
	originy=90
	
	
	size=18

	spritenumber=0
    for x=0 to sprites[spritenumber].spritesizex
		for y=0 to sprites[spritenumber].spritesizey
			
			ax=originx + (x * size)
			ay=originy + (y * size)
			DrawBox( ax ,ay , ax+size,ay+size,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),0)
			SetSpritePosition(dataforsprite[x,y], ax, ay)
			SetSpriteSize(dataforsprite[x,y],size,size)
			
			if GetSpriteCollision(mouse,dataforsprite[x,y])
				if GetRawMouseLeftState()
					SetSpriteColor(dataforsprite[x,y],selectcolorred,selectcolorgreen,selectcolorblue,255)
					
				endif
				if GetRawMouseRightState()
					SetSpriteColor(dataforsprite[x,y],0,0,0,255)
					
				endif
			endif
			
			
			
		next
	next
	
	
// draw the smaller version of the sprite and the animation frames
	
	originx=800
	originy=100
	spritenumber=0
    for x=0 to sprites[spritenumber].spritesizex
		for y=0 to sprites[spritenumber].spritesizey
			cr = GetSpriteColorRed(dataforsprite[x,y])
			cg = GetSpriteColorGreen(dataforsprite[x,y])
			cb = GetSpriteColorBlue(dataforsprite[x,y])
			c = MakeColor(cr,cg,cb)
			ax =originx + x 
			ay = originy + y 
			DrawBox(ax ,ay, ax+1,ay+1,c,c,c,c,1)

			
		next
	next
	

// draw the sprites animation steps along the top	
	originx=50
	originy=10
	spritenumber=0
	for y=0 to 25
		for x=0 to 25
			if spritenumber<sprites.length 
				ax= originx+(x * (sprites[spritenumber].spritesizex))
				ay= originy + (y * (sprites[spritenumber].spritesizex))
				SetSpritePosition(sprites[spritenumber].spr,ax,ay)
	
				// draw box around the currentsprite, so we know which one we working with
				if spritenumber=currentsprite then DrawBox(ax,ay,ax+sprites[spritenumber].spritesizex,ay+sprites[spritenumber].spritesizey,MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),MakeColor(255,255,255),0)
			
				
			endif
			inc spritenumber
		next
	next

	
	
// save sheet

	if GetVirtualButtonPressed(3)=1
		savespritesheet()
	endif


// apply
	if GetVirtualButtonPressed(4)=1
		applyimage(currentsprite)
	endif
	
// Goto previous frame
	if GetVirtualButtonPressed(5)=1
			
		dec currentsprite
	endif
	
// GO TO NEXT FRAME
	if GetVirtualButtonPressed(6)=1
		applyimage(currentsprite)
		inc maxframes
		inc currentsprite
	endif


// COPY
	if GetVirtualButtonPressed(7)=1
		inc maxframes
		inc currentsprite

		applyimage(currentsprite)

	endif


	if GetVirtualButtonPressed(8)=1
		player=-player
		
		if player=1 
			DeleteSprite(animation)
			animation=CreateSprite(0)

			for a=1 to maxframes-1
				AddSpriteAnimationFrame(animation,sprites[a].image)
			next
			PlaySprite(animation)
		else
			
			stopsprite(animation)
		endif
		SetSpritePosition(animation,700,100)


	endif
	
	if GetVirtualButtonPressed(9) = 1
		
		spritenumber=0
		for x=0 to sprites[spritenumber].spritesizex
			for y=0 to sprites[spritenumber].spritesizey
				SetSpriteColor(dataforsprite[x,y],0,0,0,255)
			next
		next
	
			
	endif
	

	
	
//
	if GetRawKeyPressed(27) then end
	Render2DBack()
    Sync()
loop


function setupspritedata()
	
	
for spritenumber=0 to sprites.length
	for x=0 to initialsizex
		for y=0 to initialsizey
			sprites[spritenumber].spr = CreateSprite(0)
			sprites[spritenumber].spritesizex = initialsizex
			sprites[spritenumber].spritesizey = initialsizey
			setspritecolor(sprites[spritenumber].spr,0,0,0,255)
			SetSpriteSize(sprites[spritenumber].spr,initialsizex,initialsizey)
			SetSpriteColor(sprites[spritenumber].spr,255,255,255,255)


		next
	next
	
next
for x=0 to initialsizex
	for y=0 to initialsizey
			dataforsprite[x,y] = CreateSprite(0)
			SetSpriteSize(dataforsprite[x,y],initialsizex,initialsizey)
			SetSpriteColor(dataforsprite[x,y],0,0,0,255)
			inc spritenumber
		next
	next

for spritenumber=0 to sprites.length
	applyimage(spritenumber)
next

endfunction

function createpalleteandmouse()
	//create palette
swap()

	DrawBox(0,0,200,100,MakeColor(0,0,0),MakeColor(255,0,0),MakeColor(255,255,255),MakeColor(0,255,255),1)
	DrawBox(0,100,200,200,MakeColor(255,255,255),MakeColor(0,255,255),MakeColor(0,0,255),MakeColor(0,255,255),1)

	DrawBox(0,200,200,300,MakeColor(0,0,255),MakeColor(0,255,255),MakeColor(255,255,0),MakeColor(255,0,255),1)

	DrawBox(0,300,200,400,MakeColor(255,255,0),MakeColor(255,0,255),MakeColor(255,255,255),MakeColor(0,0,0),1)

	DrawBox(200,0,400,100,MakeColor(255,0,0),MakeColor(0,255,0),MakeColor(0,255,255),MakeColor(255,255,255),1)
	DrawBox(200,100,400,200,MakeColor(0,255,255),MakeColor(255,255,255),MakeColor(0,255,255),MakeColor(255,255,255),1)
	DrawBox(200,200,400,300,MakeColor(0,255,255),MakeColor(255,255,255),MakeColor(255,0,255),MakeColor(0,255,0),1)
	DrawBox(200,300,400,400,MakeColor(255,0,255),MakeColor(0,255,0),MakeColor(0,0,0),MakeColor(0,0,0),1)


	render()
	palette = CreateSprite(GetImage(0,0,400,400))
	background_memblock = CreateMemblockFromImage(palette)


	mouse= CreateSprite(getimage(0,0,1,1))
	SetSpriteSize(mouse,1,1)

endfunction

function applyimage(currentsprite)
				sprites[currentsprite].image = getimage(0,0,sprites[currentsprite].spritesizex+1,sprites[currentsprite].spritesizey+1)
			sprites[currentsprite].memblock = CreateMemblockFromImage (sprites[currentsprite].image)
			background_imgwidth = GetMemblockInt(sprites[currentsprite].memblock, 0)
			background_imgheight = GetMemblockInt(sprites[currentsprite].memblock, 4)
			
			for xx=0 to sprites[currentsprite].spritesizex
				for yy=0 to sprites[currentsprite].spritesizey
					offset = 12 + (((Yy * background_imgwidth) + Xx) * 4)
			
					cr = GetSpriteColorRed(dataforsprite[xx,yy])
					cg = GetSpriteColorGreen(dataforsprite[xx,yy])
					cb = GetSpriteColorBlue(dataforsprite[xx,yy])
					SetMemblockByte(sprites[currentsprite].memblock, offset,   cr)
					SetMemblockByte(sprites[currentsprite].memblock, offset+1, cg)
					setMemblockByte(sprites[currentsprite].memblock, offset+2, cb)
					setMemblockByte(sprites[currentsprite].memblock, offset+3, 254) // 254 is air, can move in it
				next
			next


      
//		deleteimage (img)
      
		sprites[currentsprite].image = CreateImageFromMemblock(sprites[currentsprite].memblock)
		//DeleteMemblock(background_memblock)
  
		SetSpriteImage(sprites[currentsprite].spr,sprites[currentsprite].image)
endfunction

// Get a pixel color - which will provide what the color is on the loaded image it is at any
// given location
// a lemming can move on a completely blank area
function getpixelcolor( X, Y)
	offset = 12 + ((((Y-getspritey(palette)) * GetSpriteWidth(palette)) + (X-getspritex(palette))) * 4)
	
	if offset>0 

		red=GetMemblockByte(background_memblock, offset)
		green=GetMemblockByte(background_memblock, offset+1)
		blue=GetMemblockByte(background_memblock, offset+2)
	endif
	
endfunction 

function addbuttons(id,x,y,size,name$,colorred,colorgreen,colorblue)
	

    AddVirtualButton(id,x,y,size)
    SetVirtualButtonAlpha(id,255)
    SetVirtualButtonColor(id,colorred,colorgreen,colorblue)
    SetVirtualButtonText(id,name$)
    //GetVirtualButtonExists
    //GetVirtualButtonPressed
    //GetVirtualButtonReleased
    //GetVirtualButtonState
    //SetButtonScreenPosition
    //SetVirtualButtonActive
    //SetVirtualButtonImageDown
    //SetVirtualButtonImageUp
    //SetVirtualButtonPosition
//    SetVirtualButtonSize(

    
endfunction


function savespritesheet()
	
	// how many are there
	// maxsprites
	
	// what size is each one
	// spritesizex
	// spritesizey
	
	// lets build an image based on the size

	sync()
	spritenumber=0
	for y=0 to 16
		for x=0 to 16
			if spritenumber<maxframes
				
				SetSpritePosition(sprites[spritenumber].spr,x*32,y*32)
			endif
			inc spritenumber
		next
	next
	sync()
	render()
	img = getimage(0,0,maxframes * 32,32)
	SaveImage(img,"test.png")	

	
	
endfunction