Sorry your browser is not supported!

` Looney Lander Coding Challenge
` June, 2011 by Rich Dersheimer
`
` To land safely, lateral velocity
` must be no more than .050 and descent
` velocity must be no more than .500
` Also, don't hit the moon slugs.

set display mode 800,600,32
autocam off
hide mouse

nRound = 1
gosub drawgraphics
gosub splashscreen
gosub setupvars

sync on
sync rate 60
sync

` ***************************
do
    hide limb nShip,1
    hide limb nShip,2
    hide limb nShip,3
    
    if rightkey()=1 AND nFuel > 0
        show limb nShip,2
        inc nShipMoveX#,0.01
        dec nFuel,1        
    endif
    
    if leftkey()=1 AND nFuel > 0
        show limb nShip,3
        dec nShipMoveX#,0.01
        dec nFuel,1
    endif
    
    if (upkey()=1 OR downkey()=1) AND nFuel > 0
        show limb nShip,1
        dec nShipMoveY#,0.04
        dec nFuel,2
        if nFuel < 0 then nFuel = 0
    endif
    
    inc nShipMoveY#,0.025
    if nShipMoveY# > 5.0 then nShipMoveY#=5.0
    nShipX# = nShipX# + nShipMoveX#
    nShipY# = nShipY# - nShipMoveY#
    if nShipY# < nGroundY# then nShipY# = nGroundY#
    position object nShip,nShipX#,nShipY#,90
    
    for s = 1 to 3
        move object right Slug(s).object,Slug(s).move
        if object position x(Slug(s).object) > 100 then Slug(s).move = -.5 + (s * 0.1)
        if object position x(Slug(s).object) < -100 then Slug(s).move = .5 + (s * 0.1)
        if rnd(2000) = 1 then Slug(s).move = Slug(s).move * -1
    next s
    
    gosub displaystats   
    sync
    if nShipY# <= nGroundY# then gosub endgame    
loop
` ***************************
displaystats:
set text size 20
ink 0xFFFFFFFF,0
text 15,10,str$(object position y(nShip)+83,3)+" altitude"
text 15,30,str$(nShipMoveY#,3)+" descent velocity"
lv$=str$(abs(nShipMoveX#),3)
if left$(lv$,1)="-" then lv$=right$(lv$,len(lv$)-1)
text 15,50,lv$+" lateral velocity"
f$=str$(nFuel)
if nFuel<1000 then f$=" "+f$
if nFuel<100 then f$=" "+f$
if nFuel<10 then f$=" "+f$
text 15,70," "+f$+" lbs fuel remaining"
ink 0xFFFFFFFF,0

for y = 100 to 200 step 10
    line 20,y,70,y
next y

line 20,100,20,200
line 70,100,70,200
ink 0xFF000000,0
box 23,96,67,202
ink 0xFF555555,0
box 25,100,65,200
if nFuel>499 then ink 0xFF00FF00,0
if nFuel<500 and nFuel>199 then ink 0xFFFFFF00,0
if nFuel<200 then ink 0xFFFF0000,0
box 25,200-nFuel/10,65,200 
return
` ***************************
endgame:
hide limb nShip,1
hide limb nShip,2
hide limb nShip,3
Game$="CRASHED on stage "+str$(nRound)+"!"
Round$="to try again"
nShipX# = object position x(nShip)
nTouch = 0

for s = 1 to 3
    nSlugX# = object position x(Slug(s).object)
    nDistance# = abs(nShipX#-nSlugX#)
    if nDistance# < 27.0 AND Slug(s).active = 1 then nTouch = s
next s

if abs(nShipMoveY#) <= 0.50 AND abs(nShipMoveX#) <= 0.05
    Game$="Good landing on stage "+str$(nRound)+"!"
    inc nRound
    Round$="for stage "+str$(nRound)
endif

if abs(nShipMoveY#) = 0.0 AND abs(nShipMoveX#) = 0.0
    Game$="PERFECT on stage "+str$(nRound)+"!"    
endif

if nTouch <> 0 AND left$(Game$,7) <> "CRASHED"
    Game$="YOU TOUCHED A SLUG!"
    Round$="to try again"
    dec nRound
endif

do
    gosub displaystats
    ink 0xFFFFFFFF
    set text size 50    
    center text 400,250,Game$
    set text size 30
    center text 400,300,"press SPACEBAR "+Round$
    center text 400,330,"or ESC to exit"

    sync
    
    if spacekey()
        gosub setupvars
        return
    endif

loop

return
` ***************************
splashscreen:
position object nShip,-17.0,4.0,-60.0
position object nSlug,0,-87.9,89.99
show object nSlug
set alpha mapping on nShip,0
set alpha mapping on nText,0
set alpha mapping on nSlug,0
nSlugMove# = 0.005

for alpha = 0 to 255 step 4
    set alpha mapping on nShip,alpha
    set alpha mapping on nText,alpha
    set alpha mapping on nSlug,alpha
    wait 1
next alpha

set alpha mapping on nShip,255
set alpha mapping on nText,255
set alpha mapping on nSlug,255

while spacekey()=0
    hide limb nShip,1
    hide limb nShip,2
    hide limb nShip,3
    
    if upkey()=1 OR downkey()=1
        show limb nShip,1
    endif
    
    if leftkey()=1
        show limb nShip,3
    endif
    
    if rightkey()=1
        show limb nShip,2
    endif    
    
    move object right nSlug,nSlugMove#
    if object position x(nSlug)>150 then nSlugMove# = -.005
    if object position x(nSlug)<-140 then nSlugMove# = .005
    if rnd(2000)=1 then nSlugMove# = nSlugMove# * -1
endwhile

for alpha = 255 to 0 step -4
    set alpha mapping on nShip,alpha
    set alpha mapping on nText,alpha
    wait 1
next alpha

set alpha mapping on nText,0
set alpha mapping on nShip,255
return
` ***************************
setupvars:
nFuel=1025-nRound*25
if nFuel<500 then nFuel=500
nShipX#=-140.0+rnd(280)
nShipY#=125.0
nSlugY#=-87.9
nGroundY#=-83.0

if nShipX# < 0
    nShipMoveX# = rnd(10)/10.0
else
    nShipMoveX# = (rnd(10)/10.0)*-1.0
endif

for s = 1 to 3    
    Slug(s).move = 0.3 + (s * 0.1)    
    if rnd(1)=0 then Slug(s).move = Slug(s).move * -1
    position object Slug(s).object,0.0,nSlugY#,89.99 - (s * 0.001)
    hide object Slug(s).object
    Slug(s).active = 0
next s

Slug(1).active = 1
show object Slug(1).object

if nRound > 3
    Slug(2).active = 1
    show object Slug(2).object
endif

if nRound > 6
    Slug(3).active = 1
    show object Slug(3).object
endif

nShipMoveY#=0.01
position object nShip,nShipX#,nShipY#,90.0
return
` ***************************
drawgraphics:
nShip = 1
nStars = 2
nText = 3
nCrater = 4
nJet = 5
nEye = 6
nThruster = 7
nSlug = 8

type mySlug
    object as integer
    move as float
    active as integer
endtype

dim Slug(3) as mySlug

set bitmap format 21
create bitmap 1,800,600
cls 0

ink 0xFFFFFFFF,0
for r = 0 to 41
    ellipse 420,350,r,20    
next r

ink 0xFF020202,0

for r = 0 to 20
    circle 420,350,r
    circle 420,349,r
next r

get image nEye,380,330,460,370,1

for s = 1 to 3
    rBase = 150
    gBase = 150
    bBase = 150
    
    select s
        case 1
            gBase = 200
        endcase
        case 2
            rBase = 200
            bBase = 200
        endcase
        case 3
            bBase = 200
        endcase
    endselect
    
    x# as float
    
    for n = 100 to 440
        ink rgb(rBase-(n/4),gBase-(n/4),bBase-(n/4)),0
        x# = n
        y = sin(x#)*100
        line x#+150,y+screen width()/2,x#+150,500
    next n
    
    paste image nEye,380,330,1       
    get image s+7,250,301,590,500,1

next s

cls 0

for x = 0 to 16
    ink rgb(255,x*15,0),0
    line x,0,16,64
    line 32-x,0,16,64
next x

get image nJet,0,0,32,64,1
cls 0

for x = 0 to 16
    ink rgb(x*15,x*15,x*15),0
    line x,0,16,64
    line 32-x,0,16,64
next x

get image nThruster,0,0,32,64,1
cls 0

set text font "Courier New"
set text size 100
ink 0xFFFFFFFF,0
center text 400,50,"Looney"
center text 400,140,"Lander"
set text size 40
center text 400,235,"written by"
set text size 40
center text 400,270,"Rich Dersheimer"
center text 400,320,"Use arrow keys"
center text 400,350,"to fire engines"
center text 400,400,"Avoid moonslugs"
center text 400,460,"SPACE to start"
get image nText,220,50,580,500,1
cls 0
ellipse 400,300,20,10
ink 0xFF444444,0
ellipse 400,400,20,10
ink 0xFF000000,0
box 386,390,422,402
get image nCrater,380,390,420,410,1
paste image nCrater,380,290,1
paste image nCrater,381,290,1
get image nCrater,380,290,420,310,1
ink 0xFF888888,0
box 0,550,800,600
paste image nCrater,10,560,1
paste image nCrater,80,575,1
paste image nCrater,150,556,1
paste image nCrater,280,560,1
paste image nCrater,370,570,1
paste image nCrater,420,578,1
paste image nCrater,530,556,1
paste image nCrater,630,566,1
paste image nCrater,720,557,1
ink 0xFF000000,0
box 0,0,800,550
ink 0xFFFFFFFF,0

for x = 1 to 500
    circle rnd(800),rnd(540),(rnd(10)+1)/6.0
next x

get image nStars,0,0,800,600,3
cls 0

for x = 0 to 8
    ink rgb(255-x*15,255-x*15,255-x*15),0
    line 55+x,300,105+x,200
    line 244-x,200,294-x,300
    line 80,255+x,190,255+x
    line 240,255+x,270,255+x
    line 40+x,300+x,80-x,300+x
    line 270+x,300+x,310-x,300+x
    line 150-x,276+x,200+x,276+x
next x

ink 0xFF555555,0
box 100,200,250,275
ink 0xFFDDDDDD,0
box 102,202,128,273
ink 0xFFBBBBBB,0
box 130,202,218,273
ink 0xFF999999,0
box 220,202,248,273
ink 0xFF777777,0
box 140,190,210,200
ink 0xFF555555,0
box 130,70,220,190
box 100,100,250,160
ink 0xFFBBBBBB,0
box 132,103,218,158

for x = 0 to 30
    ink 0xFFDDDDDD,0
    line 100+x,100-x,130,100-x
    line 100+x,160+x,130,160+x
    line 99+x,103,99+x,158
    ink 0xFFBBBBBB,0
    line 132,70+x,218,70+x
    line 132,160+x,218,160+x
    ink 0xFF999999,0
    line 220,100-x,250-x,100-x
    line 220,160+x,250-x,160+x
    line 220+x,103,220+x,158
    ink 0xFF223322,0
    line 150-x*0.5,138-x,200+x*0.5,138-x
next x

ink 0xFFBBBBBB,0
box 165,104,185,150
ink 0xFFAA0000,0
box 140,212,210,251
ink 0xFFFFFFFF,0

for y = 215 to 248 step 6
    box 140,y,210,y+3
next x

ink 0xFF000088,0
box 140,212,170,233
ink 0xFFFFFFFF,0

for y = 0 to 4
    for x = 0 to 5
        circle 142+x*5,214+y*4,0.8
    next x
    if y < 4
        for x = 0 to 4
            circle 145+x*5,216+y*4,0.8  
        next x
    endif
next y

get image nShip,40,70,310,310,0
set current bitmap 0

make object plane nStars,800,600
texture object nStars,nStars
set object emissive nStars,0xFFFFFFFF
position object nStars,0,0,399

make object plane nShip,27,24
texture object nShip,nShip
set object texture nShip,2,0

make object plane nJet,6,8
make mesh from object 1,nJet
delete object nJet
add limb nShip,1,1
offset limb nShip,1,0.0,-13.5,0.0
texture limb nShip,1,nJet
hide limb nShip,1

make object plane nJet,2,3
make mesh from object 2,nJet
delete object nJet
add limb nShip,2,2
offset limb nShip,2,9.2,6,0
rotate limb nShip,2,0.0,0.0,-90.0
texture limb nShip,2,nThruster
hide limb nShip,2

make object plane nJet,2,3
make mesh from object 3,nJet
delete object nJet
add limb nShip,3,3
offset limb nShip,3,-9.2,6,0
rotate limb nShip,3,0.0,0.0,90.0
texture limb nShip,3,nThruster
hide limb nShip,3

set object transparency nShip,1
set object emissive nShip,0xFFFFFFFF

make object plane nText,360,450
texture object nText,nText
set object emissive nText,0xFFFFFFFF
set object transparency nText,1
lock object on nText
position object nText,150,50,499

for nObject = 8 to 10
    Slug(nObject-7).object = nObject
    Slug(nObject-7).active = 0   
    make object plane nObject,30,15
    texture object nObject,nObject
    set object emissive nObject,0xFFFFFFFF
    set object transparency nObject,1
    yrotate object nObject,180
    fix object pivot nObject
    hide object nObject
next nObject

color backdrop 0
position camera 0,0,-100
point camera 0,0,0
return

REM ===============================================
REM Title: Looney Lander Challenge
REM Author: Phaelax
REM Date: March 31, 2011
REM ===============================================

set display mode 1024, 768, 32

randomize timer()

#CONSTANT SFX_EXPLODE = 1
#CONSTANT SFX_THRUST = 2


Global GRAV# = 0.01
Global FUEL = 1000
#CONSTANT EPSILON = 0.01
#CONSTANT WHITE = rgb(255,255,255)
#CONSTANT BROWN = rgb(50,30,1)
REM ==== start variables for terrain ========================
Global DEPTH = 5
numOfPts = 2^DEPTH + 1
Global PT_COUNT = numOfPts
Global LANDING_POINT = 0
Global LANDING_WIDTH = 0
Global LANDING_SEGS = 3
dim points(numOfPts,2)
REM ==== end terrain variables ==============================

REM Background stars
#CONSTANT STARCOUNT = 200
dim stars(STARCOUNT, 3) as float
for i = 1 to STARCOUNT
	stars(i, 1) = rnd(screen width())
	stars(i, 2) = rnd(screen height())
	select rnd(2)
		case 0 : stars(i, 3) = 0.2 : endcase
		case 1 : stars(i, 3) = 0.4 : endcase
		case 2 : stars(i, 3) = 0.6 : endcase
	endselect
next i


dim msg$(5)
msg$(1) = "Perfect!"  : ` < 0.3
msg$(2) = "Rough Landing" : ` 0.4 > 0.7
msg$(3) = "You got lucky!" : ` 0.7 > 1.0
msg$(4) = "Too hard!" : ` > 1.0
msg$(5) = "Kamikaze!" : ` >= 1.5

dim platform(6,2)

Type ShipObject
	x as float
	y as float
	vx as float
	vy as float
	thrust as float
EndType

ship as ShipObject
ship.thrust = 0.04
ship.x = 200 : ship.y = 133

`drawShip(32, 40)
`get image 1, 0, 0, 64, 57, 1
`sprite 1, 0, 0, 1 : hide sprite 1
`offset sprite 1, 32, 40
drawShip2(32, 44)
get image 1, 0, 0, 64, 61, 1
sprite 1, 0, 0, 1 : hide sprite 1
offset sprite 1, 32, 44


rem build a random lunar map
buildRandomMap(1)

`frequency#,length#,loudness#,bend#,decay#,vibratospeed#,vibratodepth#,tremelospeed#,tremelodepth#,attack#

createsound("explosion",SFX_EXPLODE,300,3000,3500,2,0.1,0.05,0,0,0,10)
createsound("thrust",SFX_THRUST,500,41,4000,0.25,8.60,1.00,1,0.0,0,5.82)


REM ==== start fire/thrust particles ==============================
Type Particle
	x as float
	y as float
	sx as integer
	sy as integer
	vx as float
	vy as float
	alpha as integer
	color as dword
EndType

dim fire(200) as Particle
dim firePalette(4) as dword
firePalette(0) = rgb(255,0,0)
firePalette(1) = rgb(96,0,0)
firePalette(2) = rgb(255,128,0)
firePalette(3) = rgb(180,90,0)
firePalette(4) = rgb(200, 200, 0)

ink rgb(0,0,0), 0
box 0, 0, 20, 20
ink rgb(255,255,255),0
E2DC_Fill_Circle(10, 10, 10)
get image 4, 0, 0, 20, 20
sprite 4, 0, 0, 4 : size sprite 4, 4, 4 : offset sprite 4, 2, 2 : hide sprite 4
set sprite 4, 0, 1

for i = 1 to 200
	clone sprite 4, i+4
	hide sprite i+4
next i
REM ==== end fire/thrust particles ==============================


dim shipBlow(40, 40) as Particle


hide mouse
sync on
sync rate 60

do
	cls
	
	rem background sky
	box 0, 0, 1024, 768, rgb(0,41,63),rgb(0,23,35),rgb(0,41,63),rgb(0,23,35)
	
	gosub Controls
	
	rem add gravity to ship's vertical velocity
	inc ship.vy, GRAV#
		
	
	rem cheap form of wind resistance, pushes
	rem horizontal movement back to 0 velocity
	if ship.vx > 0 then dec ship.vx, 0.01
	if ship.vx < 0 then inc ship.vx, 0.01
	if abs(ship.vx) < EPSILON then ship.vx = 0
		

	rem check landing
	if ship.y+16 >= points(LANDING_POINT, 2)-1
		if ship.x-28 >= points(LANDING_POINT, 1) and ship.x+28 <= points(LANDING_POINT+LANDING_SEGS-1, 1)
			ship.y = points(LANDING_POINT, 2)-17
			if hasLanded# = 0 then hasLanded# = abs(ship.vy)+abs(ship.vx)
			if thrust = 0 then ship.vy = 0
		endif
	endif
	
	rem add velocity forces to ship's current position
	inc ship.x, ship.vx
	inc ship.y, ship.vy
	
	rem rotate ship
	t# = ship.vx/1.5
	if t# > 1 then t# = 1
	if t# < -1 then t# = -1
	a# = 20*t#
	rotate sprite 1, a#
	


	gosub doCollision
	
	
	
	gosub starBackground
	
	
	rem platform image
	paste image 3, 150, 150, 1
	
	
	
	rem check landing
	if hasLanded# > 0 and dead = 0
		if hasLanded# > 1.0
			dead = doDeath()
		else
			` successful landing
		endif
	endif
	

	
	rem controls fire/thrust particles
	gosub handleThrustParticles



	rem draw the mountains image
	paste image 2, 0, screen height()-500, 1
	
	
	
	rem draw landing pad
	gosub drawLandingPad
	
	
	
	if dead = 0
		rem draw the ship
		paste sprite 1, ship.x, ship.y
	else
		tt# = doDeathEffect(tt#)
		if tt# >= 50 then dead = 0 : tt# = 0 : hasLanded# = 0
	endif
	
	
	
	`dec rx, 2
	`inc rot#, 0.5
	`if rx <= 0 then rx = 1124 : ry = rnd(screen height())
	`DrawPolyCircle(rx, ry, 60, 5, rot#)
	
	
	
	rem Fuel meter
	healthBar(412, 10, 200, 30, FUEL/1000.0)
	ink 0, 0
	center text 513, 19, "Fuel"
	ink WHITE, 0
	center text 512, 18, "Fuel"
	
	
	text 645, 10, "(F1)Easy  (F2)Medium  (F3)Hard  (F4)Expert"

	

	if hasLanded# > 0
		center text screen width()/2, 40, getLandingMessage$(hasLanded#)
	endif
	
	set cursor 0,0
	print screen fps()
	print "Landed: ", hasLanded#
	print "VX: ", ship.vx
	print "VY: ", ship.vy
		
	
	sync
loop






REM ===============================================
REM Player's controls
REM ===============================================
Controls:
	rem player controls
	thrust = 0
	if dead = 0
		if upkey() and FUEL > 0
			dec FUEL
			thrust = 1
			dec ship.vy, ship.thrust
			if ship.vy < -1.5 then ship.vy = -1.5
			if sound playing(SFX_THRUST) = 0 then play sound SFX_THRUST
		endif
		
		if ship.vy <> 0
			if rightkey()
				inc ship.vx, ship.thrust
			endif
			if leftkey()
				dec ship.vx, ship.thrust
			endif
		endif
	endif
	
	rem Star a new game
	rem F1 = easy, F2 = medium, F3 = hard, F4 = Expert
	if scancode() = 59 and flag = 0 then buildRandomMap(1) : flag = 1 : hasLanded# = 0
	if scancode() = 60 and flag = 0 then buildRandomMap(2) : flag = 1 : hasLanded# = 0
	if scancode() = 61 and flag = 0 then buildRandomMap(3) : flag = 1 : hasLanded# = 0
	if scancode() = 62 and flag = 0 then buildRandomMap(4) : flag = 1 : hasLanded# = 0
	if scancode() = 0 then flag = 0
RETURN



REM ===============================================
REM Moves stars in background
REM ===============================================
starBackground:
	rem draw stars
	for i = 1 to STARCOUNT
		select stars(i, 3)
			case 0.2 : ink rgb(96,96,96),0 : endcase
			case 0.4 : ink rgb(200,200,200),0 : endcase
			case 0.6 : ink rgb(255,255,255),0 : endcase
		endselect
		box stars(i, 1), stars(i, 2), stars(i, 1)+1, stars(i, 2)+1
		stars(i, 2) = stars(i, 2) - stars(i, 3)
		if stars(i, 2) < 0 then stars(i, 2) = screen height() : stars(i, 1) = rnd(screen width())
	next i
RETURN



REM ===============================================
REM Handles collision between the ship's landing
REM feet and the terrain
REM ===============================================
doCollision:
	rem calculate positions of landing feet
	x1 = ship.x + sin(118+a#)*32.249
	y1 = ship.y - cos(118+a#)*32.249
	
	x2 = ship.x - sin(62+a#)*32.249
	y2 = ship.y + cos(62+a#)*32.249
	

	rem screen boundaries
	if ship.x > screen width()+21 then ship.x = -20
	if ship.x < -20 then ship.x = screen width()+20
		

	rem check collision
	for t = 1 to PT_COUNT-1		
		rem check if ship's left leg is within this terrain segment's region
		if x2 >= points(t, 1) and x2 <= points(t+1, 1)
			y# = getHeight#(x2)
			rem if ship hit ground
			if y2 >= y#
				ship.vy = 0
				ship.y = y#-16
				dead = doDeath()
			endif
		endif
		rem check if ship's right leg is within this terrain segment's region
		if x1 >= points(t, 1) and x1 <= points(t+1, 1)
			y# = getHeight#(x1)
			rem if ship hit ground
			if y1 >= y#
				ship.vy = 0
				ship.y = y#-16
				dead = doDeath()
			endif
		endif
	next t
	
	rem starting platform
	if (y1 >= 149 or y2 >= 149) and (y1 < 150 and y2 < 150)
		if x1 >= 150 and x2 <= 250
			ship.y = 133
			ship.vy = 0
		else
			dead = doDeath()
		endif
	endif
	
	Rem platform collision with ship's dome
	gosub platformCollision
	
RETURN



REM ===============================================
REM Handles collision between the ship's dome and
REM the platform
REM ===============================================
platformCollision:
	for i = 0 to 6
		ax = 150+platform(i,1)
		ay = 150+platform(i,2)
		if i < 6
			bx = 150+platform(i+1,1)
			by = 150+platform(i+1,2)
		else
			bx = 150+platform(0,1)
			by = 150+platform(0,2)
		endif
		
		rem with ship's dome
		x = bx - ax
		y = by - ay
		n = (ship.x-ax)*x + ((ship.y-22)-ay)*y
		d# = x^2 + y^2
		u# = n / d#
		
		if u# >= 0 and u# <= 1
			ix = ax + (bx-ax)*u#
			iy = ay + (by-ay)*u#
			e = ship.x - ix
			f = (ship.y-22) - iy
			d = e^2 + f^2
			if d <= 400 and dead = 0
				dead = doDeath()
            endif
		endif
	next i
RETURN



REM ===============================================
REM Draw and animate the landing pad
REM ===============================================
drawLandingPad:
	ink 0, 0
	box points(LANDING_POINT,1),points(LANDING_POINT,2), points(LANDING_POINT+LANDING_SEGS-1,1),points(LANDING_POINT+LANDING_SEGS-1,2)+3
	inc r#, 0.5
	if r# > LANDING_WIDTH-3 then r# = 0
	ink rgb(255,255,0),0
	box points(LANDING_POINT, 1)+LANDING_WIDTH-r#, points(LANDING_POINT, 2), points(LANDING_POINT, 1)+LANDING_WIDTH-r#+3, points(LANDING_POINT, 2)+3
	box points(LANDING_POINT, 1)+LANDING_WIDTH+r#, points(LANDING_POINT, 2), points(LANDING_POINT, 1)+LANDING_WIDTH+r#+3, points(LANDING_POINT, 2)+3
RETURN



REM ===============================================
REM handles the fire/thrust particles
REM ===============================================
handleThrustParticles:
	for i = 1 to 200
		d = (fire(i).x-fire(i).sx)^2 + (fire(i).y-fire(i).sy)^2
		if d >= 30*30 or fire(i).vy = 0
			if thrust = 1
				fire(i).x = ship.x + rnd(20)-10
				fire(i).y = ship.y
				fire(i).sx = ship.x
				fire(i).sy = ship.y
				fire(i).alpha = 255
				fire(i).color = firePalette(rnd(4))
				set sprite diffuse i+4, rgbr(fire(i).color), rgbg(fire(i).color), rgbb(fire(i).color)
				a = rnd(40)-20 - sprite angle(1)
				v# = (rnd(20)+10) / 10.0
				fire(i).vx = sin(a)*v#
				fire(i).vy = cos(a)*v#
			else
				fire(i).vy = 0
			endif
		else
			inc fire(i).x, fire(i).vx
			inc fire(i).y, fire(i).vy
			t# = (900-d) / 900.0
			fire(i).alpha = 128*t#
			if fire(i).alpha < 0 then fire(i).alpha = 0 : fire(i).vy = 0
		endif
		if fire(i).vy <> 0
			set sprite alpha i+4, fire(i).alpha
			paste sprite i+4, fire(i).x, fire(i).y
		endif
	next i
RETURN



REM ===============================================
REM begin the death process
REM ===============================================
function doDeath()
	initDeathParticles()
	play sound SFX_EXPLODE
	ship.x = 200 : ship.y = 133
	ship.vx = 0 : ship.vy = 0
endfunction 1



REM ===============================================
REM Animates death explosion particles
REM ===============================================
function doDeathEffect(t#)
	lock pixels
	for x = 1 to 40
		for y = 1 to 40
			px = shipBlow(x,y).x + shipBlow(x,y).vx*cos(shipBlow(x,y).alpha)*t#
			py = shipBlow(x,y).y + shipBlow(x,y).vx*sin(shipBlow(x,y).alpha)*t# + 0.5*2*t#^2
			E2DC_Dot(px,py,rgb(200,200,230))
		next y
	next x
	unlock pixels
	t# = t# + 0.5
	if t# >= 50
		`t# = 0
		dead = 0
		FUEL = 1000
	endif
endfunction t#



REM ===============================================
REM initializes particles for death explosion
REM ===============================================
function initDeathParticles()
	for x = 1 to 40
        for y = 1 to 40
            shipBlow(x,y).x = ship.x+x-20
            shipBlow(x,y).y = ship.y+y-42
            shipBlow(x,y).alpha = rnd(180)+180
            shipBlow(x,y).vx = rnd(10)+5
        next y
    next x
endfunction



REM ===============================================
REM Determine successfullnes of landing
REM ===============================================
function getLandingMessage$(landingValue#)
	t$ = "Out of range"
	if landingValue# <= 0.3 then t$ = msg$(1)
	if landingValue# > 0.3 and landingValue# <= 0.7 then t$ = msg$(2)
	if landingValue# > 0.7 and landingValue# <= 1.0 then t$ = msg$(3)
	if landingValue# > 1.0 and landingValue# < 1.5 then t$ = msg$(4)
	if landingValue# >= 1.5 then t$ = msg$(5)
endfunction t$



REM ===============================================
REM Draws the lunar lander
REM ===============================================
function drawShip(x, y)
	ink rgb(255,255,255),0
	rem top
	DrawPolyCircle(x, y-20, 20, 6, 90)
	rem base
	box x-20, y-10, x+20, y
	rem left leg
	line x-20, y-5,  x-28, y+8
	line x-16, y,    x-28, y+8
	line x-28, y+8,  x-28, y+16
	line x-32, y+16, x-24, y+16
	rem right leg
	line x+20, y-5,  x+28, y+8
	line x+16, y,    x+28, y+8
	line x+28, y+8,  x+28, y+16
	line x+32, y+16, x+24, y+16
endfunction



REM ===============================================
REM Draws the lunar lander
REM ===============================================
function drawShip2(x, y)
	rem top
	gradientFillCircle(x, y-22,20,x-6, y-30,30,rgb(229,241,243),rgb(123,162,194))
	E2DC_Circle_AA_Alpha(x, y-22, 20, rgb(123,162,194))
	E2DC_Circle_AA_Alpha(x, y-22, 20, rgb(123,162,194))
	
	rem left leg
	E2DC_Line_AA_ALPHA(x-20, y-5,  x-28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-16, y,    x-28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-28, y+8,  x-28, y+16 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-32, y+16, x-24, y+16 ,rgb(200,200,200))
	
	rem right leg
	E2DC_Line_AA_ALPHA(x+20, y-5,  x+28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+16, y,    x+28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+28, y+8,  x+28, y+16 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+32, y+16, x+24, y+16 ,rgb(200,200,200))
	
	rem base
	box x-22, y-12, x+22, y, rgb(237,237,237),rgb(237,237,237),rgb(100,100,100),rgb(100,100,100)
endfunction



REM ===============================================
REM Draw polygon with center at [x,y] and
REM a radius of 'r' with 'segs' number of
REM segments and rotated at 'Rot#' angle
REM ===============================================
function DrawPolyCircle(x,y,r,segs,Rot#)
	AngStep# = 360.0 / segs
	Ang# = Rot#
	For s = 1 To segs
		OldAng# = Ang#
		Ang# = Ang# + AngStep#
		x1 = x + (r * Sin(Ang#))
		y1 = y + (r * Cos(Ang#))
		x2 = x + (r * Sin(OldAng#))
		y2 = y + (r * Cos(OldAng#))
		line x1,y1,x2,y2
	Next s
endfunction



REM ===============================================
REM Creates a random terrain
REM ===============================================
function buildRandomMap(difficulty)
	rem set begin and end points
	points(1,2) = screen height()-120
	points(PT_COUNT,2) = screen height()-120
	
	segLength = screen width() / (PT_COUNT-1)
	for i = 1 to PT_COUNT
		points(i, 1) = (i-1)*segLength
	next i

	
	rem call the midpoint displacement function
	midpoint(points(1,1),points(1,2),points(PT_COUNT,1),points(PT_COUNT,2),screen height()-50,500,0.6,DEPTH,1,PT_COUNT)
	rem smooth the terrain
	smooth(4)
	rem set landing point
	LANDING_POINT = rnd(PT_COUNT-4)+1
	rem set landing pad length
	if difficulty = 1 : LANDING_SEGS = 4 : else : LANDING_SEGS = 3 : endif
	
	rem flatten landing pad
	for i = 1 to LANDING_SEGS-1
		points(LANDING_POINT+i, 2) = points(LANDING_POINT, 2)
	next i
	
	
	rem easy
	if difficulty = 1
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) + (rnd(40)+40)
		if LANDING_POINT+LANDING_SEGS <= PT_COUNT then points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) + (rnd(40)+40)
		GRAV# = 0.01
	endif
	rem medium
	if difficulty = 2
		GRAV# = 0.01
	endif
	rem hard
	if difficulty = 3
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) - (rnd(40)+40)
		points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) - (rnd(40)+40)
		GRAV# = 0.02
	endif
	rem expert
	if difficulty = 4
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) - (rnd(50)+100)
		points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) - (rnd(50)+100)
		GRAV# = 0.03
	endif
		
	
	FUEL = 1000
	LANDING_WIDTH = (points(LANDING_POINT+LANDING_SEGS-1, 1)-points(LANDING_POINT, 1)) / 2
	ship.x = 200 : ship.y = 133
	ship.vx = 0 : ship.vy = 0
	
	cls
	drawPlatform()
	if image exist(3) then delete image 3
	get image 3, 0, 0, 100, 70, 1

	
	cls
	drawTerrain()
	blur bitmap 0, 2
	if image exist(2) then delete image 2
	get image 2, 0, screen height()-500, screen width(), screen height(), 1
endfunction



REM ===============================================
REM Draws the terrain previously created by 
REM buildRandomTerrain()
REM ===============================================
function drawTerrain()
	segLength# = screen width() / (PT_COUNT-1)
	
	for t = 1 to PT_COUNT-1
		rem fill the terrain
		ink BROWN,0
		
		y2 = max(points(t, 2), points(t+1, 2))
		for x = points(t,1) to points(t+1,1)
			t# = (x - points(t, 1)) / segLength#
			y = points(t, 2) + (points(t+1, 2)-points(t, 2))*t#
			ink BROWN,0
			box x, y, x+1, screen height()
			`ink rgb(60,36,1),0
			
			
			
			for i = y to screen height()
			
				if rnd(1) = 1
					h# = (screen height() - y)
					r# = (h#-(screen height() - i)) / h#
					`if r# < 0 then r# = 0
					`if r# > 1 then r# = 1
					c = getTransitionalColor(rgb(138,83,5), BROWN, r#)
					ink c, 0
					box x, i, x+1, i+1
				endif
			next i
		next x
		`box points(t,1),y2, points(t+1,1),screen height()
	next t
	
	rem show landing score
	ink WHITE, 0
	center text points(LANDING_POINT, 1)+LANDING_WIDTH, points(LANDING_POINT+1, 2)+4, "10"
endfunction



REM ===============================================
REM Draws a randomly-shaped platform
REM ===============================================
function drawPlatform()
	tx = 0 : ty = 0
	for i = 0 to 5
		ax = 10+i*18
		ay = 50+(rnd(40)-20)
		if i = 5 then ax = 99 : ay = 3
		
		platform(i,1) = tx : platform(i,2) = ty
		
		ink BROWN, 0
		for j = tx to ax
			l# = ax-tx
			t# = (j-tx)/l#
			k = ty + (ay-ty)*t#
			box j, 0, j+1, k
		next j
		
		tx = ax : ty = ay
	next i
	platform(i,1) = tx : platform(i,2) = ty
endfunction



REM ===============================================
REM recursive method using midpoint displacement
REM (x1,y1)    - starting point of line
REM (x2,y2)    - ending point of line
REM baseline   - the base or ground of where the points start
REM height#    - places midpoint Y-coord randomly between 0 and height#
REM h#         - 0 < h# <= 1 : higher makes a very ridged line, lower makes smoother
REM depth      - how many times should the line be split
REM arr1       - used for storing values in array
REM arr2       - used for storing values in array
REM ===============================================
function midpoint(x1,y1,x2,y2,baseline,height#,h#,depth, arr1,arr2)
   y = baseline - rnd(height#)
   arrIndex = arr1 + (arr2-arr1)/2

   points(arrIndex,2) = y

   dec depth, 1

   if depth > 0
      midpoint(x1,y1,x,y,baseline,height#*h#,h#,depth,arr1,arrIndex)
      midpoint(x,y,x2,y2,baseline,height#*h#,h#,depth,arrIndex,arr2)
   endif
endfunction



REM ===============================================
REM Smooths out terrain
REM ===============================================
function smooth(factor)
	rem define an array to temporarily store the points.
	local dim temp(PT_COUNT)
	
	for k = 1 to factor
		for i = 2 to PT_COUNT - 1
			y = points(i,2)
			y1 = points(i-1,2)
			y2 = points(i+1,2)
			temp(i) = (y+y1+y2)/3
		next i
		
		for i = 2 to PT_COUNT - 1
			points(i,2) = temp(i)
		next i
	next k
endfunction



REM ===============================================
REM Returns the height on the terrain at point X
REM ===============================================
function getHeight#(x as float)
	mapWidth# = points(PT_COUNT, 1) - points(1, 1)
	segLength# = mapWidth# / (PT_COUNT-1)
	p1 = ceil(x / segLength#)
	if p1 = 0 then p1 = 1
	p2 = p1+1
	
	t# = (x - points(p1, 1)) / segLength#
	h# = points(p1, 2) + (points(p2, 2)-points(p1, 2))*t#
endfunction h#



REM ===============================================
REM x,y is the upper left corner of meter
REM P# ranges from 0 to 1
REM ===============================================
function healthBar(x, y, width, height, P#)
   rem gradient bar
   seg = width / 3
   box x, y, x+seg, y+height, rgb(255,0,0),rgb(255,0,0),rgb(255,128,0),rgb(255,128,0)
   box x+seg, y, x+seg+seg, y+height, rgb(255,128,0),rgb(255,128,0), rgb(255,255,0),rgb(255,255,0)
   box x+seg+seg, y, x+width, y+height, rgb(255,255,0),rgb(255,255,0), rgb(0,255,0),rgb(0,255,0)
   
   rem empty bit
   ink rgb(0,24,35),0
   box x+width*P#, y, x+width, y+height
   
   rem highlight
   c1 = 0xCCFFFFFF
   c2 = 0x33FFFFFF   
   box x, y, x+width, y+height*0.5, c2,c1,c2,c1
endfunction



REM **************************************************
REM Gracefully swiped from Ric!
REM **************************************************
function createsound(name$,soundnumber,frequency#,length#,loudness#,bend#,decay#,vibratospeed#,vibratodepth#,tremelospeed#,tremelodepth#,attack#)

   outWord as word
   dword1 as dword: dword2 as dword: dword3 as dword: dword4 as dword
   dword5 as dword: dword6 as dword: dword7 as dword

   samples=int((length#/1000)*44100)

   if memblock exist(1) then delete memblock 1
   make memblock 1,samples*2+28

   ` write 28 memblock header bytes
   dword1=1      ` gg query: is this the number of channels?
   dword2=2      ` gg query: is this the number of bytes per sample?
   dword3=22050  ` gg query: seems to be half the number of samples per second - why?
   dword4=88200  ` gg query: is this the number of bytes per second?
   dword5=4      ` gg query: what does this represent?
   dword6=16     ` gg query:     (ditto)            ?
   dword7=0      ` gg query:     (ditto)            ?

   position=0
   write memblock dword 1, position, dword1 : inc position,4
   write memblock dword 1, position, dword2 : inc position,4
   write memblock dword 1, position, dword3 : inc position,4
   write memblock dword 1, position, dword4 : inc position,4
   write memblock dword 1, position, dword5 : inc position,4
   write memblock dword 1, position, dword6 : inc position,4
   write memblock dword 1, position, dword7 : inc position,4

   rem generate and write wave
   riseinloudness#=loudness#
   for x=1 to samples
      outInteger=int(sin((x/122.5)*(frequency#+vibratodepth#*sin(theta#)))*(loudness#-fallinloudness#-riseinloudness#+tremelodepth#*sin(phi#)))*3.0
      if outInteger <-32767 then outInteger=-32767  ` gg query: is this the valid range?
      if outInteger>32767 then outInteger=32767     ` gg query:       (ditto)          ?
      outWord=outInteger
      inc theta#,vibratospeed#
      inc phi#,tremelospeed#
      dec frequency#,bend#

      if fallinloudness#<loudness#
         inc fallinloudness#,decay#
      endif

      if riseinloudness#>0
         dec riseinloudness#,attack#
      endif

      write memblock word 1, position, outWord : inc position,2
   next x

   if sound exist(soundnumber)=1 then delete sound soundnumber

   make sound from memblock 999, 1
   clone sound soundnumber, 999

   delete sound 999
   ` memblock no longer required
   delete memblock 1

endfunction



REM ***********************************************************************************************
REM ***********************************************************************************************
REM 
REM	                                    ENHANCED 2D COMMANDS
REM
REM ***********************************************************************************************
REM ***********************************************************************************************



REM **************************************************
REM Fills circle with center [cx1,cy1] and radius r1
REM with a radial gradient starting from [cx2,cy2] and
REM a radius of r2.
REM **************************************************
function gradientFillCircle(cx1,cy1,r1,cx2,cy2,r2,gradient1,gradient2)
   for x = cx1-r1 to cx1+r1
      for y = cy1-r1 to cy1+r1
         if (x-cx1)^2 + (y-cy1)^2 <= r1^2
            p# = ((cx2-x)^2 + (cy2-y)^2+0.0) / r2^2
            if p# > 1 then p#=1.0
            ink getTransitionalColor(gradient1,gradient2,p#),0
            box x,y,x+1,y+1
         endif
      next y
   next x
endfunction



REM **************************************************
REM Draws an anti-aliased circle with alpha values
REM Based on Xiaolin Wu method
REM Unlike the above method, this uses true alpha
REM values but is slower
REM **************************************************
function E2DC_Circle_AA_Alpha(cx as integer, cy as integer, r as integer, color as dword)
	local alpha1 as dword
	local alpha2 as dword
	
	red = rgbr(color)
	green = rgbg(color)
	blue = rgbb(color)
	
	x = r
	xx = r
	y = -1
	yy = -1
	t# = 0
	
	while x > y
		inc y
		cur_dist# = E2DC_Distance#(r, y)
		if cur_dist# < t# then dec x

		rem anti-aliased pixels inside the circle
		c = 127*cur_dist#	: alpha1 = E2DC_ARGB(c, red, green, blue)
		rem anit-aliased pixels outside the circle
		c = 127 - c 		: alpha2 = E2DC_ARGB(c, red, green, blue)
		
		rem octant 1
		box cx-y,   cy-x,cx-y+1,   cy-x+1,   color, color, color, color
		box cx-y,   cy-x-1,cx-y+1,   cy-x, alpha2, alpha2, alpha2, alpha2
		box cx-y,   cy-x+1,cx-y+1,   cy-x+2, alpha1, alpha1, alpha1, alpha1
		rem octant 2
		box cx-x,   cy-y,cx-x+1,   cy-y+1,   color, color, color, color
		box cx-x-1, cy-y, cx-x, cy-y+1,  alpha2, alpha2, alpha2, alpha2
		box cx-x+1, cy-y,cx-x+2, cy-y+1,   alpha1, alpha1, alpha1, alpha1
		rem octant 3
		box cx-x,   cy+y,cx-x+1,   cy+y+1,   color, color, color, color
		box cx-x-1, cy+y, cx-x, cy+y+1,  alpha2, alpha2, alpha2, alpha2
		box cx-x+1, cy+y,cx-x+2, cy+y+1,   alpha1, alpha1, alpha1, alpha1
		rem octant 4
		box cx-y,   cy+x, cx-y+1,   cy+x+1,  color, color, color, color
		box cx-y,   cy+x+1,cx-y+1,   cy+x+2, alpha2, alpha2, alpha2, alpha2
		box cx-y,   cy+x-1,cx-y+1,   cy+x, alpha1, alpha1, alpha1, alpha1
		rem octant 5
		box cx+y,   cy+x,cx+y+1,   cy+x+1,   color, color, color, color
		box cx+y,   cy+x-1,cx+y+1,   cy+x, alpha1, alpha1, alpha1, alpha1
		box cx+y,   cy+x+1,cx+y+1,   cy+x+2, alpha2, alpha2, alpha2, alpha2
		rem octant 6
		box cx+x,   cy+y,cx+x+1,   cy+y+1,   color, color, color, color
		box cx+x-1, cy+y,cx+x, cy+y+1,   alpha1, alpha1, alpha1, alpha1
		box cx+x+1, cy+y,cx+x+2, cy+y+1,   alpha2, alpha2, alpha2, alpha2
		rem octant 7
		box cx+x,   cy-y, cx+x+1,   cy-y+1,  color, color, color, color
		box cx+x-1, cy-y,cx+x, cy-y+1,   alpha1, alpha1, alpha1, alpha1
		box cx+x+1, cy-y,cx+x+2, cy-y+1,   alpha2, alpha2, alpha2, alpha2
		rem octant 8
		box cx+y,   cy-x,cx+y+1,   cy-x+1,   color, color, color, color
		box cx+y,   cy-x-1,cx+y+1,   cy-x, alpha2, alpha2, alpha2, alpha2
		box cx+y,   cy-x+1,cx+y+1,   cy-x+2, alpha1, alpha1, alpha1, alpha1
		
		t# = cur_dist#
	endwhile
endfunction



REM **************************************************
REM Returns fractional part of distance
REM   * Needed for Xiaolin Wu functions
REM **************************************************
function E2DC_Distance#(a, b)
	real# = sqrt(a^2 - b^2)
	d# = ceil(real#) - real#
endfunction d#



REM **************************************************
REM Returns a linear interpolated color between base
REM color and target color. Percent ranges from 0 to 1
REM **************************************************
function getTransitionalColor(base, target, percent#)
   br = rgbr(base)
   bg = rgbg(base)
   bb = rgbb(base)
   tr = rgbr(target)
   tg = rgbg(target)
   tb = rgbb(target)
   tr = br + (tr-br)*percent#
   tg = bg + (tg-bg)*percent#
   tb = bb + (tb-bb)*percent#
   color = rgb(tr,tg,tb)
endfunction color



REM **************************************************
REM Xiaolin Wu's line algorithm.
REM **************************************************
function E2DC_Line_AA_ALPHA(x1, y1, x2, y2, color as dword)
	local dx as float
	local dy as float
	local xend as float
	local yend as float
	local xgap as float
	local ygap as float
	local xpxl1 as float
	local ypxl1 as float
	local xpxl2 as float
	local ypxl2 as float
	local intery as float
	local interx as float
        
	red   = rgbr(color)
	green = rgbg(color)
	blue  = rgbb(color)
	
	dx = x2-x1
	dy = y2-y1
        
	if abs(dx) > abs(dy)
		rem handle horizontal lines
		if x2 < x1
			ax = x1                 
			x1 = x2
			x2 = ax
			ay = y1
			y1 = y2
			y2 = ay
		endif
		gradient# = dy / dx
                
		rem handle first endpoint
		xend = ceil(x1)
		yend = y1 + gradient# * (xend-x1)
		xgap = 1.0 - fract#(x1 + 0.5)
		xpxl1 = xend : `used in main loop
		ypxl1 = int(yend)
		f# = 1-fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1, xpxl1+1, ypxl1+1, c, c, c, c
		rem brightness: fract#(yend)*xgap
		f# = fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1+1, xpxl1+1, ypxl1+2, c, c, c, c
		intery = yend + gradient# : `first y-intersection for main loop

		rem handle second endpoint
		xend = ceil(x2)
		yend = y2 + gradient# * (xend-x2)
		xgap = 1.0 - fract#(x2 + 0.5)
		xpxl2 = xend : `used in main loop
		ypxl2 = int(yend)
		f# = 1-fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2, xpxl2+1, ypxl2+1, c, c, c, c
		f# = fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2+1, xpxl2+1, ypxl2+2, c, c, c, c

		rem main loop
		a = xpxl1+1
		b = xpxl2-1
		for x = a to b
			f# = 1-fract#(intery) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box x, intery, x+1, intery+1, c, c, c, c
			f# = fract#(intery) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box x, intery+1, x+1, intery+2, c, c, c, c
			intery = intery + gradient#
		next x
                
	else
		rem handle vertical lines
		if y2 < y1
			ax = x1
			x1 = x2
			x2 = ax
			ay = y1
			y1 = y2
			y2 = ay
		endif
        
        gradient# = dx / dy

		rem handle first endpoint
		yend = ceil(y1)
		xend = x1 + gradient# * (yend-y1)
		ygap = 1.0 - fract#(y1 + 0.5)
		xpxl1 = int(xend)
		ypxl1 = yend            
		f# = 1-fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1,  xpxl1+1, ypxl1+1, c, c, c, c
		intery = intery + gradient#
		f# = fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1+1, xpxl1+1, ypxl1+2, c, c, c, c
		
		interx = xend + gradient# : `first y-intersection for main loop
		
		rem handle second endpoint
		yend = ceil(y2)
		xend = x2 + gradient# * (yend-y2)
		ygap = fract#(y2 + 0.5)
		xpxl2 = int(xend)
		ypxl2 = yend
		f# = 1-fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2, xpxl2+1, ypxl2+1, c, c, c, c
		f# = fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2+1, xpxl2+1, ypxl2+2, c, c, c, c
        
		rem main loop
		a = ypxl1+1
		b = ypxl2-1
		for y = a to b                  
			f# = 1-fract#(interx) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box interx, y, interx+1, y+1, c, c, c, c
			f# = fract#(interx) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box interx+1, y, interx+2, y+1, c, c, c, c
			interx = interx + gradient#
		next y
	endif
endfunction



REM **************************************************
REM quicker dot function
REM **************************************************
function E2DC_Dot(x as integer, y as integer, color as dword )
   if x > 0 and x < screen width() and y > 0 and y < screen height()
      offset = get pixels pointer()
      pitch = get pixels pitch()
      bitsPerPixel = bitmap depth(0)/8
      pointer = offset + y*pitch + x*bitsPerPixel
      *pointer = color
   endif
endfunction



REM **************************************************
REM Draws a filled-in circle
REM **************************************************
function E2DC_Fill_Circle(x,y,r)
   for yy = y-r to y
      for xx = x-r to x
         d# = (xx-x)*(xx-x) + (yy-y)*(yy-y)
         if d# <= r*r
            box xx,yy,x+(x-xx)+1,yy+1
            if yy <> y then box xx,y+(y-yy),x+(x-xx)+1,y+(y-yy)+1
            exit
         endif
      next xx
   next yy
endfunction


REM **************************************************
REM Just a little helper function
REM **************************************************
function fract#(x as float)
        a# = x - int(x)
endfunction a#



REM **************************************************
REM Returns a color with an alpha value
REM **************************************************
function E2DC_ARGB(a,r,g,b)
	local c as dword
	c = (a*16777216)+(r*65536)+(g*256)+b
endfunction c

Rem Project: Dark Basic Pro Project
Rem Created: Monday, May 30, 2011

Rem ***** Main Source File *****
set display mode 800,600,32
sync on
sync rate 0
sync
randomize timer()
hide mouse
set window position 0,0

set text font "courier new"
set text size 24

type particle
x as float
y as float
dx as float
dy as float
L# as float
endtype

dim pa(101) as particle

` THE OBJECT:
` LAND 10 SHIPS SUCCESSFULLY ON THE PLANET.
` GET A PERFECT SCORE


` dx# will hold the horizontal thrust, dy# holds vertical.
` grav# will be a constant downward acceleration.
` wind# can be a constant horizontal accel, either way.

 dim L(801)
 dim pad(801)
 
 global dx# as float
 global dy# as float
 
 global gs# as float
 global t1
 
 global grav# as float
 global wind# as float
 
 global x# as float
 global y# as float
 
 GLOBAL FUEL
 GLOBAL SCORE
 
 GLOBAL NP  
 GLOBAL SHIPS
 
 GLOBAL LANDINGS
 
cls
dot 0,0
get image 2,0,0,1,1,1


cls
for t=1 to 9
 read x,y
 box x*2,y*2,x*2+2,y*2+2 
next t
 get image 1,1,1,12,10,1
data 3,1 , 2,2 , 4,2 , 2,3 , 3,3 , 4,3
data 1,4 , 3,4 , 5,4


`jag=0

DO

SCORE=0
`highscore=0
SHIPS=10
LANDINGS=0

DO


for t=1 to 100
 pa(t).L#=-11.1
next t



at=500
goal=0

for t=0 to 800

 pad(t)=0
 if sprite exist(t+1)
  delete sprite t+1
 endif
 
if goal=0 or abs(at-goal)<3
 goal=rnd(60)-30+at
 if goal<300 then goal=400-rnd(50)
 if goal>580 then goal=520+rnd(50)
endif

if at>goal
 dec at,rnd(2)
else
 inc at,rnd(2)
endif

L(t)=at

next t



for t=7 to 11
 `y=450+rnd(100)
 
 ` find an x location that is not already a pad
repeat
 x=rnd(500)+50
 yes=1
  for z=x-3 to x+t*2+3
   if pad(z)>0 then yes=0
  next z
until yes=1

 y=L(x)+rnd(2)
 
  for z=x to x+t*2
   L(z)=y
   pad(z)=t
  next z
  
  
  
next t
 

cls

for t=1 to 100
 dot rnd(800),rnd(600)
next t

for t=0 to 800

  if pad(t)>0
   ink rgb(0,0,255),0
  else
   ink rgb(255,255,255),0
  endif
 dot t,L(t)

 
for u=l(t)+2 to 600 
 q=rnd(40)+70
 ink rgb(q,q,q),0
 dot t,u
next u
 
 
 if pad(t)=0
  sprite t+1,t,l(t),2
  size sprite t+1,1,600
  hide sprite t+1
 endif
 
next t

get image 99,0,0,800,600,1


x#=300+rnd(200)
y#=10

dx#=0
dy#=0

grav#=0.165
wind#=((rnd(34)-17)/77.17)*rnd(2)

FUEL=5000

t1=timer()
do
cls
gs#=(timer()-t1)*0.025
t1=timer()

paste image 99,0,0

w$=" >>>"
if wind#<0
 w$=" <<<"
endif

if abs(wind#)<0.01 then w$=""

text 0,250,"SPEED: "+str$(dy#*10,1)
text 0,150,"FUEL: "+str$(FUEL/50,1)
Center text 400,0,"SCORE : "+str$(SCORE)
text 0,200,"WIND: "+str$(wind#*100,1)+w$
text 0,100,"SHIPS: "+str$(ships)


dx=(rightkey()-leftkey())
dy=-upkey()

if fuel<1
 dx=0
 dy=0
endif

dx#=dx#+(wind#+dx)*0.0025
dy#=dy#+(grav#+(dy)*0.60)*0.02

IF dx or dy THEN DEC FUEL

x#=x#+dx#*gs#
y#=y#+dy#*gs#

if x#<5 then x#=5
if x#>795 then x#=795
if y#<5 then y#=5

sprite 999,x#,y#,1

if sprite collision(999,0)>0

 CRASH()
 EXIT
else
  z=int(x#)
 if y#+9>L(z)
 
  yes=1
   for t=int(x#) to int(x#+11)
    if L(t)<>L(z)
     yes=0
    endif
   next t
   
    ` if you land too fast, you crash
   if dy#>3.1 then yes=0
   
  if yes=1
     You_Win()
     EXIT
  else
     CRASH()
     EXIT
  endif
   
  
 endif
endif

IF RND(2)=0

    if dy
     inc NP
      if NP>100 then NP=1
      
       pa(np).x=x#+5
       pa(np).y=y#+5
       pa(np).dx=(rnd(30)-15)*0.05
       pa(np).dy=(rnd(5)+9)*0.49
       pa(np).l#=31.1
    
    endif
    
    if dx : ` or dy
     inc NP
      if NP>100 then NP=1
      
       pa(np).x=x#+5
       pa(np).y=y#+5
       pa(np).dx=(-dx) * (rnd(5)+9)*0.39
       pa(np).dy=(rnd(30)-15)*0.05
       pa(np).l#=31.1
    
    endif

ENDIF
   


Particle_Control()

sync

loop

if ships<1
 Game_Over()
 EXIT
endif

LOOP

 
LOOP
 

end



` particle trails and explosions.

Function Particle_Control()
INK RGB(255,0,0),0
 for t=1 to 100
  if pa(t).L#>0
   dec pa(t).L#,gs#
   pa(t).x=pa(t).x+pa(t).dx*gs#
   pa(t).y=pa(t).y+pa(t).dy*gs#
   dot pa(t).x,pa(t).y   
   
   ` this makes the particles stop when they hit the ground:
    xx=int(pa(t).x)
   if xx<800 and xx>1
    if pa(t).y>L(xx) then pa(t).l#=-99.9
   endif
   
  endif
 next t
INK RGB(255,255,255),0
Endfunction 

Function CRASH()

 SCORE=(SCORE*2)/3
 DEC SHIPS

 for t=1 to 100
       
       pa(t).x=x#+5
       pa(t).y=y#+5
       pa(t).dx=(rnd(18)-9)*0.39
       pa(t).dy=(rnd(18)-9)*0.39
       pa(t).l#=33.1

 next t
 
 tim#=0.0
 DO
 CLS
  gs#=(timer()-t1)*0.025
  t1=timer()
  paste image 99,0,0
  hide sprite 999
  
  Particle_Control()
 
  center text 400,200,"YOU HAVE CRASHED!"
  if ships>0 then center text 400,280,"...Get Ready To Try Again..."
  
 inc tim#,gs#
 
 SYNC
 if returnkey() then exit
if tim#>50.0 then exit
 LOOP
        

 show sprite 999

Endfunction

Function You_Win()

z=int(x#)
padbon=(12-pad(z))
padbon=padbon*padbon

 INC SCORE,(50*padbon)+(ABS(SCORE))
 DEC SHIPS
 INC LANDINGS
 
` DO
 
  CLS
  PASTE IMAGE 99,0,0
  
  center text 400,200,"SAFE LANDING!"
  
  center text 400,240,"Landing Pad Multiplier : x"+str$(padbon)

  if ships>0 then center text 400,280,"...Get Ready..."
 SYNC
wait 2500
 

Endfunction 



Function Game_Over()

for t=1 to 999
if sprite exist(t)
 delete sprite t
endif
next t

cls
center text 400,200,"GAME OVER"
center text 400,240,"You Landed "+str$(landings)+" Ships out of 10"
center text 400,280,"Your Final Score Is"
center text 400,320,str$(score)
center text 400,500,"Press Any Key To Try Again"
center text 400,540,"Or Escape To Quit"

sync
wait 1000
wait key

Endfunction


` my score.

` 138928

//////////////////////////////////////////
// Lunar Lander Compo Entry
// Thenerd - 6/4/11
// chrisdalke@gmail.com
//////////////////////////////////////////

// standard init code
set display mode 640,480,32 : set window on
sync on : sync rate 60 : hide mouse
backdrop off : autocam off

// init variables
global starcount as integer
global vel_x as float
global vel_y as float
global vy as float
global tick as integer
global timer_old as integer
global land_pts as integer
global tunnelht as integer
tunnelht=100
timer_old=timer()

vy=320

CreateStaticOverlay()

type land
	x as integer
	y_upper as integer
	y_lower as integer
endtype

InitBoundaries()

// set up stars (code by darkforge!)
starcount=1000
type star x y speed depth endtype
dim stars(starcount) as star
for c=1 to starcount
   stars(c).x = rnd(640)
   stars(c).y = rnd(480)
   stars(c).speed = rnd(5)+1
   stars(c).depth = rnd(10)
next c


// main loop
do
	`UpdateStars()
	ink rgb(255,255,255),0
	UpdateStaticOverlay()
	UpdateBoundaries()
	
	set cursor 0,0
	print "Thenerd's compo entry"
	print "Velocity Y:",vel_y
	print "Height Y:",vy
	
	vel_x=2
	vel_y=vel_y+0.1
	if upkey() or spacekey() then vel_y=vel_y-0.4
	
	vy=vy+vel_y
	circle 320,vy,10
	
	coly_top=point(320,vy)
	coly_bottom=point(320,vy)
	coly_top=RGBR(coly_top)
	coly_bottom=RGBR(coly_bottom)
	if coly_top>200 then col=1
	if coly_bottom>200 then col=1
	if col:
		vy=240
		vel_y=0.0
	endif
	print "ColY_TOP:",coly_top
	print "ColY_BOTTOM:",coly_bottom
	print "Collision:",col
	col=0
   
   sync
loop


// FUNCTIONS

function InitBoundaries():
	dim lands() as land
endfunction

function UpdateBoundaries():
	if timer()-timer_old>400:
		timer_old=timer()
		array insert at bottom lands()
		land_pts=land_pts+1
		lands(land_pts-1).x=740
		lands(land_pts-1).y_upper=rnd(tunnelht)+40+(tunnelht/10)
		lands(land_pts-1).y_lower=440-rnd(tunnelht)+(tunnelht/10)
		tunnelht=tunnelht+1
		if tunnelht>160 then tunnelht=160
	endif
	for c=0 to land_pts-1:
		lands(c).x=lands(c).x+(0-vel_x)
		`circle lands(c).x,lands(c).y_upper,10
		`circle lands(c).x,lands(c).y_lower,10
		if c>0:
			line lands(c).x,lands(c).y_upper,lands(c-1).x,lands(c-1).y_upper
			line lands(c).x,lands(c).y_lower,lands(c-1).x,lands(c-1).y_lower
			line lands(c).x,lands(c).y_upper-10,lands(c-1).x,lands(c-1).y_upper-10
			line lands(c).x,lands(c).y_lower-10,lands(c-1).x,lands(c-1).y_lower-10
		else :
			line lands(c).x,lands(c).y_upper,lands(c).x-200,0
			line lands(c).x,lands(c).y_lower,lands(c).x-200,640
			line lands(c).x,lands(c).y_upper-10,lands(c).x-200,0-10
			line lands(c).x,lands(c).y_lower-10,lands(c).x-200,640-10
		endif 
		if lands(c).x<-200:
		array index to top lands()
		array delete element lands()
		land_pts=land_pts-1
		endif
	next c
endfunction

function UpdateStars()
	// handle stars
   for c=1 to starcount
      tempx = stars(c).x
      inc tempx,(0-vel_x)-stars(c).depth
      if tempx < -10 then tempx = 640+rnd(100) : stars(c).y = rnd(480):stars(c).depth = 1-rnd(100)/1000.0
      stars(c).x = tempx
      ink rgb(50*stars(c).speed,50*stars(c).speed,50*stars(c).speed),0
      dot stars(c).x, stars(c).y
   next c
endfunction

function CreateStaticOverlay()
	// make static image
	cls 0 
	for x=0 to 640:
	for y=0 to 480:
		colorrnd=rnd(80)
		dot x,y,rgb(colorrnd,colorrnd,colorrnd)
	next y
	next x
	get image 1,0,0,640,480
	cls 0
	wh=rgb(255,255,255)
	box 0,0,640,480,0,0,0,wh
	box 0,0,640,480,0,0,wh,0
	box 0,0,640,480,0,wh,0,0
	box 0,0,640,480,wh,0,0,0
	
	get image 2,0,0,640,480
	
	
	make object plain 1,640,480
	set object light 1,0
	texture object 1,1
	`ghost object on 1
	set object transparency 1,1
	set alpha mapping on 1,40
	`texture object 1,2,0
endfunction

function UpdateStaticOverlay()
	position camera 0,0,0
	position object 1,0,0,380
	point object 1,0,0,0
	tick=tick+1
	if tick>10 then scroll object texture 1,0,rnd(100)/1000.0,rnd(100)/1000.0 : tick=0
endfunction

REM ===============================================
REM Title: Looney Lander Challenge
REM Author: Phaelax
REM Date: March 31, 2011
REM ===============================================

set display mode 1024, 768, 32

randomize timer()

#CONSTANT SFX_EXPLODE = 1
#CONSTANT SFX_THRUST = 2


Global GRAV# = 0.01
Global FUEL = 1000
#CONSTANT EPSILON = 0.01
#CONSTANT WHITE = rgb(255,255,255)
#CONSTANT BROWN = rgb(50,30,1)
local slugSpeed = 1
local slugX = -100
REM ==== start variables for terrain ========================
Global DEPTH = 5
numOfPts = 2^DEPTH + 1
Global PT_COUNT = numOfPts
Global LANDING_POINT = 0
Global LANDING_WIDTH = 0
Global LANDING_SEGS = 3
dim points(numOfPts,2)
REM ==== end terrain variables ==============================

REM Background stars
#CONSTANT STARCOUNT = 200
dim stars(STARCOUNT, 3) as float
for i = 1 to STARCOUNT
	stars(i, 1) = rnd(screen width())
	stars(i, 2) = rnd(screen height())
	select rnd(2)
		case 0 : stars(i, 3) = 0.2 : endcase
		case 1 : stars(i, 3) = 0.4 : endcase
		case 2 : stars(i, 3) = 0.6 : endcase
	endselect
next i


dim msg$(5)
msg$(1) = "Perfect!"  : ` < 0.3
msg$(2) = "Rough Landing" : ` 0.4 > 0.7
msg$(3) = "You got lucky!" : ` 0.7 > 1.0
msg$(4) = "Too hard!" : ` > 1.0
msg$(5) = "Kamikaze!" : ` >= 1.5

dim platform(6,2)

Type ShipObject
	x as float
	y as float
	vx as float
	vy as float
	thrust as float
EndType

ship as ShipObject
ship.thrust = 0.04
ship.x = 200 : ship.y = 23

`drawShip(32, 40)
`get image 1, 0, 0, 64, 57, 1
`sprite 1, 0, 0, 1 : hide sprite 1
`offset sprite 1, 32, 40
drawShip2(32, 44)
get image 1, 0, 0, 64, 61, 1
sprite 1, 0, 0, 1 : hide sprite 1
offset sprite 1, 32, 44


rem build a random lunar map
buildRandomMap(1)

`frequency#,length#,loudness#,bend#,decay#,vibratospeed#,vibratodepth#,tremelospeed#,tremelodepth#,attack#

createsound("explosion",SFX_EXPLODE,300,3000,3500,2,0.1,0.05,0,0,0,10)
createsound("thrust",SFX_THRUST,500,41,4000,0.25,8.60,1.00,1,0.0,0,5.82)


REM ==== start fire/thrust particles ==============================
Type Particle
	x as float
	y as float
	sx as integer
	sy as integer
	vx as float
	vy as float
	alpha as integer
	color as dword
EndType

dim fire(200) as Particle
dim firePalette(4) as dword
firePalette(0) = rgb(255,0,0)
firePalette(1) = rgb(96,0,0)
firePalette(2) = rgb(255,128,0)
firePalette(3) = rgb(180,90,0)
firePalette(4) = rgb(200, 200, 0)

ink rgb(0,0,0), 0
box 0, 0, 20, 20
ink rgb(255,255,255),0
E2DC_Fill_Circle(10, 10, 10)
get image 4, 0, 0, 20, 20
sprite 4, 0, 0, 4 : size sprite 4, 4, 4 : offset sprite 4, 2, 2 : hide sprite 4
set sprite 4, 0, 1

for i = 1 to 200
	clone sprite 4, i+4
	hide sprite i+4
next i
REM ==== end fire/thrust particles ==============================


dim shipBlow(40, 40) as Particle


hide mouse
sync on
sync rate 60

do
	cls
	
	rem background sky
	box 0, 0, 1024, 768, rgb(0,41,63),rgb(0,23,35),rgb(0,41,63),rgb(0,23,35)
	
	gosub Controls
	
	rem add gravity to ship's vertical velocity
	inc ship.vy, GRAV#
		
	
	rem cheap form of wind resistance, pushes
	rem horizontal movement back to 0 velocity
	if ship.vx > 0 then dec ship.vx, 0.01
	if ship.vx < 0 then inc ship.vx, 0.01
	if abs(ship.vx) < EPSILON then ship.vx = 0
		

	rem check landing
	if ship.y+16 >= points(LANDING_POINT, 2)-1
		if ship.x-28 >= points(LANDING_POINT, 1) and ship.x+28 <= points(LANDING_POINT+LANDING_SEGS-1, 1)
			ship.y = points(LANDING_POINT, 2)-17
			if hasLanded# = 0 then hasLanded# = abs(ship.vy)+abs(ship.vx)
			if thrust = 0 then ship.vy = 0
		endif
	endif
	
	
	rem rotate ship
	t# = ship.vx/1.5
	if t# > 1 then t# = 1
	if t# < -1 then t# = -1
	a# = 20*t#
	rotate sprite 1, a#
	


	gosub doCollision
	
	
	rem add velocity forces to ship's current position
	inc ship.x, ship.vx
	inc ship.y, ship.vy
	
	
	gosub starBackground
	
	
	rem platform image
	paste image 3, 150, 150, 1
		
	
	rem check landing
	if hasLanded# > 0 and dead = 0
		if hasLanded# > 1.0
			dead = doDeath()
		else
			` successful landing
		endif
	endif
	

	
	rem controls fire/thrust particles
	gosub handleThrustParticles



	rem draw the mountains image
	paste image 2, 0, screen height()-500, 1
	
	
	
	rem draw landing pad
	gosub drawLandingPad
	
	
	rem slug running along ground
	gosub handleSlug
	
	if dead = 0
		rem draw the ship
		paste sprite 1, ship.x, ship.y
		
	else
		tt# = doDeathEffect(tt#)
		if tt# >= 50 then dead = 0 : tt# = 0 : hasLanded# = 0
	endif
	
	
	
	`dec rx, 2
	`inc rot#, 0.5
	`if rx <= 0 then rx = 1124 : ry = rnd(screen height())
	`DrawPolyCircle(rx, ry, 60, 5, rot#)
	
	
	
	rem Fuel meter
	healthBar(412, 10, 200, 30, FUEL/1000.0)
	ink 0, 0
	center text 513, 19, "Fuel"
	ink WHITE, 0
	center text 512, 18, "Fuel"
	
	
	text 645, 10, "(F1)Easy  (F2)Medium  (F3)Hard  (F4)Expert"

	

	if hasLanded# > 0
		center text screen width()/2, 40, getLandingMessage$(hasLanded#)
	endif
	
	
	
	
	set cursor 0,0
	print screen fps()
	print "Landed: ", hasLanded#
	print "VX: ", ship.vx
	print "VY: ", ship.vy
	print tt#
	
	sync
loop




REM ===============================================
REM Space slug. Draws slug and checks for collision
REM with ship's landing feet.
REM ===============================================
handleSlug:
	rem calculate positions of landing feet
	x1 = ship.x + sin(118+a#)*32.249
	y1 = ship.y - cos(118+a#)*32.249
	x2 = ship.x - sin(62+a#)*32.249
	y2 = ship.y + cos(62+a#)*32.249
	
	slugSize# = 200
	
	if hasLanded# = 0 then inc slugX, 2
	if slugX > screen width() + slugSize# then slugX = -slugSize#
	ba# = ba# + slugSpeed
	if ba# >= 20 or ba# <= -30 then slugSpeed = slugSpeed*-1
	v# = (sin(ba#)+1)*2
	a = slugSize#*0.2
	for n = a to slugSize#-a
		n#=(b-a)*t+a
		c = 255 - 255 * n/slugSize#
    	c1 = rgb(0,c,0)
    	c2 = rgb(c,c,0)
    	x# = (n-(slugSize#/2))/(slugSize#/4)
    	y# = (0.39894228*v#*exp(-x#*x#*v#))*(slugSize#*0.3)
    	base = getHeight#(slugX+n)
    	box slugX+n,base-y#,slugX+n+1,base, c2, c1, c2, c1
    	
    	if slugX+n = x1
    		if y1 > base-y# then dead = doDeath()
    	endif
    	if slugX+n = x2
    		if y2 > base-y# then dead = doDeath()
    	endif
    	
	next n
RETURN



REM ===============================================
REM Player's controls
REM ===============================================
Controls:
	rem player controls
	thrust = 0
	if dead = 0 and hasLanded# = 0
		if upkey() and FUEL > 0
			dec FUEL
			thrust = 1
			dec ship.vy, ship.thrust
			if ship.vy < -1.5 then ship.vy = -1.5
			if sound playing(SFX_THRUST) = 0 then play sound SFX_THRUST
		endif
		
		if ship.vy <> 0
			if rightkey()
				inc ship.vx, ship.thrust
			endif
			if leftkey()
				dec ship.vx, ship.thrust
			endif
		endif
	endif
	
	rem Star a new game
	rem F1 = easy, F2 = medium, F3 = hard, F4 = Expert
	if scancode() = 59 and flag = 0 then buildRandomMap(1) : flag = 1 : hasLanded# = 0
	if scancode() = 60 and flag = 0 then buildRandomMap(2) : flag = 1 : hasLanded# = 0
	if scancode() = 61 and flag = 0 then buildRandomMap(3) : flag = 1 : hasLanded# = 0
	if scancode() = 62 and flag = 0 then buildRandomMap(4) : flag = 1 : hasLanded# = 0
	if scancode() = 0 then flag = 0
RETURN



REM ===============================================
REM Moves stars in background
REM ===============================================
starBackground:
	rem draw stars
	for i = 1 to STARCOUNT
		select stars(i, 3)
			case 0.2 : ink rgb(96,96,96),0 : endcase
			case 0.4 : ink rgb(200,200,200),0 : endcase
			case 0.6 : ink rgb(255,255,255),0 : endcase
		endselect
		box stars(i, 1), stars(i, 2), stars(i, 1)+1, stars(i, 2)+1
		stars(i, 2) = stars(i, 2) - stars(i, 3)
		if stars(i, 2) < 0 then stars(i, 2) = screen height() : stars(i, 1) = rnd(screen width())
	next i
RETURN



REM ===============================================
REM Handles collision between the ship's landing
REM feet and the terrain
REM ===============================================
doCollision:
	rem calculate positions of landing feet
	x1 = ship.x + sin(118+a#)*32.249
	y1 = ship.y - cos(118+a#)*32.249
	
	x2 = ship.x - sin(62+a#)*32.249
	y2 = ship.y + cos(62+a#)*32.249
	

	rem screen boundaries
	if ship.x > screen width()+21 then ship.x = -20
	if ship.x < -20 then ship.x = screen width()+20
		

	rem check collision
	for t = 1 to PT_COUNT-1		
		rem check if ship's left leg is within this terrain segment's region
		if x2 >= points(t, 1) and x2 <= points(t+1, 1)
			y# = getHeight#(x2)
			rem if ship hit ground
			if y2 >= y#
				ship.vy = 0
				ship.y = y#-16
				dead = doDeath()
			endif
		endif
		rem check if ship's right leg is within this terrain segment's region
		if x1 >= points(t, 1) and x1 <= points(t+1, 1)
			y# = getHeight#(x1)
			rem if ship hit ground
			if y1 >= y#
				ship.vy = 0
				ship.y = y#-16
				dead = doDeath()
			endif
		endif
	next t

	
	Rem platform collision with ship's dome
	gosub platformCollision
	
RETURN



REM ===============================================
REM Handles collision between the ship's dome and
REM the platform
REM ===============================================
platformCollision:

	for i = 0 to 6
		ax = 150+platform(i,1)
		ay = 150+platform(i,2)
		if i < 6
			bx = 150+platform(i+1,1)
			by = 150+platform(i+1,2)
		else
			bx = 150+platform(0,1)
			by = 150+platform(0,2)
		endif
		
		n# = (ship.x-ax)*(bx-ax) + ((ship.y-22)-ay)*(by-ay)
		x# = bx - ax
		y# = by - ay
		d# = x#*x# + y#*y#
		u# = n# / d#
		if u# < 0 then u# = 0
		if u# > 1 then u# = 1
		
		ix = ax + (bx-ax)*u#
		iy = ay + (by-ay)*u#
		
		dist# = (ship.x-ix)^2 + ((ship.y-22)-iy)^2
		

		if dist# <= 400
			dead = doDeath()
		endif
		if ship.x > 150 and ship.x < 250
			if dist# < 1528 and i = 6
				if ship.vy > 0 then ship.vy = 0
			endif
		endif
	
	next i
RETURN



REM ===============================================
REM Draw and animate the landing pad
REM ===============================================
drawLandingPad:
	ink 0, 0
	box points(LANDING_POINT,1),points(LANDING_POINT,2), points(LANDING_POINT+LANDING_SEGS-1,1),points(LANDING_POINT+LANDING_SEGS-1,2)+3
	inc r#, 0.5
	if r# > LANDING_WIDTH-3 then r# = 0
	ink rgb(255,255,0),0
	box points(LANDING_POINT, 1)+LANDING_WIDTH-r#, points(LANDING_POINT, 2), points(LANDING_POINT, 1)+LANDING_WIDTH-r#+3, points(LANDING_POINT, 2)+3
	box points(LANDING_POINT, 1)+LANDING_WIDTH+r#, points(LANDING_POINT, 2), points(LANDING_POINT, 1)+LANDING_WIDTH+r#+3, points(LANDING_POINT, 2)+3
RETURN



REM ===============================================
REM handles the fire/thrust particles
REM ===============================================
handleThrustParticles:
	for i = 1 to 200
		d = (fire(i).x-fire(i).sx)^2 + (fire(i).y-fire(i).sy)^2
		if d >= 30*30 or fire(i).vy = 0
			if thrust = 1
				fire(i).x = ship.x + rnd(20)-10
				fire(i).y = ship.y
				fire(i).sx = ship.x
				fire(i).sy = ship.y
				fire(i).alpha = 255
				fire(i).color = firePalette(rnd(4))
				set sprite diffuse i+4, rgbr(fire(i).color), rgbg(fire(i).color), rgbb(fire(i).color)
				a = rnd(40)-20 - sprite angle(1)
				v# = (rnd(20)+10) / 10.0
				fire(i).vx = sin(a)*v#
				fire(i).vy = cos(a)*v#
			else
				fire(i).vy = 0
			endif
		else
			inc fire(i).x, fire(i).vx
			inc fire(i).y, fire(i).vy
			t# = (900-d) / 900.0
			fire(i).alpha = 128*t#
			if fire(i).alpha < 0 then fire(i).alpha = 0 : fire(i).vy = 0
		endif
		if fire(i).vy <> 0
			set sprite alpha i+4, fire(i).alpha
			paste sprite i+4, fire(i).x, fire(i).y
		endif
	next i
RETURN



REM ===============================================
REM begin the death process
REM ===============================================
function doDeath()
	initDeathParticles()
	play sound SFX_EXPLODE
	ship.x = 200 : ship.y = 133
	ship.vx = 0 : ship.vy = 0
endfunction 1



REM ===============================================
REM Animates death explosion particles
REM ===============================================
function doDeathEffect(t#)
	lock pixels
	for x = 1 to 40
		for y = 1 to 40
			px = shipBlow(x,y).x + shipBlow(x,y).vx*cos(shipBlow(x,y).alpha)*t#
			py = shipBlow(x,y).y + shipBlow(x,y).vx*sin(shipBlow(x,y).alpha)*t# + 0.5*2*t#^2
			E2DC_Dot(px,py,rgb(200,200,230))
		next y
	next x
	unlock pixels
	t# = t# + 0.5
	if t# >= 50
		`t# = 0
		dead = 0
		FUEL = 1000
	endif
endfunction t#



REM ===============================================
REM initializes particles for death explosion
REM ===============================================
function initDeathParticles()
	for x = 1 to 40
        for y = 1 to 40
            shipBlow(x,y).x = ship.x+x-20
            shipBlow(x,y).y = ship.y+y-42
            shipBlow(x,y).alpha = rnd(180)+180
            shipBlow(x,y).vx = rnd(10)+5
        next y
    next x
endfunction



REM ===============================================
REM Determine successfullnes of landing
REM ===============================================
function getLandingMessage$(landingValue#)
	t$ = "Out of range"
	if landingValue# <= 0.3 then t$ = msg$(1)
	if landingValue# > 0.3 and landingValue# <= 0.7 then t$ = msg$(2)
	if landingValue# > 0.7 and landingValue# <= 1.0 then t$ = msg$(3)
	if landingValue# > 1.0 and landingValue# < 1.5 then t$ = msg$(4)
	if landingValue# >= 1.5 then t$ = msg$(5)
endfunction t$



REM ===============================================
REM Draws the lunar lander
REM ===============================================
function drawShip(x, y)
	ink rgb(255,255,255),0
	rem top
	DrawPolyCircle(x, y-20, 20, 6, 90)
	rem base
	box x-20, y-10, x+20, y
	rem left leg
	line x-20, y-5,  x-28, y+8
	line x-16, y,    x-28, y+8
	line x-28, y+8,  x-28, y+16
	line x-32, y+16, x-24, y+16
	rem right leg
	line x+20, y-5,  x+28, y+8
	line x+16, y,    x+28, y+8
	line x+28, y+8,  x+28, y+16
	line x+32, y+16, x+24, y+16
endfunction



REM ===============================================
REM Draws the lunar lander
REM ===============================================
function drawShip2(x, y)
	rem top
	gradientFillCircle(x, y-22,20,x-6, y-30,30,rgb(229,241,243),rgb(123,162,194))
	E2DC_Circle_AA_Alpha(x, y-22, 20, rgb(123,162,194))
	E2DC_Circle_AA_Alpha(x, y-22, 20, rgb(123,162,194))
	
	rem left leg
	E2DC_Line_AA_ALPHA(x-20, y-5,  x-28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-16, y,    x-28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-28, y+8,  x-28, y+16 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x-32, y+16, x-24, y+16 ,rgb(200,200,200))
	
	rem right leg
	E2DC_Line_AA_ALPHA(x+20, y-5,  x+28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+16, y,    x+28, y+8 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+28, y+8,  x+28, y+16 ,rgb(200,200,200))
	E2DC_Line_AA_ALPHA(x+32, y+16, x+24, y+16 ,rgb(200,200,200))
	
	rem base
	box x-22, y-12, x+22, y, rgb(237,237,237),rgb(237,237,237),rgb(100,100,100),rgb(100,100,100)
endfunction



REM ===============================================
REM Draw polygon with center at [x,y] and
REM a radius of 'r' with 'segs' number of
REM segments and rotated at 'Rot#' angle
REM ===============================================
function DrawPolyCircle(x,y,r,segs,Rot#)
	AngStep# = 360.0 / segs
	Ang# = Rot#
	For s = 1 To segs
		OldAng# = Ang#
		Ang# = Ang# + AngStep#
		x1 = x + (r * Sin(Ang#))
		y1 = y + (r * Cos(Ang#))
		x2 = x + (r * Sin(OldAng#))
		y2 = y + (r * Cos(OldAng#))
		line x1,y1,x2,y2
	Next s
endfunction



REM ===============================================
REM Creates a random terrain
REM ===============================================
function buildRandomMap(difficulty)
	rem set begin and end points
	points(1,2) = screen height()-120
	points(PT_COUNT,2) = screen height()-120
	
	segLength = screen width() / (PT_COUNT-1)
	for i = 1 to PT_COUNT
		points(i, 1) = (i-1)*segLength
	next i

	
	rem call the midpoint displacement function
	midpoint(points(1,1),points(1,2),points(PT_COUNT,1),points(PT_COUNT,2),screen height()-50,500,0.6,DEPTH,1,PT_COUNT)
	rem smooth the terrain
	smooth(4)
	rem set landing point
	LANDING_POINT = rnd(PT_COUNT-4)+1
	rem set landing pad length
	if difficulty = 1 : LANDING_SEGS = 4 : else : LANDING_SEGS = 3 : endif
	
	rem flatten landing pad
	for i = 1 to LANDING_SEGS-1
		points(LANDING_POINT+i, 2) = points(LANDING_POINT, 2)
	next i
	
	
	rem easy
	if difficulty = 1
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) + (rnd(40)+40)
		if LANDING_POINT+LANDING_SEGS <= PT_COUNT then points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) + (rnd(40)+40)
		GRAV# = 0.01
	endif
	rem medium
	if difficulty = 2
		GRAV# = 0.01
	endif
	rem hard
	if difficulty = 3
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) - (rnd(40)+40)
		points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) - (rnd(40)+40)
		GRAV# = 0.02
	endif
	rem expert
	if difficulty = 4
		points(LANDING_POINT-1, 2) = points(LANDING_POINT, 2) - (rnd(50)+100)
		points(LANDING_POINT+LANDING_SEGS, 2) = points(LANDING_POINT+2, 2) - (rnd(50)+100)
		GRAV# = 0.03
	endif
		
	
	FUEL = 1000
	LANDING_WIDTH = (points(LANDING_POINT+LANDING_SEGS-1, 1)-points(LANDING_POINT, 1)) / 2
	ship.x = 200 : ship.y = 123
	ship.vx = 0 : ship.vy = 0
	
	cls
	drawPlatform()
	if image exist(3) then delete image 3
	get image 3, 0, 0, 100, 70, 1

	
	cls
	drawTerrain()
	blur bitmap 0, 2
	if image exist(2) then delete image 2
	get image 2, 0, screen height()-500, screen width(), screen height(), 1
endfunction



REM ===============================================
REM Draws the terrain previously created by 
REM buildRandomTerrain()
REM ===============================================
function drawTerrain()
	segLength# = screen width() / (PT_COUNT-1)
	
	for t = 1 to PT_COUNT-1
		rem fill the terrain
		ink BROWN,0
		
		y2 = max(points(t, 2), points(t+1, 2))
		for x = points(t,1) to points(t+1,1)
			t# = (x - points(t, 1)) / segLength#
			y = points(t, 2) + (points(t+1, 2)-points(t, 2))*t#
			ink BROWN,0
			box x, y, x+1, screen height()
			`ink rgb(60,36,1),0
			
			
			
			for i = y to screen height()
			
				if rnd(1) = 1
					h# = (screen height() - y)
					r# = (h#-(screen height() - i)) / h#
					`if r# < 0 then r# = 0
					`if r# > 1 then r# = 1
					c = getTransitionalColor(rgb(138,83,5), BROWN, r#)
					ink c, 0
					box x, i, x+1, i+1
				endif
			next i
		next x
		`box points(t,1),y2, points(t+1,1),screen height()
	next t
	
	rem show landing score
	ink WHITE, 0
	center text points(LANDING_POINT, 1)+LANDING_WIDTH, points(LANDING_POINT+1, 2)+4, "10"
endfunction



REM ===============================================
REM Draws a randomly-shaped platform
REM ===============================================
function drawPlatform()
	tx = 0 : ty = 0
	for i = 0 to 5
		ax = 10+i*18
		ay = 50+(rnd(40)-20)
		if i = 5 then ax = 99 : ay = 0
		
		platform(i,1) = tx : platform(i,2) = ty
		
		ink BROWN, 0
		for j = tx to ax
			l# = ax-tx
			t# = (j-tx)/l#
			k = ty + (ay-ty)*t#
			box j, 0, j+1, k
		next j
		
		tx = ax : ty = ay
	next i
	platform(i,1) = tx : platform(i,2) = ty
endfunction



REM ===============================================
REM recursive method using midpoint displacement
REM (x1,y1)    - starting point of line
REM (x2,y2)    - ending point of line
REM baseline   - the base or ground of where the points start
REM height#    - places midpoint Y-coord randomly between 0 and height#
REM h#         - 0 < h# <= 1 : higher makes a very ridged line, lower makes smoother
REM depth      - how many times should the line be split
REM arr1       - used for storing values in array
REM arr2       - used for storing values in array
REM ===============================================
function midpoint(x1,y1,x2,y2,baseline,height#,h#,depth, arr1,arr2)
   y = baseline - rnd(height#)
   arrIndex = arr1 + (arr2-arr1)/2

   points(arrIndex,2) = y

   dec depth, 1

   if depth > 0
      midpoint(x1,y1,x,y,baseline,height#*h#,h#,depth,arr1,arrIndex)
      midpoint(x,y,x2,y2,baseline,height#*h#,h#,depth,arrIndex,arr2)
   endif
endfunction



REM ===============================================
REM Smooths out terrain
REM ===============================================
function smooth(factor)
	rem define an array to temporarily store the points.
	local dim temp(PT_COUNT)
	
	for k = 1 to factor
		for i = 2 to PT_COUNT - 1
			y = points(i,2)
			y1 = points(i-1,2)
			y2 = points(i+1,2)
			temp(i) = (y+y1+y2)/3
		next i
		
		for i = 2 to PT_COUNT - 1
			points(i,2) = temp(i)
		next i
	next k
endfunction



REM ===============================================
REM Returns the height on the terrain at point X
REM ===============================================
function getHeight#(x as float)
	mapWidth# = points(PT_COUNT, 1) - points(1, 1)
	segLength# = mapWidth# / (PT_COUNT-1)
	p1 = ceil(x / segLength#)
	if p1 <= 0 then p1 = 1
	if p1 > PT_COUNT-1 then p1 = PT_COUNT-1
	p2 = p1+1
	
	t# = (x - points(p1, 1)) / segLength#
	h# = points(p1, 2) + (points(p2, 2)-points(p1, 2))*t#
endfunction h#



REM ===============================================
REM x,y is the upper left corner of meter
REM P# ranges from 0 to 1
REM ===============================================
function healthBar(x, y, width, height, P#)
   rem gradient bar
   seg = width / 3
   box x, y, x+seg, y+height, rgb(255,0,0),rgb(255,0,0),rgb(255,128,0),rgb(255,128,0)
   box x+seg, y, x+seg+seg, y+height, rgb(255,128,0),rgb(255,128,0), rgb(255,255,0),rgb(255,255,0)
   box x+seg+seg, y, x+width, y+height, rgb(255,255,0),rgb(255,255,0), rgb(0,255,0),rgb(0,255,0)
   
   rem empty bit
   ink rgb(0,24,35),0
   box x+width*P#, y, x+width, y+height
   
   rem highlight
   c1 = 0xCCFFFFFF
   c2 = 0x33FFFFFF   
   box x, y, x+width, y+height*0.5, c2,c1,c2,c1
endfunction



REM **************************************************
REM Gracefully swiped from Ric!
REM **************************************************
function createsound(name$,soundnumber,frequency#,length#,loudness#,bend#,decay#,vibratospeed#,vibratodepth#,tremelospeed#,tremelodepth#,attack#)

   outWord as word
   dword1 as dword: dword2 as dword: dword3 as dword: dword4 as dword
   dword5 as dword: dword6 as dword: dword7 as dword

   samples=int((length#/1000)*44100)

   if memblock exist(1) then delete memblock 1
   make memblock 1,samples*2+28

   ` write 28 memblock header bytes
   dword1=1      ` gg query: is this the number of channels?
   dword2=2      ` gg query: is this the number of bytes per sample?
   dword3=22050  ` gg query: seems to be half the number of samples per second - why?
   dword4=88200  ` gg query: is this the number of bytes per second?
   dword5=4      ` gg query: what does this represent?
   dword6=16     ` gg query:     (ditto)            ?
   dword7=0      ` gg query:     (ditto)            ?

   position=0
   write memblock dword 1, position, dword1 : inc position,4
   write memblock dword 1, position, dword2 : inc position,4
   write memblock dword 1, position, dword3 : inc position,4
   write memblock dword 1, position, dword4 : inc position,4
   write memblock dword 1, position, dword5 : inc position,4
   write memblock dword 1, position, dword6 : inc position,4
   write memblock dword 1, position, dword7 : inc position,4

   rem generate and write wave
   riseinloudness#=loudness#
   for x=1 to samples
      outInteger=int(sin((x/122.5)*(frequency#+vibratodepth#*sin(theta#)))*(loudness#-fallinloudness#-riseinloudness#+tremelodepth#*sin(phi#)))*3.0
      if outInteger <-32767 then outInteger=-32767  ` gg query: is this the valid range?
      if outInteger>32767 then outInteger=32767     ` gg query:       (ditto)          ?
      outWord=outInteger
      inc theta#,vibratospeed#
      inc phi#,tremelospeed#
      dec frequency#,bend#

      if fallinloudness#<loudness#
         inc fallinloudness#,decay#
      endif

      if riseinloudness#>0
         dec riseinloudness#,attack#
      endif

      write memblock word 1, position, outWord : inc position,2
   next x

   if sound exist(soundnumber)=1 then delete sound soundnumber

   make sound from memblock 999, 1
   clone sound soundnumber, 999

   delete sound 999
   ` memblock no longer required
   delete memblock 1

endfunction



REM ***********************************************************************************************
REM ***********************************************************************************************
REM 
REM	                                    ENHANCED 2D COMMANDS
REM
REM ***********************************************************************************************
REM ***********************************************************************************************



REM **************************************************
REM Fills circle with center [cx1,cy1] and radius r1
REM with a radial gradient starting from [cx2,cy2] and
REM a radius of r2.
REM **************************************************
function gradientFillCircle(cx1,cy1,r1,cx2,cy2,r2,gradient1,gradient2)
   for x = cx1-r1 to cx1+r1
      for y = cy1-r1 to cy1+r1
         if (x-cx1)^2 + (y-cy1)^2 <= r1^2
            p# = ((cx2-x)^2 + (cy2-y)^2+0.0) / r2^2
            if p# > 1 then p#=1.0
            ink getTransitionalColor(gradient1,gradient2,p#),0
            box x,y,x+1,y+1
         endif
      next y
   next x
endfunction



REM **************************************************
REM Draws an anti-aliased circle with alpha values
REM Based on Xiaolin Wu method
REM Unlike the above method, this uses true alpha
REM values but is slower
REM **************************************************
function E2DC_Circle_AA_Alpha(cx as integer, cy as integer, r as integer, color as dword)
	local alpha1 as dword
	local alpha2 as dword
	
	red = rgbr(color)
	green = rgbg(color)
	blue = rgbb(color)
	
	x = r
	xx = r
	y = -1
	yy = -1
	t# = 0
	
	while x > y
		inc y
		cur_dist# = E2DC_Distance#(r, y)
		if cur_dist# < t# then dec x

		rem anti-aliased pixels inside the circle
		c = 127*cur_dist#	: alpha1 = E2DC_ARGB(c, red, green, blue)
		rem anit-aliased pixels outside the circle
		c = 127 - c 		: alpha2 = E2DC_ARGB(c, red, green, blue)
		
		rem octant 1
		box cx-y,   cy-x,cx-y+1,   cy-x+1,   color, color, color, color
		box cx-y,   cy-x-1,cx-y+1,   cy-x, alpha2, alpha2, alpha2, alpha2
		box cx-y,   cy-x+1,cx-y+1,   cy-x+2, alpha1, alpha1, alpha1, alpha1
		rem octant 2
		box cx-x,   cy-y,cx-x+1,   cy-y+1,   color, color, color, color
		box cx-x-1, cy-y, cx-x, cy-y+1,  alpha2, alpha2, alpha2, alpha2
		box cx-x+1, cy-y,cx-x+2, cy-y+1,   alpha1, alpha1, alpha1, alpha1
		rem octant 3
		box cx-x,   cy+y,cx-x+1,   cy+y+1,   color, color, color, color
		box cx-x-1, cy+y, cx-x, cy+y+1,  alpha2, alpha2, alpha2, alpha2
		box cx-x+1, cy+y,cx-x+2, cy+y+1,   alpha1, alpha1, alpha1, alpha1
		rem octant 4
		box cx-y,   cy+x, cx-y+1,   cy+x+1,  color, color, color, color
		box cx-y,   cy+x+1,cx-y+1,   cy+x+2, alpha2, alpha2, alpha2, alpha2
		box cx-y,   cy+x-1,cx-y+1,   cy+x, alpha1, alpha1, alpha1, alpha1
		rem octant 5
		box cx+y,   cy+x,cx+y+1,   cy+x+1,   color, color, color, color
		box cx+y,   cy+x-1,cx+y+1,   cy+x, alpha1, alpha1, alpha1, alpha1
		box cx+y,   cy+x+1,cx+y+1,   cy+x+2, alpha2, alpha2, alpha2, alpha2
		rem octant 6
		box cx+x,   cy+y,cx+x+1,   cy+y+1,   color, color, color, color
		box cx+x-1, cy+y,cx+x, cy+y+1,   alpha1, alpha1, alpha1, alpha1
		box cx+x+1, cy+y,cx+x+2, cy+y+1,   alpha2, alpha2, alpha2, alpha2
		rem octant 7
		box cx+x,   cy-y, cx+x+1,   cy-y+1,  color, color, color, color
		box cx+x-1, cy-y,cx+x, cy-y+1,   alpha1, alpha1, alpha1, alpha1
		box cx+x+1, cy-y,cx+x+2, cy-y+1,   alpha2, alpha2, alpha2, alpha2
		rem octant 8
		box cx+y,   cy-x,cx+y+1,   cy-x+1,   color, color, color, color
		box cx+y,   cy-x-1,cx+y+1,   cy-x, alpha2, alpha2, alpha2, alpha2
		box cx+y,   cy-x+1,cx+y+1,   cy-x+2, alpha1, alpha1, alpha1, alpha1
		
		t# = cur_dist#
	endwhile
endfunction



REM **************************************************
REM Returns fractional part of distance
REM   * Needed for Xiaolin Wu functions
REM **************************************************
function E2DC_Distance#(a, b)
	real# = sqrt(a^2 - b^2)
	d# = ceil(real#) - real#
endfunction d#



REM **************************************************
REM Returns a linear interpolated color between base
REM color and target color. Percent ranges from 0 to 1
REM **************************************************
function getTransitionalColor(base, target, percent#)
   br = rgbr(base)
   bg = rgbg(base)
   bb = rgbb(base)
   tr = rgbr(target)
   tg = rgbg(target)
   tb = rgbb(target)
   tr = br + (tr-br)*percent#
   tg = bg + (tg-bg)*percent#
   tb = bb + (tb-bb)*percent#
   color = rgb(tr,tg,tb)
endfunction color



REM **************************************************
REM Xiaolin Wu's line algorithm.
REM **************************************************
function E2DC_Line_AA_ALPHA(x1, y1, x2, y2, color as dword)
	local dx as float
	local dy as float
	local xend as float
	local yend as float
	local xgap as float
	local ygap as float
	local xpxl1 as float
	local ypxl1 as float
	local xpxl2 as float
	local ypxl2 as float
	local intery as float
	local interx as float
        
	red   = rgbr(color)
	green = rgbg(color)
	blue  = rgbb(color)
	
	dx = x2-x1
	dy = y2-y1
        
	if abs(dx) > abs(dy)
		rem handle horizontal lines
		if x2 < x1
			ax = x1                 
			x1 = x2
			x2 = ax
			ay = y1
			y1 = y2
			y2 = ay
		endif
		gradient# = dy / dx
                
		rem handle first endpoint
		xend = ceil(x1)
		yend = y1 + gradient# * (xend-x1)
		xgap = 1.0 - fract#(x1 + 0.5)
		xpxl1 = xend : `used in main loop
		ypxl1 = int(yend)
		f# = 1-fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1, xpxl1+1, ypxl1+1, c, c, c, c
		rem brightness: fract#(yend)*xgap
		f# = fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1+1, xpxl1+1, ypxl1+2, c, c, c, c
		intery = yend + gradient# : `first y-intersection for main loop

		rem handle second endpoint
		xend = ceil(x2)
		yend = y2 + gradient# * (xend-x2)
		xgap = 1.0 - fract#(x2 + 0.5)
		xpxl2 = xend : `used in main loop
		ypxl2 = int(yend)
		f# = 1-fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2, xpxl2+1, ypxl2+1, c, c, c, c
		f# = fract#(yend)*xgap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2+1, xpxl2+1, ypxl2+2, c, c, c, c

		rem main loop
		a = xpxl1+1
		b = xpxl2-1
		for x = a to b
			f# = 1-fract#(intery) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box x, intery, x+1, intery+1, c, c, c, c
			f# = fract#(intery) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box x, intery+1, x+1, intery+2, c, c, c, c
			intery = intery + gradient#
		next x
                
	else
		rem handle vertical lines
		if y2 < y1
			ax = x1
			x1 = x2
			x2 = ax
			ay = y1
			y1 = y2
			y2 = ay
		endif
        
        gradient# = dx / dy

		rem handle first endpoint
		yend = ceil(y1)
		xend = x1 + gradient# * (yend-y1)
		ygap = 1.0 - fract#(y1 + 0.5)
		xpxl1 = int(xend)
		ypxl1 = yend            
		f# = 1-fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1,  xpxl1+1, ypxl1+1, c, c, c, c
		intery = intery + gradient#
		f# = fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl1, ypxl1+1, xpxl1+1, ypxl1+2, c, c, c, c
		
		interx = xend + gradient# : `first y-intersection for main loop
		
		rem handle second endpoint
		yend = ceil(y2)
		xend = x2 + gradient# * (yend-y2)
		ygap = fract#(y2 + 0.5)
		xpxl2 = int(xend)
		ypxl2 = yend
		f# = 1-fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2, xpxl2+1, ypxl2+1, c, c, c, c
		f# = fract#(xend)*ygap : `brightness
		alpha = 255*f#
		c = E2DC_ARGB(alpha, red, green, blue)
		box xpxl2, ypxl2+1, xpxl2+1, ypxl2+2, c, c, c, c
        
		rem main loop
		a = ypxl1+1
		b = ypxl2-1
		for y = a to b                  
			f# = 1-fract#(interx) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box interx, y, interx+1, y+1, c, c, c, c
			f# = fract#(interx) : `brightness
			alpha = 255*f#
			c = E2DC_ARGB(alpha, red, green, blue)
			box interx+1, y, interx+2, y+1, c, c, c, c
			interx = interx + gradient#
		next y
	endif
endfunction



REM **************************************************
REM quicker dot function
REM **************************************************
function E2DC_Dot(x as integer, y as integer, color as dword )
   if x > 0 and x < screen width() and y > 0 and y < screen height()
      offset = get pixels pointer()
      pitch = get pixels pitch()
      bitsPerPixel = bitmap depth(0)/8
      pointer = offset + y*pitch + x*bitsPerPixel
      *pointer = color
   endif
endfunction



REM **************************************************
REM Draws a filled-in circle
REM **************************************************
function E2DC_Fill_Circle(x,y,r)
   for yy = y-r to y
      for xx = x-r to x
         d# = (xx-x)*(xx-x) + (yy-y)*(yy-y)
         if d# <= r*r
            box xx,yy,x+(x-xx)+1,yy+1
            if yy <> y then box xx,y+(y-yy),x+(x-xx)+1,y+(y-yy)+1
            exit
         endif
      next xx
   next yy
endfunction


REM **************************************************
REM Just a little helper function
REM **************************************************
function fract#(x as float)
        a# = x - int(x)
endfunction a#



REM **************************************************
REM Returns a color with an alpha value
REM **************************************************
function E2DC_ARGB(a,r,g,b)
	local c as dword
	c = (a*16777216)+(r*65536)+(g*256)+b
endfunction c

Rem Project: Mission Divinity
Rem Created: Saturday, May 28, 2011

//set types and data
//display mode type
type dmstat
 w as word
 h as word
 d as byte
 l as word
 t as word
endtype

//self explanitory
type coord
 x as word
 y as word
endtype

//safe zones type
type flat
 x1 as word
 x2 as word
 mult as byte
endtype

//ground type
type path
 x1 as word
 y1 as word
 x2 as word
 y2 as word
endtype

//set screen
scrn as dmstat
scrn.w = 1280
scrn.h = 800
scrn.d = 32

set display mode scrn.w , scrn.h , scrn.d : sync on : sync
scrn.w , scrn.h

//set math and screen mods
if scrn.h < 768
 center text scrn.w / 2 , scrn.h / 2 , "Sorry, native screen resolution must have a height of 768 or higher."
 sync
 wait key
 end
endif

scrn.l = ( ( scrn.w - 1000 ) / 2 ) - 1
scrn.t = ( ( scrn.h - 800 ) / 2 ) - 1

if scrn.h <= 800 then scrn.t = 0

//create lander and arrow sprites

//lander
//cabin
ink rgb( 255 , 255 , 255 ) , 0
line 6 , 0 , 9 , 0
line 6 , 9 , 9 , 9
line 3 , 3 , 3 , 6
line 12 , 3 , 12 , 6
line 3 , 3 , 6 , 0
line 9 , 0 , 12 , 3
line 12 , 6 , 9 , 9
line 6 , 9 , 3 , 6
//left leg
ink rgb( 255 , 255 , 255 ) , 0
line 5 , 11 , 2 , 14
line 0 , 15 , 3 , 15
//right leg
line 11 , 12 , 14 , 15
line 12 , 15 , 15 , 15
//systems1
line 5 , 11 , 5 , 15
//systems2
line 10 , 11 , 10 , 15
//systems3
line 5 , 14 , 10 , 14
//body
box 3 , 9 , 13 , 12
ink rgb( 0 , 0 , 0 ) , 0
line 4 , 10 , 11 , 10
get image 1 , 0 , 0 , 16 , 16
ink rgb( 255 , 255 , 255 ) , 0

//flame
line 5 , 15 , 7 , 30
line 10 , 15 , 8 , 30
get image 2 , 0 , 0 , 16 , 32

//arrow
cls
line 19 , 0 , 9 , 0
line 14 , 5 , 19 , 0
line 14 , 5 , 9 , 0
line 14 , 15 , 5 , 6
line 14 , 15 , 24 , 5
line 5 , 6 , 23 , 6
line 14 , 29 , 0 , 15
line 14 , 29 , 29 , 14
line 0 , 15 , 28 , 15
get image 3 , 0 , 0 , 32 , 32
sprite 1 , -40 , -40 , 3
rotate sprite 1 , 90
cls
paste sprite 1 , 31 , 0
get image 4 , 0 , 0 , 32 , 32
delete sprite 1
cls

//load ground data
dim pathvec( 119 ) as path

read pathvec( 0 ).x1
read pathvec( 0 ).y1
read pathvec( 0 ).x2
read pathvec( 0 ).y2

for vn = 1 to 119
 pathvec( vn ).x1 = pathvec( vn - 1 ).x2
 pathvec( vn ).y1 = pathvec( vn - 1 ).y2
 read pathvec( vn ).x2
 read pathvec( vn ).y2
next vn

//find ground heights
dim xheit(999)
xh = 0

for pn = pathvec( xh ).x1 to pathvec( xh ).x2
 xheit( pn ) = terrain( pathvec( xh ).x1 , pathvec( xh ).y1 , pathvec( xh ).x2 , pathvec( xh ).y2 , pn )
next pn

for xh = 1 to 119
 for pn = pathvec( xh ).x1 + 1 to pathvec( xh ).x2
  xheit( pn ) = terrain( pathvec( xh ).x1 , pathvec( xh ).y1 , pathvec( xh ).x2 , pathvec( xh ).y2 , pn )
 next pn
next xh

//set safe zones
dim safezone( 22 ) as flat

for fn = 0 to 22
 read safezone( fn ).x1
 read safezone( fn ).x2
 read safezone( fn ).mult
next fn

//set stars
ranseed()
dim str( 449 ) as coord

for str = 0 to 449
 x = rnd( 999 )
 y = rnd( xheit( x ) - 3 )
 str( str ).x = x
 str( str ).y = y
next str

//set death phrases
dim crshdeth( 11 ) as string
crshdeth( 0 ) = "You are going fast enough to make quite a large hole!"
crshdeth( 1 ) = "You now have a crater named after you!"
crshdeth( 2 ) = "You have become a smudge on the lunar surface!"
crshdeth( 3 ) = "Let's just hope there's enough of you to be burried on Earth!"
crshdeth( 4 ) = "The last thing mission control hears is your screams!"
crshdeth( 5 ) = "They won't soon forget your name!"
crshdeth( 6 ) = "A slight miscalculation has turned into a major problem!"
crshdeth( 7 ) = "You have now come down with a nasty case of mortality!"
crshdeth( 8 ) = "A novice astronomer sees a glint through his telescope!"
crshdeth( 9 ) = "He has no knowledge of your mission and shrugs it off!"
crshdeth( 10 ) = "Sadly, you didn't survive the impact with the lunar surface!"
crshdeth( 11 ) = "Although, your data will save lives on a future mission!"

//main loop
//set data
fuel# = 3000
score# = 0
stop = 0
sprite 1 , -50 , -50 , 1
sprite 2 , -50 , - 50 , 3
sprite 3 , -50 , -50 , 4
offset sprite 1 , 8 , 8
offset sprite 2 , 16 , 16
offset sprite 3 , 16 , 16

//set and reset data
repeat
 ranseed()
 land = 0
 deth = -1
 pow# = -1
 rot# = 0
 sprtx# = rnd( 800 ) + 100 + scrn.l
 sprty# = scrn.t + 100
 xvel# = 0
 yvel# = 0
 tstrt = 0
 tstp = 0
 negfuel# = 0
 set text size 50

 //play loop
 repeat
   ranseed()
   tstrt = timer()

   //check controls
   if mouseclick() = 1
    if lc = 0 then pow# = 0
    inc pow# , mousemovex() / 3
    if pow# > 100 then pow# = 100
    if pow# < 0 then pow# = 0
    lc = 1
   endif
   if mouseclick() = 2 then end
   if keystate( 32 ) = 1 and dk = 0
    inc rot# , 22.5
    dk = 1
   endif
   if keystate( 30 ) = 1 and ak = 0
    dec rot# , 22.5
    ak = 1
   endif
   if rot# < -90 then rot# = -90
   if rot# > 90 then rot# = 90
   rotate sprite 1 , rot#

   //clear all inputs
   if keystate( 32 ) = 0 then dk = 0
   if keystate( 30 ) = 0 then ak = 0
   if mouseclick() = 0
    lc = 0
    pow# = -1
   endif

   //check altitude/fuel/x velocity/y velocity and set vars
   if pow# > -1 then fuel# = fuel# - ( .25 * ( pow# / 100 ) )
   if fuel# < 0
    pow# = -1
    fuel# = 0
   endif
   yvel# = yvel# + .01
   if pow# > -1  and fuel# > 0
    yvel# = yvel# - ( .04 * ( ( pow# - ( abs( rot# ) * 1.1111111112 ) ) ) / 100 )
    xvel# = xvel# + ( .01 * ( rot# / 90 ) )
   endif
   if yvel# > 1.17 then yvel# = 1.17
   if yvel# < -1.17 then yvel# = -1.17
   sprty# = sprty# + yvel#
   sprtx# = sprtx# + xvel#
   if sprtx# > 999 + scrn.l then sprtx# = 999 + scrn.l
   if sprtx# < scrn.l then sprtx# = scrn.l
   if sprty# + 8 > xheit( int( sprtx# ) - scrn.l ) then sprty# = xheit( int( sprtx# ) - scrn.l ) - 8
   if sprty# < scrn.t then sprty# = scrn.t
   alt# = ( xheit( int( sprtx# ) - scrn.l ) * 3 ) - ( int( sprty# ) * 3 )
   
   //check for deaths/landings
   if sprtx# = scrn.l or sprtx# = 999 + scrn.l then deth = 1
   if sprty# = scrn.t then deth = 2
   if sprty# >= xheit( int ( sprtx# ) - scrn.l ) - 8
    if checkzone( sprtx# - scrn.l ) > 0 and rot# = 0 and abs( int( yvel# * 60 ) ) < 25 and abs( int( xvel# * 60 ) ) < 11
     land = 1
     mult = checkzone( sprtx# - scrn.l )
     if abs( int( yvel# * 60 ) ) <= 16 then scre = 50
     if abs( int( yvel# * 60 ) ) > 16 then scre = 25
     scre# = score( mult , scre )
    endif
    if checkzone( sprtx# - scrn.l ) = 0 or ( checkzone( sprtx# - scrn.l ) > 0 and ( rot# <> 0 or abs( int( yvel# * 60 ) ) > 24 or abs( int( xvel# * 60 ) ) > 10 ) )
     deth = 0
    endif
   endif

   //set text for display
   //score
   if score# >= 0 then score$ = "   " + str$( score# )
   if score# >= 10 then score$ = "  " + str$( score# )
   if score# >= 100 then score$ = " " + str$( score# )
   if score# >= 1000 then score$ = str$( score# )
   //fuel
   if int( fuel# ) >= 0 then fuel$ = "   " + str$( int( fuel# ) )
   if int( fuel# ) >= 10 then fuel$ = "  " + str$( int( fuel# ) )
   if int( fuel# ) >= 100 then fuel$ = " " + str$( int( fuel# ) )
   if int( fuel# ) >= 1000 then fuel$ = str$( int( fuel# ) )
   //altitude
   if alt# >= 0 then alt$ = "   " + str$( alt# )
   if alt# >= 10 then alt$ = "  " + str$( alt# )
   if alt# >= 100 then alt$ = " " + str$( alt# )
   if alt# >= 1000 then alt$ = str$( alt# )
   //horiz. speed
   if abs( int( xvel# * 60 ) ) >= 0 then xvel$ = "   " + str$( abs( int( xvel# * 60 ) ) )
   if abs( int( xvel# * 60 ) ) >= 10 then xvel$ = "  " + str$( abs( int( xvel# * 60 ) ) )
   if abs( int( xvel# * 60 ) ) >= 100 then xvel$ = " " + str$( abs( int( xvel# * 60 ) ) )
   //vert. speed
   if abs( int( yvel# * 60 ) ) >= 0 then yvel$ = "   " + str$( abs( int( yvel# * 60 ) ) )
   if abs( int( yvel# * 60 ) ) >= 10 then yvel$ = "  " + str$( abs( int( yvel# * 60 ) ) )

  cls

   //text
   ink rgb( 255 , 255 , 255 ) , 0
   text scrn.l + 10 , scrn.t , "SCORE"
   text scrn.l + 10 , scrn.t + 39 , "FUEL"
   text scrn.l + 285 , scrn.t , "THRUSTER"
   if pow# = -1 then center text scrn.l + 409 , scrn.t + 39 , "0%"
   if pow# > -1
    if pow# = 100 then powt# = scrn.l + 385
    if pow# > 9 and pow# < 100 then powt# = scrn.l + 397
    if pow# < 10 then powt# = scrn.l + 409
    center text powt# , 39 , str$( pow# ) + "%"
   endif
   text scrn.l + 535 , scrn.t , "ALTITUDE"
   text scrn.l + 535 , scrn.t + 39 , "HORIZ. SPEED"
   text scrn.l + 535 , scrn.t + 79 , "VERT. SPEED"
   text scrn.l + 153 , scrn.t , score$
   text scrn.l + 153 , scrn.t + 39 , fuel$
   text scrn.l + 847 , scrn.t , alt$
   text scrn.l + 847 , scrn.t + 39 , xvel$
   text scrn.l + 847 , scrn.t + 79 , yvel$

   if ( xheit( int( sprtx# - scrn.l ) ) * 3 ) - ( int( sprty# ) * 3 ) > 400

   //ground and sky art
   for vn = 0 to 119
    line pathvec( vn ).x1 + scrn.l , pathvec( vn ).y1 + scrn.t , pathvec( vn ).x2 + scrn.l , pathvec( vn ).y2 + scrn.t
   next vn
   lock pixels
   for str = 0 to 224
    dot str( str ).x + scrn.l , str( str ).y + scrn.t
   next str
   unlock pixels
   for str = 225 to 374
    box str( str ).x + scrn.l , str( str ).y + scrn.t , str( str ).x + scrn.l + 2 , str( str ).y+ scrn.t + 2
   next str
   for str = 375 to 449
    box str( str ).x + scrn.l , str( str ).y + scrn.t , str( str ).x + scrn.l + 3 , str( str ).y + scrn.t + 3
   next str

   //sprites
   if pow# < 1  then sprite 1 , -50 , -50 , 1
   if pow# > 0 and fuel# > 0 then sprite 1 , -50 , -50 , 2
   if yvel# > 0 then uda# = 0
   if yvel# < 0 then uda# = 180
   if xvel# > 0 then lra# = 180
   if xvel# < 0 then lra# = 0
   rotate sprite 2 , uda#
   rotate sprite 3 , lra#
   paste sprite 3 , scrn.l + 973 , scrn.t + 64 `right/left arrow
   paste sprite 2 , scrn.l + 973 , scrn.t + 104 `up/down arrow
   paste sprite 1 , sprtx# , sprty# `ship

   endif
   
   if ( xheit( int( sprtx# - scrn.l ) ) * 3 ) - ( int( sprty# ) * 3 ) <= 400

   //ground and sky art zoomed
   for vn = 0 to 119
    line ( pathvec( vn ).x1 * 3 ) - ( ( sprtx# - scrn.l ) * 3 ) + 500 + scrn.l , ( ( ( pathvec( vn ).y1 - 514 ) * 3 ) - ( ( ( sprty# - 514 ) * 3 ) + 16 ) ) + 400 + scrn.t  , ( pathvec( vn ).x2 * 3 ) - ( ( sprtx# - scrn.l ) * 3 ) + 500 + scrn.l , ( ( ( pathvec( vn ).y2 - 514 ) * 3 ) - ( ( ( sprty# - 514 ) * 3 ) + 16 ) ) + 400 + scrn.t
   next vn

   //sprites zoomed
   if pow# < 1  then sprite 1 , -50 , -50 , 1
   if pow# > 0 and fuel# > 0 then sprite 1 , -50 , -50 , 2
   if yvel# > 0 then uda# = 0
   if yvel# < 0 then uda# = 180
   if xvel# > 0 then lra# = 180
   if xvel# < 0 then lra# = 0
   rotate sprite 2 , uda#
   rotate sprite 3 , lra#
   paste sprite 3 , scrn.l + 973 , scrn.t + 64 `right/left arrow
   paste sprite 2 , scrn.l + 973 , scrn.t + 104 `up/down arrow
   paste sprite 1 , scrn.l + 500 , scrn.t + 400 `ship

   endif

   //edges of screen
   ink rgb( 10 , 10 , 10 ) , 0
   box 0 , 0 , scrn.l , scrn.h
   box scrn.l + 1000 , 0 , scrn.w , scrn.h
   box 0 , 0 , scrn.w , scrn.t
   box 0 , scrn.t + 800 , scrn.w , scrn.h

  sync

   //balance fps to ~30
   tstp = timer()
   fps = tstp - tstrt
   if fps < 32 then wait 32 - fps

 until deth > -1 or land > 0

 cls
 
 ink rgb( 255 , 255 , 255 ) , 0
 set text size 30
 ranseed()
 
 if land = 1
  inc score# , scre#
  if scre = 50 then center text scrn.w / 2 , ( scrn.h / 2 ) - 15 , "PERFECT LANDING!"
  if scre = 25 then center text scrn.w / 2 , ( scrn.h / 2 ) - 15 , "HARD LANDING!"
  center text scrn.w / 2 , ( scrn.h / 2 ) + 15 , "+" + str$( scre# )
 endif

 if deth > -1

 if deth = 0
  msg = rnd( 5 ) * 2
  center text scrn.w / 2 , ( scrn.h / 2 ) - 30 , crshdeth( msg )
  center text scrn.w / 2 , scrn.h / 2 , crshdeth( msg + 1 )
 endif

 if deth = 1
  center text scrn.w / 2 , ( scrn.h / 2 ) - 30 , "You veer off course and crash on the dark side of the moon."
  center text scrn.w / 2 , scrn.h / 2 , "Your remains won't be found until 2162."
 endif

 if deth = 2
  center text scrn.w / 2 , ( scrn.h / 2 ) - 30 , "You are ejected from the moon's gravity and crash into Earth."
  center text scrn.w / 2 , scrn.h / 2 , "Your loved ones have to have a closed casket ceremony."
 endif

  negfuel# = rnd( 150 ) + 200
  center text scrn.w / 2 , ( scrn.h / 2 ) + 30 , "You lost " + str$( negfuel# ) + " units of fuel."
  dec fuel# , negfuel#
  
 endif

 ink rgb( 10 , 10 , 10 ) , 0
 box 0 , 0 , scrn.l , scrn.h
 box scrn.l + 1000 , 0 , scrn.w , scrn.h
 box 0 , 0 , scrn.w , scrn.t
 box 0 , scrn.t + 800 , scrn.w , scrn.h

 sync
 if deth > -1 then wait 8000
 if land = 1 then wait 3000

 if fuel# < 1 then stop = 1

until stop = 1

cls

ink rgb( 255 , 255 , 255 ) , 0
center text scrn.w / 2 , ( scrn.h / 2 ) - 30 , "YOUR FINAL SCORE IS:"
center text scrn.w / 2 , ( scrn.h / 2 ) , score$
center text scrn.w / 2 , scrn.t + 700 , "PRESS ANY KEY TO EXIT"

ink rgb( 10 , 10 , 10 ) , 0
box 0 , 0 , scrn.l , scrn.h
box scrn.l + 1000 , 0 , scrn.w , scrn.h
box 0 , 0 , scrn.w , scrn.t
box 0 , scrn.t + 800 , scrn.w , scrn.h

sync

wait key

end

function ranseed()
 rt# = timer() + mousex() + mousey() + rnd( 999999 )
 randomize rt#
endfunction rt#

function round( in# , d ) `in# is value to be rounded, d is number of points desired
 if d > 5 then d = 5 `avoids errors caused by limited # of points in reals
 if 10 ^ d <> 0 then in# = in# * ( 10 ^ d ) `raises right # of points
 if in# - int( in# ) < .5 then in# = floor( in# ) `round up
 if in# - int( in# ) >= .5 then in# = ceil( in# ) `round down
 if 10 ^ d <> 0 then in# = in# / ( 10 ^ d ) `lowers to original # of points
endfunction in# `outputs newly rounded value

function terrain( x1# , y1# , x2# , y2# , xmid# )
 ymid# = ( xmid# - x1# ) * ( ( y2# - y1# ) / ( x2# - x1# ) ) + y1#
endfunction ymid#

function checkzone( x# )
 sz = 0
 repeat
  inc sz
 until x# + 2 < safezone( sz ).x1
 if x# + 2 <= safezone( sz - 1 ).x2 and x# - 3 >= safezone( sz - 1 ).x1
  zm = safezone( sz - 1 ).mult
 else
  zm = 0
 endif
endfunction zm

function score( zm , ls )
 scor = ls * zm
endfunction scor

//ground
data 0,599,12,593,26,590,39,596,53,596,60,585,73,579,82,584,89,598,91,620,97,639,98,660,103,666,113,666,116,678,127,685
data 128,691,136,691,139,699,151,699,157,713,159,732,165,746,197,746,212,739,219,722,233,712,245,717,255,717,261,731
data 293,731,309,717,319,698,323,670,334,659,343,642,346,625,354,625,358,604,367,594,382,598,395,598,406,586,412,556
data 422,544,427,528,436,524,442,514,467,514,474,528,475,561,481,588,483,611,492,611,495,624,502,630,502,641,510,641
data 511,659,519,679,529,684,532,690,537,692,541,698,556,698,564,687,572,686,575,680,583,678,586,671,592,671,601,655
data 604,633,614,624,628,624,633,613,634,599,642,597,652,597,662,602,673,594,680,581,690,574,704,580,718,569,729,574
data 733,595,741,613,751,613,756,628,766,639,795,639,811,625,817,610,826,591,835,588,838,575,847,575,851,568,855,568
data 860,561,861,552,867,545,878,545,888,530,900,534,906,557,906,579,912,604,923,604,927,626,937,629,946,629,948,639
data 957,639,957,651,963,670,974,680,986,674,992,655,999,650

//safe zones
data 39,53,4,103,113,5,128,118,5,139,151,4,165,197,1,243,255,4,261,293,1,346,354,5,379,395,3,442,467,4,483,492,5
data 503,510,5,541,556,4,586,592,5,613,628,3,639,653,4,741,751,4,766,795,1,838,847,5,867,878,4,912,923,4,937,946,5
data 948,957,5

FLAG_SEGMENT_WIDTH = 1
FLAG_WIDTH# = 400

Set Display Mode 800, 600, 32
Set Window On
Set Window Position 20, 20
Backdrop On
Color Backdrop 0

Sync On
Sync Rate 60

Type Vec2D
    x As Float
    y As Float
EndType

numSegments = (FLAG_WIDTH#/FLAG_SEGMENT_WIDTH)

Dim flagSegs(numSegments) As Integer

Cls
DrawFlag(FLAG_WIDTH#)
height# = FLAG_WIDTH#/1.9

For i = 0 To numSegments
    flagSegs(i) = FreeImage()
    Get Image flagSegs(i), i*FLAG_SEGMENT_WIDTH, 0, (i*FLAG_SEGMENT_WIDTH)+FLAG_SEGMENT_WIDTH, height#+1, 1
Next i

flagX = 50
flagY = 50
Do
    Inc wavey, 4
    For i = 0 To numSegments
        Paste Image flagSegs(i), flagX + (i*FLAG_SEGMENT_WIDTH), flagY + Sin(wavey-i)*6.0
    Next i
    
    Text 5, 5, Str$(Screen FPS())
    Sync
Loop

Function DrawFlag(w#)
    h# = w# / 1.9
    bw# = h# * 0.76
    bh# = h# * 0.5385
    starVSpace# = h# * 0.054
    starHSpace# = h# * 0.063
    starDiam# = h# * 0.0616
    stripeH# = h# * 0.0769
    blue = RGB(0,0,125)
    red = RGB(175,0,0)
    white = RGB(255,255,225)
   
    Box 1, 1, w#+1, h#+1, red, red, red, red
    For i = 1 To 12 Step 2
        Box 1, (stripeH#*i)+1, w#+1, ((stripeH#*i)+stripeH#)+1, white, white, white, white
    Next i
    
    Box 1, 1, bw#+1, bh#+1, blue, blue, blue, blue
    
    For sx = 1 To 5
        For sy = 1 To 4
            DrawFivePointStar(sx*(starHSpace#*2.0), sy*(starVSpace#*2.0), starDiam#*0.33, white)
        Next sy
    Next sx
    
    For sx = 0 To 5
        For sy = 0 To 4
            DrawFivePointStar(starHSpace# + (sx*(starHSpace#*2.0)), starVSpace#+(sy*(starVSpace#*2.0)), starDiam#*0.33, white)
        Next sy
    Next sx
        
EndFunction

Function FreeImage()
    For i = 1 To 65535
        If Image Exist(i) = 0 Then ExitFunction i
    Next i
EndFunction -1

Function DrawFivePointStar(x#, y#, radius#, color As Dword)
    Dim points(8) As Vec2D
    For i = 0 To 4 // First five in the points array are the tips of the star
        points(i).x = x# + Sin(i*(360/5))*radius#
        points(i).y = y# + Cos(i*(360/5)-180.0)*radius#
    Next i
    
    For i = 5 To 7 // These three are for the third point of each of the 
                   // three triangles required to draw the star
        points(i).x = x# + Sin(108+((i-5)*(360/5)))*(radius#*0.42)
        points(i).y = y# + Cos(108+((i-5)*(360/5)-180.0))*(radius#*0.42)     
    Next i
    
    yimTriangle(points(4).x, points(4).y, points(1).x, points(1).y, points(6).x, points(6).y, color, 1)
    yimTriangle(points(0).x, points(0).y, points(5).x, points(5).y, points(3).x, points(3).y, color, 1)
    yimTriangle(points(0).x, points(0).y, points(7).x, points(7).y, points(2).x, points(2).y, color, 1)
EndFunction

Function LineFunction(x1, y1, x2, y2, lineColor1 As Dword, lineColor2 As Dword)
    //** Line using DBP Dots (TIME TO GET YOURSElf A PLUGIN)
    yimLine(x1, y1, x2, y2, lineColor1)
    
    //** Advanced2D Line (FASTER)
    `a2Line x1, y1, x2, y2, lineColor1, lineColor2
    
    //** D3D_Func Line (FASTEST)
    `D3D_Line x1, y1, x2, y2, lineColor1, lineColor2
  
EndFunction

Function yimLine(x1, y1, x2, y2, color As Dword) // ******* Conversion from: http://www.blitzbasic.com/codearcs/codearcs.php?code=1465
    Lock Pixels
    Steep = (Abs(Y2-Y1) > Abs(X2-X1))
    If Steep
        Temp=X1
        X1=Y1
        Y1=Temp        
        Temp=X2
        X2=Y2
        Y2=Temp
    EndIf
    DeltaX = Abs(X2-X1)
    DeltaY = Abs(Y2-Y1)
    Error = 0
    DeltaError = DeltaY
    X = X1
    Y = Y1
    XStep = -1
    If X1<X2 Then XStep = 1
    YStep = -1
    If Y1<Y2 Then YStep = 1
    
    If Steep
        Dot Y, X, color
    Else
        Dot X, Y, color
    EndIf
    
    While X<>X2
        Inc X, XStep
        Inc Error, DeltaError
        If (Error << 1)>DeltaX
            Inc Y, YStep
            Error=Error-DeltaX
        EndIf
        If Steep
            Dot Y, X, color
        Else
            Dot X, Y, color
        EndIf
    EndWhile
    Unlock Pixels
EndFunction

Function yimTriangle(x1, y1, x2, y2, x3, y3, color As Dword, filled) // ******* Conversion from Axel Wheeler's post on: http://www.blitzbasic.com/Community/posts.php?topic=93985
    If filled
        Local Xa As Float
        Local Xb As Float
        Local Xc As Float
        Local Ya As Float
        Local Yb As Float
        Local Yc As Float
        
        Xa = x1
        Ya = y1
        Xb = x2
        Yb = y2
        Xc = x3
        Yc = y3
        
        If Yb<Ya
            Xtemp#=Xa
            Ytemp#=Ya
            Xa=Xb
            Ya=Yb
            Xb=Xtemp#
            Yb=Ytemp#
        EndIf
        
        If Yc<Ya 
            Xtemp#=Xa
            Ytemp#=Ya
            Xa=Xc
            Ya=Yc
            Xc=Xtemp#
            Yc=Ytemp#
        EndIf
        
        If Yc<Yb
            Xtemp#=Xb
            Ytemp#=Yb
            Xb=Xc
            Yb=Yc
            Xc=Xtemp#
            Yc=Ytemp#
        EndIf
        
        For y#=Ya To Yc
            If Yc=Ya Then Yc=Yc+.00001
            proportionA#=(y#-Ya)/(Yc-Ya)
            Xlong#=Xa+(Xc-Xa)*proportionA#
            
            If y#<Yb
                If Yb = Ya Then Yb = Yb + .00001
                ProportionB#=(y#-Ya)/(Yb-Ya)
                Xshort#=Xa+(Xb-Xa)*ProportionB#
            Else
                If Yc = Yb Then Yc = Yc+.00001
                ProportionB#=(y#-Yb)/(Yc-Yb)
                Xshort#=Xb+(Xc-Xb)*ProportionB#
            EndIf
            
            LineFunction(Xlong#, y#, Xshort#, y#, color, color)
        Next y#
    Else
        LineFunction(x1, y1, x2, y2, color, color)
        LineFunction(x2, y2, x3, y3, color, color)
        LineFunction(x3, y3, x1, y1, color, color)
    EndIf
EndFunction

backdrop on
color backdrop 0
  flag1=1
  pole1=2
  wind1=3
  gravity1=4
  
  create bitmap 1,256,128
  ink rgb(0,0,192),0
  box 0,0,255,127
  ink rgb(128,128,128),0
  for x=0 to 5
    line 0+x,0,255,127-x
    line 0,0+x,255-x,127
    line 255-x,0,0,127-x
    line 255,0+x,0+x,127   
  NEXT
  get image 1,0,0,255,127
  set current bitmap 0
  
  plen=40
  make object cylinder pole1,plen
  scale object pole1,2,100,2
  color object pole1,rgb(64,64,64)
  position object pole1,0,0,0
  
  mass#=1.0
  make cloth flag1
  generate rectangular cloth flag1,20.0,10.0,5,5,1
  set cloth mass flag1,mass#
  texture object flag1,1
  for x=0 to 35
    xoff#=(-5.0+(x mod 6))*2.0
    yoff#=int(x/6)
    fix cloth point to object flag1,x,pole1,0.0,plen-yoff#,xoff#-1.3
  next x
  set cloth elasticity flag1,1.0
  make wind effector wind1
  make gravity effector gravity1
  bind effector to object wind1,flag1
  bind effector to object gravity1,flag1
  set wind effector wind1,-5.0,0.0,0.0
  set gravity effector gravity1,0.0,-9.8,0.0
  set physics frame rate 30
  position camera 0,plen/2,-50
  point camera 0,plen/2,0
  free all cloth points flag1
  fix cloth point to object flag1,5,pole1,0.0,plen/2.0,-2
  fix cloth point to object flag1,35,pole1,0.0,plen/2.0-10,-2

  WHILE NOT ESCAPEKEY()
    update physics
    if leftkey()
      turn camera left 90
      move camera 1
      turn camera right 90  
    ENDIF
    if rightkey()
      turn camera right 90
      move camera 1
      turn camera left 90  
    ENDIF
    if upkey()
      move camera 1
    ENDIF
    if downkey()
      move camera -1
    ENDIF
   ENDWHILE


  unbind effector from object wind1,FLAG1
  unbind effector from object wind1,flag1
  unbind effector from object gravity1,flag1
  delete effector wind1
  delete effector gravity1
  delete cloth flag1
  physics garbage collect
  set physics max iterations 1
end