Sorry your browser is not supported!

code removed and an update placed in a later post

set display mode 320,240,32

sync on
sync rate 40
backdrop on
color backdrop 0
hide mouse
randomize timer()

paddle_X = screen width()/2         :  `X position of paddle (start centered of screen)
paddle_Width = 20                   :  `paddle's half width (if set to 20, total paddle width would be 40)
paddle_thickness = 5                :  `thickness of paddle
#constant INTERFACE_BORDER = 276    :  `x-intercept boundary marking off interface from game area
#constant MAX_ANGLE = 80            :  `max angle that paddle can reflect ball off


type vector2d
   x as float
   y as float
endtype

type toy
   position as vector2d
   oldPosition as vector2d
   direction as vector2d
   velocity as float
   radius as float
endtype

ball as toy


ball.position.x = 50
ball.position.y = 200
ball.direction.x = 0.5
ball.direction.y = -0.5
ball.velocity = 4
ball.radius = 3

type triangle
   x1 as float
   y1 as float
   x2 as float
   y2 as float
   x3 as float
   y3 as float
   alive as integer
endtype

type brick
   a as triangle
   b as triangle
endtype



dim map(11,5) as brick


   for x = 0 to 10
      for y = 1 to 5
         map(x,y).a.x1 = x*25
         map(x,y).a.y1 = y*15
         map(x,y).a.x2 = x*25
         map(x,y).a.y2 = (y+1)*15
         map(x,y).a.x3 = (x+1)*25
         map(x,y).a.y3 = (y+1)*15
         map(x,y).a.alive = 1

         map(x,y).b.x1 = x*25
         map(x,y).b.y1 = y*15
         map(x,y).b.x2 = (x+1)*25
         map(x,y).b.y2 = y*15
         map(x,y).b.x3 = (x+1)*25
         map(x,y).b.y3 = (y+1)*15
         map(x,y).b.alive = 1
      next y
   next x

rem temp variable
tri as triangle

null = make vector2(1)  :  `ball direction vector and reflection vector(after calculation)
null = make vector2(2)  :  `line normal



REPEAT

   rem record previous position
   ball.oldPosition.x = ball.position.x
   ball.oldPosition.y = ball.position.y

   gosub _handle_controls


   for x = 0 to 10
      for y = 1 to 5
         if map(x,y).a.alive = 1
            tri = map(x,y).a
            draw_triangle(tri.x1,tri.y1,tri.x2,tri.y2,tri.x3,tri.y3)
         endif
         if map(x,y).b.alive = 1
            tri = map(x,y).b
            draw_triangle(tri.x1,tri.y1,tri.x2,tri.y2,tri.x3,tri.y3)
         endif
      next y
   next x


   ball.position.x = ball.position.x + ball.direction.x*ball.velocity
   ball.position.y = ball.position.y + ball.direction.y*ball.velocity


   gosub _handle_ball_collisions

   circle ball.position.x, ball.position.y,ball.radius

   draw_paddle(paddle_X,paddle_Width)

   draw_interface()

   text 1,1,str$(screen fps())

   sync
UNTIL SPACEKEY()









rem handle paddle movement with mouse and handle paddle's boundaries
_handle_controls:
   paddle_X = paddle_x + mousemovex()/3
   if paddle_X-paddle_Width < 0 then paddle_X = paddle_Width
   if paddle_X+paddle_Width > interface_border then paddle_X = interface_border-paddle_Width
return


rem handles ball collision with paddle, play area boundaries, and brick objects
_handle_ball_collisions:

   rem if ball hits paddle
   if ball.position.y >= screen height()-(paddle_thickness + ball.radius)
      if ball.position.x >= paddle_X - paddle_Width AND ball.position.x <= paddle_X + paddle_Width
         angle# = 270 + ((ball.position.x-paddle_X) * MAX_ANGLE)/paddle_Width
         ball.direction.x = cos(angle#)
         ball.direction.y = sin(angle#)
      endif
   endif

   rem walls
   if ball.position.x <= ball.radius
      ball.position.x = ball.radius
      ball.direction.x = ball.direction.x*-1
   endif
   if ball.position.x >= INTERFACE_BORDER-ball.radius
      ball.position.x = INTERFACE_BORDER-ball.radius
      ball.direction.x = ball.direction.x*-1
   endif
   rem ceiling
   if ball.position.y <= ball.radius
      ball.position.y = ball.radius
      ball.direction.y = ball.direction.y*-1
   endif

   rem if ball drops below paddle
   if ball.position.y > screen height()
      ball.position.y = screen height()-1
      ball.direction.y = ball.direction.y*-1
   endif

   rem brick collision
   for x = 0 to 10
      for y = 1 to 5
         if map(x,y).a.alive = 1
            tri = map(x,y).a
            if triangle_collide#(ball,tri) > 0
               map(x,y).a.alive = 0
               calculate_reflection()
            endif
         endif
         if map(x,y).b.alive = 1
            tri = map(x,y).b
            if triangle_collide#(ball,tri) > 0
               map(x,y).b.alive = 0
               calculate_reflection()
            endif
         endif
      next y
   next x
return


rem calculates ball's reflection from brick(triangle)
rem assumes reflection surface vector was set and normalized (vector 2)
function calculate_reflection()
   set vector2 1, ball.direction.x, ball.direction.y
   dp# = dot product vector2(1,2)*2
   multiply vector2 2,dp#
   subtract vector2 1, 1, 2
   normalize vector2 1, 1
   ball.direction.x = x vector2(1)
   ball.direction.y = y vector2(1)
endfunction



rem returns a time value of set [0,1] of closest intersection between ball's velocity vector and triangle's sides
rem if intersection happens, calculates normal of reflection surface and stores in vector 2
rem returns -1 if no sides were hit
function triangle_collide#(b as toy, t as triangle)
   a# = _line_intersect(b.oldPosition.x,b.oldPosition.y,b.position.x,b.position.y,t.x1,t.y1,t.x2,t.y2)
   b# = _line_intersect(b.oldPosition.x,b.oldPosition.y,b.position.x,b.position.y,t.x1,t.y1,t.x3,t.y3)
   c# = _line_intersect(b.oldPosition.x,b.oldPosition.y,b.position.x,b.position.y,t.x2,t.y2,t.x3,t.y3)

   rem if a# is first intersection
   if a# < 1
      if a# < b# and a# < c#
         rem set normal of reflection surface
         set vector2 2, t.y2-t.y1,-(t.x2-t.x1)
         normalize vector2 2,2
         exitfunction a#
      endif
   else
      rem if b# is first intersection
      if b# < 1
         if b# < a# and b# < c#
            rem set normal of reflection surface
            set vector2 2, t.y1-t.y3,-(t.x1-t.x3)
            normalize vector2 2,2
            exitfunction b#
         endif
      else
         rem if c# is first intersection
         if c# < 1
            if c# < a# and c# < b#
               rem set normal of reflection surface
               set vector2 2, t.y3-t.y2,-(t.x3-t.x2)
               normalize vector2 2,2
               exitfunction c#
            endif
         endif
      endif
   endif
endfunction -1.0



rem draw the paddle at 'X' with a half-length of 'midLength'
function draw_paddle(x,midLength)
   box x-midLength,screen height()-5,x+midLength,screen height()
endfunction


rem draws the interface on the right side of screen
function draw_interface()
   line INTERFACE_BORDER,0,INTERFACE_BORDER,screen height()
endfunction


rem draws a triangle
function draw_triangle(ax,ay,bx,by,cx,cy)
   line ax,ay,bx,by
   line ax,ay,cx,cy
   line bx,by,cx,cy
endfunction



REM returns 2 if the two line segments dont intersect, between [0,1] if they do
function _line_intersect(ax#,ay#,bx#,by#,cx#,cy#,dx#,dy#)

   d# = (dy# - cy#)*(bx# - ax#) - (dx# - cx#)*(by# - ay#)
   Ua# = ((dx# - cx#)*(ay# - cy#) - (dy# - cy#)*(ax# - cx#)) / d#
   Ub# = ((bx# - ax#)*(ay# - cy#) - (by# - ay#)*(ax# - cx#)) / d#
   _intersect# = 2

   if Ua# > 0 and Ua# < 1 and Ub# > 0 and Ub# < 1 then _intersect# = Ua#
endfunction _intersect#

REM Project: breakout
REM Created: 4/10/2005 8:23:57 PM
REM by Coding Fodder
REM ***** Main Source File *****
REM
sync on:sync rate 0
set display mode 1024,768,32
backdrop on
color backdrop 0
hide mouse

type brick
   kind as integer
   strength as integer
endtype

type ball
   kind as integer
   strength as integer
   captured as boolean
   vx as float
   vy as float
   x as float
   y as float
   t0 as integer
endtype

type paddles
   kind as string
   width as float
   angle as float
   xpos as float
endtype

type item
   kind as string
   x as float
   y as float
endtype

type particle
   color as integer
   x as float
   y as float
   vx as float
   vy as float
   t0 as integer
endtype

type events
   ball as integer
   kind as integer
   time as integer
   dx as integer
   dy as integer
endtype

#Constant G=0.0002

Global Number_of_paddles
Global Number_of_balls
Global Number_of_items
Global Number_of_bricks
Global Number_of_particles
Global Score
global paddle as paddles
global event as events
global game_time
global start_time
global event_time
global level_done

dim bricks(15,20) as brick
dim balls(10) as ball
dim items(10) as item
dim particles(10000) as particle
start_time=timer()
game_time=timer()

create_brick(1,1,1,0)
create_brick(2,0,1,0)
create_brick(3,0,0,1)
create_brick(4,1,1,1)


create_paddle()
add_paddle()
add_paddle()
add_paddle()
create_ball()
add_ball(0,0,0,0)
for i=1 to 4
add_paddle()
level_done=0
create_level(i)
balls(1).captured=1
balls(1).kind=1
DO
   game_clock()
   if check_for_event()=1
      execute_event()
      calculate_next_event()
   endif
   draw_bricks()
   get_inputs()
   draw_paddle()
   draw_balls()
   draw_particles()
   text 1,1,str$(screen fps())
   text 500,1,"SCORE "+str$(score)
   sync
   if level_done=1 then exit
LOOP
next t

function draw_particles()
   lock pixels
      for i=1 to number_of_particles
         x#=lin_move(game_time,particles(i).t0,particles(i).x,particles(i).vx)
         y#=arc_move(game_time,particles(i).t0,particles(i).y,particles(i).vy)

         if y#>0
            if y#<768 and x#>0 and x#<1024
               set_locked_pixel(x#,y#,rgb(255,255,0))
            else
               remove_particle(i)
            endif
         endif
      next i
   unlock pixels
endfunction

function execute_event()
chx=1
chy=1
   if event.dy=700
      left#=mousex()-paddle.width/2-5
      right#=mousex()+paddle.width/2+5
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      if balls(event.ball).x>left# and balls(event.ball).x<right#
         angle#=(mousex()-balls(event.ball).x)/paddle.width*85.0
         balls(event.ball).vx=-sin(angle#)*0.3
         balls(event.ball).vy=-cos(angle#)*0.3
         score=score-10
      else
         remove_ball(event.ball)
      endif
   endif
   if balls(event.ball).kind=2 and event.dx>0 then event.kind=-1
   if event.kind=1
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      balls(event.ball).vx=-balls(event.ball).vx
      chx=-1
   endif
   if event.kind=2
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      balls(event.ball).vy=-balls(event.ball).vy
      chy=-1
   endif
   if event.dx>0
      if event.kind=-1
         score=score+(bricks(event.dx,event.dy).strength-1)*10
         bricks(event.dx,event.dy).strength=1
      endif
      if bricks(event.dx,event.dy).strength<4
         dec bricks(event.dx,event.dy).strength
         score=score+10
      endif
      if bricks(event.dx,event.dy).strength=0
         remove_brick(event.dx,event.dy)
         score=score+90
         for i= 1 to 15
            for j=1 to 20
               if bricks(i,j).kind>0 and bricks(i,j).kind<4 then inc bricksleft
            next j
         next i
         if bricksleft=0 then level_done=1
         lock pixels
         for i=(event.dx-1)*68 to event.dx*68 step 3
            for j=(event.dy-1)*20 to event.dy*20 step 3
               add_particle(rgb(255,255,0),i,j,balls(event.ball).vx*((rnd(150)/100.0)+0.5)*chx,balls(event.ball).vy*((rnd(150)/100.0)+0.5)*chy)
            next j
         next i
         unlock pixels
      endif
   endif

endfunction

function lin_move(t,t0,x0#,vx#)
   x#=vx#*(t-t0)+x0#
endfunction x#

function arc_move(t,t0,x0#,vx#)
   x#=vx#*(t-t0)+g*(t-t0)^2.0+x0#
endfunction x#

function calculate_next_event()
   time=20000
   time3=20000
   event.ball=0
   event.kind=-1
   event.dx=0
   event.dy=0
   for i=1 to number_of_balls
      if balls(i).vx<0
         time2=balls(i).t0+(5.0-balls(i).x)/balls(i).vx
         if time2-game_time<time
            time=time2-game_time
            event.kind=1
            event.ball=i
         endif
         for j=15 to 1 step -1

         next j
      endif
      if balls(i).vx>0
         time2=balls(i).t0+(1019.0-balls(i).x)/balls(i).vx
         if time2-game_time<time
            time=time2-game_time
            event.kind=1
            event.ball=i
         endif
      endif
      if balls(i).vy<0
         time2=balls(i).t0+(5.0-balls(i).y)/balls(i).vy
         if time2-game_time<time
            time=time2-game_time
            event.kind=2
            event.ball=i
         endif
      endif
      if balls(i).vy>0
         time2=balls(i).t0+(695.0-balls(i).y)/balls(i).vy
         if time2-game_time<time
            time=time2-game_time
            event.kind=-1
            event.ball=i
            event.dy=700
         endif
      endif

      for j=1 to 15
         if balls(i).vx>0.0
            time2=balls(i).t0+(j*68-5-balls(i).x)/balls(i).vx
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               x#=j*68-5
               y#=lin_move(time2,balls(i).t0,balls(i).y,balls(i).vy)
               x=j+1
               y=int(y#/20)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=1
               endif
               endif
            endif
         endif
         if balls(i).vx<0.0
            time2=balls(i).t0+(j*68+5-balls(i).x)/balls(i).vx
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               x#=j*68-5
               y#=lin_move(time2,balls(i).t0,balls(i).y,balls(i).vy)
               x=j
               y=int(y#/20)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=1
               endif
               endif
            endif
         endif
      next j
      for j=1 to 20
         if balls(i).vy>0.0
            time2=balls(i).t0+(j*20-5-balls(i).y)/balls(i).vy
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               y#=j*20-5
               x#=lin_move(time2,balls(i).t0,balls(i).x,balls(i).vx)
               y=j+1
               x=int(x#/68)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=2
               endif
               endif
            endif
         endif
         if balls(i).vy<0.0
            time2=balls(i).t0+(j*20+5-balls(i).y)/balls(i).vy
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               y#=j*20-5
               x#=lin_move(time2,balls(i).t0,balls(i).x,balls(i).vx)
               y=j
               x=int(x#/68)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=2
               endif
               endif
            endif
         endif
      next j
   next i
   if time3<time then time=time3
   event.time=time+game_time
endfunction

function check_for_event()
   if event.kind<>0
   if game_time>=event.time
      out=1
      game_time=event.time
   endif
   endif
endfunction out

function game_clock()
   time=timer()
   if time<start_time then time=time+86400000
   game_time=time-start_time
endfunction

function draw_balls()
   for i=1 to number_of_balls
      if balls(i).captured=1
         paste sprite 11,balls(i).x-5,balls(i).y-5
      else
         x#=lin_move(game_time,balls(i).t0,balls(i).x,balls(i).vx)-5
         y#=lin_move(game_time,balls(i).t0,balls(i).y,balls(i).vy)-5
         paste sprite 11,x#,y#
         if y#>780 then remove_ball(i)
      endif
   next i
endfunction

function create_ball()
   cls
   lock pixels
   for i=1 to 10
      for j=1 to 10
         if (5-i)^2+(5-j)^2<=25 then set_locked_pixel(i,j,rgb(150,150,150))
      next j
   next i
   unlock pixels
   get image 11,1,1,10,10
   sprite 11,20,20,11
   hide sprite 11
endfunction

function get_inputs()
   `angle=paddle.angle+mousemovez()/10.0
   if angle<45 and angle>-45 then paddle.angle=angle
   for i=1 to number_of_balls
      if balls(i).captured=1
         balls(i).x=mousex()+(5*(sin(paddle.angle)))
         balls(i).y=695+abs(5*(sin(paddle.angle)))
         if mouseclick()>0
            balls(i).captured=0
            balls(i).t0=game_time
            balls(i).vx=sin(paddle.angle)*0.3
            balls(i).vy=-cos(paddle.angle)*0.3
            calculate_next_event()
         endif
      endif
   next i
endfunction

function draw_paddle()
   rotate sprite 10,paddle.angle
   stretch sprite 10,paddle.width/50.0*100.0,100
   paste sprite 10,mousex()-paddle.width/2+(paddle.width/2*(1-cos(paddle.angle))),700-(paddle.width/2*(sin(paddle.angle)))
endfunction

function create_paddle()
   cls
   lock pixels
   for i=1 to 50
      for j=1 to 10
         set_locked_pixel(i,j,rgb(200,0,0))
      next j
   next i
   unlock pixels
   get image 10,1,1,50,10
   sprite 10,20,20,10
   hide sprite 10
   paddle.width=50
endfunction

function create_level(difficulty)
   for i=1 to 15
      for j=1 to 20
         add_brick(rnd(difficulty),i,j)
      next j
   next i
endfunction

Function Add_Brick(kind,x,y)
   `if bricks(x,y).kind=0
      inc number_of_bricks
      bricks(x,y).kind=kind
      select kind
         case 1:bricks(x,y).strength=1:endcase
         case 2:bricks(x,y).strength=2:endcase
         case 3:bricks(x,y).strength=3:endcase
         case 4:bricks(x,y).strength=4:endcase
      endselect
   `endif
endfunction

function Add_ball(x#,y#,vx#,vy#)
   if number_of_balls<10
      inc number_of_balls
      balls(number_of_balls).kind=1
      balls(number_of_balls).x=x#
      balls(number_of_balls).y=y#
      balls(number_of_balls).vx=vx#
      balls(number_of_balls).vy=vy#
      if x#=0 and y#=0 then balls(number_of_balls).captured=1
   endif
endfunction

function Add_item(kind$,x#,y#)

endfunction

function add_paddle()
   inc number_of_paddles
endfunction

function add_particle(color,x#,y#,vx#,vy#)
   inc number_of_particles
   particles(number_of_particles).color=color
   particles(number_of_particles).x=x#
   particles(number_of_particles).y=y#
   particles(number_of_particles).vx=vx#
   particles(number_of_particles).vy=vy#
   particles(number_of_particles).t0=game_time
endfunction

function remove_brick(x,y)
   bricks(x,y).kind=0
endfunction

function remove_ball(num)
   dec number_of_balls
   if number_of_balls>=num
      for i=num to number_of_balls
         balls(i).kind=balls(i+1).kind
         balls(i).t0=balls(i+1).t0
         balls(i).x=balls(i+1).x
         balls(i).y=balls(i+1).y
         balls(i).vx=balls(i+1).vx
         balls(i).vy=balls(i+1).vy
      next i
   endif
   if number_of_balls<=0 then remove_paddle()
endfunction

function remove_paddle()
   dec number_of_paddles
   paddle.width=50
   if number_of_paddles=0 then endgame()
   add_ball(0,0,0,0)
endfunction

function remove_particle(num)
   dec number_of_particles
   for i=num to number_of_particles
      particles(i).color=particles(i+1).color
      particles(i).x=particles(i+1).x
      particles(i).y=particles(i+1).y
      particles(i).vx=particles(i+1).vx
      particles(i).vy=particles(i+1).vy
      particles(i).t0=particles(i+1).t0
   next i
endfunction

function draw_bricks()
   for i=1 to 15
      for j=1 to 20
         if bricks(i,j).kind=1 then paste sprite 1,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=2 then paste sprite 2,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=3 then paste sprite 3,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=4 then paste sprite 4,(i-1)*68,(j-1)*20
      next j
   next i
endfunction

function create_brick(num,red,green,blue)
   lock pixels
   for i=1 to 67
      for j=1 to 19
         set_locked_pixel(i,j,rgb(red*(200+abs(34-i)+abs(10-j)),green*(200+abs(34-i)+abs(10-j)),blue*(200+abs(34-i)+abs(10-j))))
      next j
   next i
   unlock pixels
   get image num,1,1,68,20
   sprite num,20,20,num
   hide sprite num
endfunction

function endgame()
   end
endfunction

function get_locked_pixel(x,y)
   start=get pixels pointer()
   repeat_number=get pixels pitch()
   bits_per_pixel=bitmap depth(num)/8
   pointer=start+y*repeat_number+x*bits_per_pixel
   result=*pointer
endfunction result

function set_locked_pixel(x,y,color_value)
   start=get pixels pointer()
   repeat_number=get pixels pitch()
   bits_per_pixel=bitmap depth(num)/8
   pointer=start+y*repeat_number+x*bits_per_pixel
   *pointer=color_value
endfunction

Rem Breakoids
Rem By Patrick Lewis (RiiDii)
Rem 12/Apr/2005

Sync On:Sync Rate 30:AutoCam Off: Hide Mouse
Randomize Timer()

Type Coordinates
   x as Float
   y as Float
   z As Float
EndType

Type Asteroids
   pos as Coordinates
   rot as Coordinates
   move as Coordinates
   Size as Float
EndType

Global Object as Coordinates
Global Target as Coordinates
Dim Asteroid (500) as Asteroids
Global Ball as Coordinates
Global Sticky

Rem Start Game
Make_Stars()
Make_Paddle()
Position Object 1000,0,-39,70
Make Object Sphere 1001,2
Troids=5

Rem Start Level
Do
   For i = 1 to Troids
      Make_Asteroid(i,10)
   Next i
   Sticky=1
   Do
      Total=Move_Asteroids()
      If Total=0 Then Exit
      Move_Paddle()
      Lose=Move_Ball()
      If Lose=1 Then Sticky=1
      Sync
   Loop
   Troids=Troids+1
Loop

Function Move_Ball()
   If MouseClick()=1 And Sticky=1
      Sticky=0
      Ball.x=rnd(100.0)/100.0-.5
      Ball.y=1
   Endif
   If Sticky=1
      Return_Object(1000)
      Position Object 1001,Object.x,Object.y+2,Object.z
      ExitFunction
   Endif
   Move Object Right 1001,Ball.x
   Move Object Up 1001,Ball.y
   oc=Object Collision(1001,0)
   if oc<501
      Return_Object(1001):Return_Target(oc)
      Position Object 1001,Target.x,Target.y,Target.z
      Point Object 1001,Object.x,Object.y,Object.z
      Move Object 1001,1.5
      Ball.x=Object Position X(1001)-Target.x:Ball.y=Object Position Y(1001)-Target.y
      Position Object 1001,Object.x,Object.y,Object.z
      Rotate Object 1001,0,0,0
      New_Asteroids(oc)
   Endif
   If oc=1000
      Return_Object(1001):Return_Target(1000)
      Position Object 1001,Target.x,Target.y,Target.z
      Point Object 1001,Object.x,Object.y,Object.z
      Move Object 1001,1.5
      Ball.x=(Object Position X(1001)-Target.x)*.8:Ball.y=Object Position Y(1001)-Target.y
      Position Object 1001,Object.x+Ball.x,Object.y+Ball.y,Object.z
      Rotate Object 1001,0,0,0
   Endif
   Return_Object(1001)
   If object.x<-50 Then Ball.x=Abs(Ball.x)
   If object.x>50 Then Ball.x=Abs(Ball.x)*-1
   If Object.y>40 Then Ball.y=Abs(Ball.y)*-1
   If Object.y<-45 Then ExitFunction 1
   If Abs(Ball.y)<.1 Then If Object.y<0 Then Ball.y=.1 Else Ball.y=-.1
EndFunction 0

Function New_Asteroids(ObjectID)
   size=Asteroid(ObjectID).Size
   Asteroid(ObjectID).Size=0
   Return_Object(ObjectID)
   Delete Object ObjectID
   If size=3 then ExitFunction
   If Size=10 then Size=5 Else Size=3
   For i = 1 to 3
      For j=1 to 500
         If Asteroid(j).Size=0 Then Exit
      Next j
      Make_Asteroid(j,size)
      Asteroid(j).pos.x=Object.x:Asteroid(j).pos.y=Object.y
   Next i
EndFunction

Function Make_Asteroid(ObjectID,Size)
If Object Exist(ObjectID) Then Delete Object ObjectID
For i = 1 to 8
   Make Object Sphere ObjectID,1,rnd(3)+3,rnd(3)+3
   Make Mesh from Object i,ObjectID
   Delete Object ObjectID
Next i
Make Object Sphere ObjectID,.1,1,1
For i = 1 to 8
   Add Limb ObjectID,i,i
   Offset Limb ObjectID,i,Rnd(100.0)/200.0-.5,Rnd(100.0)/200.0-.5,Rnd(100.0)/200.0-.5
   Delete Mesh i
Next i
Scale Object ObjectID,Size*100,Size*100,Size*100
Set Object Collision To SPheres ObjectID
Asteroid(ObjectID).rot.x=rnd(9)-5:Asteroid(ObjectID).rot.y=rnd(9)-5:Asteroid(ObjectID).rot.z=rnd(9)-5
Asteroid(ObjectID).pos.x=rnd(100)-50:Asteroid(ObjectID).pos.y=rnd(60)-10:Asteroid(ObjectID).pos.z=70
Asteroid(ObjectID).move.x=rnd(100.0)/100.0-.5:Asteroid(ObjectID).move.y=rnd(100.0)/100.0-.5:Asteroid(ObjectID).move.z=0
Asteroid(ObjectID).Size=Size
Color Object ObjectID,RGB(118,37,57)
Set Object Ambience ObjectID,RGB(149,0,0)
EndFunction

Function Move_Asteroids()
Count=0
For i = 1 to 500
   If Asteroid(i).Size>0
      Count=Count+1
      Asteroid(i).pos.x=Asteroid(i).pos.x+Asteroid(i).move.x
      Asteroid(i).pos.y=Asteroid(i).pos.y+Asteroid(i).move.y
      Asteroid(i).pos.z=Asteroid(i).pos.z+Asteroid(i).move.z
      If Asteroid(i).pos.x<-60 then Asteroid(i).pos.x=Asteroid(i).pos.x+120
      If Asteroid(i).pos.x>60 then Asteroid(i).pos.x=Asteroid(i).pos.x-120
      If Asteroid(i).pos.y<-10 then Asteroid(i).move.y=abs(Asteroid(i).move.y)
      If Asteroid(i).pos.y>50 then Asteroid(i).move.y=abs(Asteroid(i).move.y)*-1
      Position Object i,Asteroid(i).pos.x,Asteroid(i).pos.y,Asteroid(i).pos.z
      Pitch Object Down i,Asteroid(i).rot.x
      Turn Object Right i,Asteroid(i).rot.y
      Roll Object Right i,Asteroid(i).rot.z
   Endif
Next i
EndFunction Count

Function Make_Stars()
   If Object Exist(5000) Then Delete Object 5000
   If Bitmap Exist(1) Then Delete Bitmap 1
   Create Bitmap 1,2048,2048
   Set Current Bitmap 1
   Ink 0,0
   Box 0,0,1023,1023
   For i = 1 to rnd(500)+Rnd(500)+Rnd(500)+Rnd(500)+500
      Ink Rgb(rnd(55)+200,rnd(55)+200,rnd(55)+200),0
      Dot rnd(2047),rnd(2047)
   Next i
   Get Image 1,0,0,2047,2047,1
   Set Current Bitmap 0
   Delete Bitmap 1
   Make Object Sphere 5000,2000
   Set Object Cull 5000,0
   Texture Object 5000,1
   Position Object 5000,0,0,0
   Set Object Emissive 5000,RGB(255,255,255)
EndFunction

Function Make_Paddle()
   If Object Exist(1000) Then Delete Object 1000
   Make Object Sphere 1000,1
   Make Mesh from Object 1,1000
   Delete Object 1000
   Make Object Cylinder 1000,1
   Scale Object 1000,100,500,100
   Roll Object Right 1000,90
   Fix Object Pivot 1000
   Make Mesh from Object 1000,1000
   Delete Object 1000
   Make Object 1000,1000,0
   Add Limb 1000,1,1
   Add Limb 1000,2,1
   Offset Limb 1000,1,-2.5,0,0
   Offset Limb 1000,2,2.5,0,0
   Scale Object 1000,200,200,200
   Set Object Collision To Boxes 1000
EndFunction

Function Move_Paddle()
   x#=MouseMoveX()*.5
   Move Object Right 1000,x#
   Return_Object(1000)
   If Object.x<-52 Then Position Object 1000,-52,Object.y,Object.z
   If Object.x>52 Then Position Object 1000,52,Object.y,Object.z
EndFunction

Function Return_Object(ObjectID)
   Object.x=Object Position X(ObjectID):Object.y=Object Position Y(ObjectID):Object.z=Object Position Z(ObjectID)
EndFunction

Function Return_Target(TargetID)
   Target.x=Object Position X(TargetID):Target.y=Object Position Y(TargetID):Target.z=Object Position Z(TargetID)
EndFunction

set display mode 1024,768,32
sync on
sync rate 0
sync
randomize timer()
backdrop on
color backdrop 0
set image colorkey 0,0,0
autocam off
PERFORM CHECKLIST FOR FONTS
SET TEXT FONT "arial"
EMPTY CHECKLIST
set text size 50
set text to bold
hide mouse

global spd#
global spdinc#
global maxspd#

 ` you
make object box 1,13,13,13
 ` the dummy object you point at
make object box 2,0,0,0
hide object 2
 ` the sphere that represents the thing that you don't want the ball to hit
make object sphere 3,32
position object 3,0,0,0
 ` the ball
make object sphere 4,9

make_images()
makeexplosionboxes()

level=1

beginanewlevelhere:
delobs()

`  restore
` for t=1 to level
read spd#,spdinc#,maxspd#
read numbox,boxsize,boxdist
read boxmove#,oscilate
` next t

x=0
y=(360/numbox)
for t=101 to 100+numbox
 make object box t,boxsize,boxsize,boxsize
 texture object t,level
 d=boxdist
 position object t,sin(x)*d,cos(x)*d,0
 x=x+y
next t

offset#=0.0
ballheld=1
boxleft=numbox
degree=0

make object cube 100,1000
set object light 100,0
set object cull 100,0
texture object 100,level
set object collision off 100
position object 100,0,0,-250

for t=1 to 4
 texture object t,11
next t

ink rgb(200,0,255),0
approach(level)

position camera 0,0,-250

f#=0.1
T1#=TIMER()

do

if level=11

 if abs(boxmove#)>0.9 then f#=-f# : boxmove#=boxmove#+f#*gs#
 boxmove#=boxmove#+f#*gs#

endif



 ` timer-based movement:
GS#=(TIMER()-T1#)*0.010
T1#=TIMER()

inc degree
if degree>359 then degree=0

offset#=offset#+(rightkey()-leftkey())*30*gs#
position object 1,sin(offset#)*20,cos(offset#)*20,0
position object 2,sin(offset#)*230,cos(offset#)*230,0
point object 1,object position x(2),object position y(2),object position z(2)


x=0
y=(360/numbox)
d=(boxdist+(sin(degree)*oscilate))
if d<50 then d=50
if d>150 then d=150


for t=101 to 100+numbox
 boxpos#=boxpos#+(boxmove#*gs#)
 if boxpos#>360.0 then boxpos#=boxpos#-360.0
 position object t,sin(boxpos#+x)*d,cos(boxpos#+x)*d,0
 x=x+y
next t

if ballheld=1
 position object 4,object position x(1),object position y(1),object position z(1)
 point object 4,object position x(2),object position y(2),object position z(2)
 move object 4,11

 if spacekey() then  ballheld=0

endif

if ballheld=0
 move object 4,spd#*gs#

 x=object collision(4,0)
 if x>100 and x<200
  explode(x,level)
  hide object x
  set object collision off x
  redirball()
  dec boxleft
  score=score+10*level
 endif  : ` hit a box object

if x=1
 rotate object 4,object angle x(1),object angle y(1),object angle z(1)
endif : ` hit your paddle

if x=3
 if level>1
  score=score-level*50
  if score<0 then score=0
 endif
 ballheld=1
 explode(3,11)
 spd#=spd#-3.5
 if spd#<15.0 then spd#=15.0
endif

 endif : ` if ball is NOT HELD

if sqdisob(1,4)>23000
 redirball()
endif

if boxleft<1
 inc level

for x=1 to 20
for t=201 to 220
 move object t,15*gs#
next t
sync
next x

 goto beginanewlevelhere

endif

rotate object 100,object angle x(100)+gs#,object angle y(100)+gs#,object angle z(100)+gs#

for t=201 to 220
 move object t,15*gs#
next t

rotate object 3,rnd(360),rnd(360),rnd(360)

`center text 512,20,str$(score)
text 20,20,str$(score)
sync : loop

function sqdisob(a,b)
 dist=(object position x(a)-object position x(b))^2+(object position y(a)-object position y(b))^2
endfunction dist

function delobs()
for t=100 to 199
 if object exist(t) then delete object t
next t
for t=201 to 220
 position object t,0,0,-300
 point object t,0,0,-400
next t
endfunction

function makeexplosionboxes()
for t=201 to 220
 make object box t,5,5,5
 position object t,0,0,-300
 point object t,0,0,-400
 ghost object on t
 set object collision off t
next t
endfunction

function make_images()

 for z=1 to 10
create bitmap 1,32,32
 ink rgb(rnd(150+50),rnd(150+50),rnd(150+50)),0
 box 0,0,31,31
for t=1 to 15
 ink rgb(rnd(150+50),rnd(150+50),rnd(150+50)),0
 x=rnd(29-t)
 y=rnd(29-t)
 box x,y,x+2+t,y+2+t
next t
get image z,0,0,31,31
delete bitmap 1
 next z

create bitmap 1,32,32
ink rgb(255,255,255),0
 for t=1 to 300
  dot rnd(31),rnd(31)
 next t
get image 11,0,0,31,31
delete bitmap 1

endfunction

function explode(a,b)

x=object position x(a)
y=object position y(a)

for t=201 to 220
 position object t,x,y,0
 rotate object t,rnd(360),rnd(360),rnd(360)
 texture object t,b
next t

endfunction

function redirball()

z=0
a=sqdisob(1,4)
move object 4,5
b=sqdisob(1,4)
move object 4,-5
if b<a then z=1
if a>22000 or b>22000 then z=0

point object 4,rnd(60)-30,rnd(60)-30,0

if z=1 then zrotate object 4,object angle z(4)+200-rnd(40)

spd#=spd#+spdinc#/2.0
if spd#>30.0 then spd#=30.0

endfunction

function approach(l)
 for t=201 to 220
  hide object t
 next t
 for t=1 to 4
  hide object t
 next t
for t=-600 to -250 step 5
position camera 0,0,t
position object 100,0,0,t
center text 512,300,"LEVEL "+STR$(L)
sync
next t
 for t=201 to 220
  show object t
 next t
 for t=1 to 4
  show object t
 next t
endfunction

LEVEL_ONE_DATA:
`spd#,spdinc#,maxspd#
data 10.0,0.250,20.0
`numbox,boxsize,boxdist
data 10,50,100
`boxmove#,oscilate
data 0.035,0

LEVEL_Two_DATA:
`spd#,spdinc#,maxspd#
data 11.0,0.250,30.0
`numbox,boxsize,boxdist
data 40,15,100
`boxmove#,oscilate
data -0.05,10

LEVEL_Three_DATA:
`spd#,spdinc#,maxspd#
data 12.0,0.250,40.0
`numbox,boxsize,boxdist
data 20,30,100
`boxmove#,oscilate
data 0.10,25

LEVEL_four_DATA:
`spd#,spdinc#,maxspd#
data 13.0,0.350,40.0
`numbox,boxsize,boxdist
data 30,20,100
`boxmove#,oscilate
data -0.15,250

LEVEL_five_DATA:
`spd#,spdinc#,maxspd#
data 14.0,0.350,20.0
`numbox,boxsize,boxdist
data 60,40,135
`boxmove#,oscilate
data 0.25,0

LEVEL_six_DATA:
`spd#,spdinc#,maxspd#
data 15.0,0.250,30.0
`numbox,boxsize,boxdist
data 16,15,125
`boxmove#,oscilate
data -1.00,25

LEVEL_seven_DATA:
`spd#,spdinc#,maxspd#
data 16.0,0.250,40.0
`numbox,boxsize,boxdist
data 45,10,150
`boxmove#,oscilate
data 0.25,75

LEVEL_eight_DATA:
`spd#,spdinc#,maxspd#
data 17.0,0.250,40.0
`numbox,boxsize,boxdist
data 30,20,75
`boxmove#,oscilate
data -0.15,0

LEVEL_nine_DATA:
`spd#,spdinc#,maxspd#
data 18.0,0.250,30.0
`numbox,boxsize,boxdist
data 36,15,125
`boxmove#,oscilate
data 0.10,50

LEVEL_ten_DATA:
`spd#,spdinc#,maxspd#
data 19.0,0.250,40.0
`numbox,boxsize,boxdist
data 60,10,150
`boxmove#,oscilate
data -0.25,75

LEVEL_eleven_DATA:
`spd#,spdinc#,maxspd#
data 20.0,0.250,40.0
`numbox,boxsize,boxdist
data 72,12,100
`boxmove#,oscilate
data 0.15,50

REM Project: breakout
REM Created: 4/10/2005 8:23:57 PM
REM by Coding Fodder
REM ***** Main Source File *****
REM
sync on:sync rate 0
set display mode 1024,768,32
backdrop on
color backdrop 0
hide mouse

type brick
   kind as integer
   strength as integer
endtype

type ball
   kind as integer
   strength as integer
   captured as boolean
   vx as float
   vy as float
   x as float
   y as float
   t0 as integer
endtype

type paddles
   kind as string
   width as float
   angle as float
   xpos as float
endtype

type item
   kind as string
   x as float
   y as float
   t0 as float
endtype

type particle
   color as integer
   x as float
   y as float
   vx as float
   vy as float
   t0 as integer
endtype

type events
   ball as integer
   kind as integer
   time as integer
   dx as integer
   dy as integer
endtype

#Constant G=0.0002

Global Number_of_paddles
Global Number_of_balls
Global Number_of_items
Global Number_of_bricks
Global Number_of_particles
Global Score
global paddle as paddles
global event as events
global game_time
global start_time
global event_time
global level_done

dim bricks(15,20) as brick
dim balls(10) as ball
dim items(10) as item
dim particles(10000) as particle
start_time=timer()
game_time=timer()

create_brick(1,1,1,0)
create_brick(2,0,1,0)
create_brick(3,0,0,1)
create_brick(4,1,1,1)


create_paddle()
add_paddle()
add_paddle()
add_paddle()
create_ball()
add_ball(0,0,0,0)
for i=1 to 4
add_paddle()
level_done=0
create_level(i)
balls(1).captured=1
balls(1).kind=1
DO
   game_clock()
   if check_for_event()=1
      execute_event()
      calculate_next_event()
   endif
   draw_bricks()
   get_inputs()
   draw_paddle()
   draw_balls()
   draw_particles()
   draw_items()
   text 1,1,str$(screen fps())
   text 500,1,"SCORE "+str$(score)
   sync
   if level_done=1 then exit
LOOP
next t

function draw_items()
   for i=1 to number_of_items
      y#=arc_move(game_time,items(i).t0,items(i).y,0.0)
      x#=items(i).x-4
      text x#,y#,items(i).kind
      if y#>768 then remove_item(i)
      if y#>695
         left#=mousex()-paddle.width/2-5
         right#=mousex()+paddle.width/2+5
         if x#>left# and x#<right#
            if items(i).kind="T"
               for j=1 to number_of_balls
                  balls(j).kind=2
               next i
            endif
            if items(i).kind="P"
               for j=1 to number_of_balls
                  balls(j).kind=3
               next i
            endif
            if items(i).kind="B" then `add_ball(0,0,0,0)
            if items(i).kind="L" then paddle.width=paddle.width+20
            remove_item(i)
         endif
      endif
   next i
endfunction

function draw_particles()
   lock pixels
      for i=1 to number_of_particles
         x#=lin_move(game_time,particles(i).t0,particles(i).x,particles(i).vx)
         y#=arc_move(game_time,particles(i).t0,particles(i).y,particles(i).vy)

         if y#>0
            if y#<768 and x#>0 and x#<1024
               set_locked_pixel(x#,y#,rgb(255,255,0))
            else
               remove_particle(i)
            endif
         endif
      next i
   unlock pixels
endfunction

function execute_event()
chx=1
chy=1
   if event.dy=700
      left#=mousex()-paddle.width/2-5
      right#=mousex()+paddle.width/2+5
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      if balls(event.ball).x>left# and balls(event.ball).x<right#
         angle#=(mousex()-balls(event.ball).x)/paddle.width*85.0
         balls(event.ball).vx=-sin(angle#)*0.3
         balls(event.ball).vy=-cos(angle#)*0.3
         score=score-10
      else
         remove_ball(event.ball)
      endif
   endif
   if balls(event.ball).kind=2 and event.dx>0 then event.kind=-1
   if event.kind=1
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      balls(event.ball).vx=-balls(event.ball).vx
      chx=-1
   endif
   if event.kind=2
      balls(event.ball).x=lin_move(event.time,balls(event.ball).t0,balls(event.ball).x,balls(event.ball).vx)
      balls(event.ball).y=lin_move(event.time,balls(event.ball).t0,balls(event.ball).y,balls(event.ball).vy)
      balls(event.ball).t0=event.time
      balls(event.ball).vy=-balls(event.ball).vy
      chy=-1
   endif
   if balls(event.ball).kind=3 and event.dx>0 then event.kind=-2
   if event.dx>0
      if event.kind<0 and event.dx>0 and event.dx<16 and event.dy>0 and event.dy<21
         score=score+(bricks(event.dx,event.dy).strength-1)*10
         bricks(event.dx,event.dy).strength=1
      endif
      if bricks(event.dx,event.dy).strength<4
         dec bricks(event.dx,event.dy).strength
         score=score+10
      endif
      if bricks(event.dx,event.dy).strength=0
         remove_brick(event.dx,event.dy)
         score=score+90
         for i= 1 to 15
            for j=1 to 20
               if bricks(i,j).kind>0 and bricks(i,j).kind<4 then inc bricksleft
            next j
         next i
         if bricksleft=0 then level_done=1
         lock pixels
         for i=(event.dx-1)*68 to event.dx*68 step 3
            for j=(event.dy-1)*20 to event.dy*20 step 3
               add_particle(rgb(255,255,0),i,j,balls(event.ball).vx*((rnd(150)/100.0)+0.5)*chx,balls(event.ball).vy*((rnd(150)/100.0)+0.5)*chy)
            next j
         next i
         if event.kind=-2
            for u=event.dx-1 to event.dx+1
               for v=event.dy-1 to event.dy+1
                  if u>0 and u<16 and v>0 and v<21
                     if bricks(u,v).strength>0
                        score=score+(bricks(u,v).strength-1)*10+100
                        remove_brick(u,v)
                     endif
                  endif
               next v
            next u
         endif
         unlock pixels
      endif
   endif

endfunction

function lin_move(t,t0,x0#,vx#)
   x#=vx#*(t-t0)+x0#
endfunction x#

function arc_move(t,t0,x0#,vx#)
   x#=vx#*(t-t0)+g*(t-t0)^2.0+x0#
endfunction x#

function calculate_next_event()
   time=20000
   time3=20000
   event.ball=0
   event.kind=-1
   event.dx=0
   event.dy=0
   for i=1 to number_of_balls
      if balls(i).vx<0
         time2=balls(i).t0+(5.0-balls(i).x)/balls(i).vx
         if time2-game_time<time
            time=time2-game_time
            event.kind=1
            event.ball=i
         endif
         for j=15 to 1 step -1

         next j
      endif
      if balls(i).vx>0
         time2=balls(i).t0+(1019.0-balls(i).x)/balls(i).vx
         if time2-game_time<time
            time=time2-game_time
            event.kind=1
            event.ball=i
         endif
      endif
      if balls(i).vy<0
         time2=balls(i).t0+(5.0-balls(i).y)/balls(i).vy
         if time2-game_time<time
            time=time2-game_time
            event.kind=2
            event.ball=i
         endif
      endif
      if balls(i).vy>0
         time2=balls(i).t0+(695.0-balls(i).y)/balls(i).vy
         if time2-game_time<time
            time=time2-game_time
            event.kind=-1
            event.ball=i
            event.dy=700
         endif
      endif

      for j=1 to 15
         if balls(i).vx>0.0
            time2=balls(i).t0+(j*68-5-balls(i).x)/balls(i).vx
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               x#=j*68-5
               y#=lin_move(time2,balls(i).t0,balls(i).y,balls(i).vy)
               x=j+1
               y=int(y#/20)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=1
               endif
               endif
            endif
         endif
         if balls(i).vx<0.0
            time2=balls(i).t0+(j*68+5-balls(i).x)/balls(i).vx
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               x#=j*68-5
               y#=lin_move(time2,balls(i).t0,balls(i).y,balls(i).vy)
               x=j
               y=int(y#/20)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=1
               endif
               endif
            endif
         endif
      next j
      for j=1 to 20
         if balls(i).vy>0.0
            time2=balls(i).t0+(j*20-5-balls(i).y)/balls(i).vy
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               y#=j*20-5
               x#=lin_move(time2,balls(i).t0,balls(i).x,balls(i).vx)
               y=j+1
               x=int(x#/68)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=2
               endif
               endif
            endif
         endif
         if balls(i).vy<0.0
            time2=balls(i).t0+(j*20+5-balls(i).y)/balls(i).vy
            if time2-game_time>0 and time2-game_time<time and time2-game_time<time3
               y#=j*20-5
               x#=lin_move(time2,balls(i).t0,balls(i).x,balls(i).vx)
               y=j
               x=int(x#/68)+1
               if x<16 and x>0 and y>0 and y<21
               if bricks(x,y).kind>0
                  time3=time2-game_time
                  event.dx=x
                  event.dy=y
                  event.kind=2
               endif
               endif
            endif
         endif
      next j
   next i
   if time3<time then time=time3
   event.time=time+game_time
endfunction

function check_for_event()
   if event.kind<>0
   if game_time>=event.time
      out=1
      game_time=event.time
   endif
   endif
endfunction out

function game_clock()
   time=timer()
   if time<start_time then time=time+86400000
   game_time=time-start_time
endfunction

function draw_balls()
   for i=1 to number_of_balls
      if balls(i).captured=1
         paste sprite 11,balls(i).x-5,balls(i).y-5
      else
         x#=lin_move(game_time,balls(i).t0,balls(i).x,balls(i).vx)-5
         y#=lin_move(game_time,balls(i).t0,balls(i).y,balls(i).vy)-5
         paste sprite 11,x#,y#
         if y#>780 then remove_ball(i)
      endif
   next i
endfunction

function create_ball()
   cls
   lock pixels
   for i=1 to 10
      for j=1 to 10
         if (5-i)^2+(5-j)^2<=25 then set_locked_pixel(i,j,rgb(150,150,150))
      next j
   next i
   unlock pixels
   get image 11,1,1,10,10
   sprite 11,20,20,11
   hide sprite 11
endfunction

function get_inputs()
   `angle=paddle.angle+mousemovez()/10.0
   if angle<45 and angle>-45 then paddle.angle=angle
   for i=1 to number_of_balls
      if balls(i).captured=1
         balls(i).x=mousex()+(5*(sin(paddle.angle)))
         balls(i).y=695+abs(5*(sin(paddle.angle)))
         if mouseclick()>0
            balls(i).captured=0
            balls(i).t0=game_time
            balls(i).vx=sin(paddle.angle)*0.3
            balls(i).vy=-cos(paddle.angle)*0.3
            calculate_next_event()
         endif
      endif
   next i
endfunction

function draw_paddle()
   rotate sprite 10,paddle.angle
   stretch sprite 10,paddle.width/50.0*100.0,100
   paste sprite 10,mousex()-paddle.width/2+(paddle.width/2*(1-cos(paddle.angle))),700-(paddle.width/2*(sin(paddle.angle)))
endfunction

function create_paddle()
   cls
   lock pixels
   for i=1 to 50
      for j=1 to 10
         set_locked_pixel(i,j,rgb(200,0,0))
      next j
   next i
   unlock pixels
   get image 10,1,1,50,10
   sprite 10,20,20,10
   hide sprite 10
   paddle.width=50
endfunction

function create_level(difficulty)
   for i=1 to 15
      for j=1 to 20
         add_brick(rnd(difficulty),i,j)
      next j
   next i
endfunction

Function Add_Brick(kind,x,y)
   `if bricks(x,y).kind=0
      inc number_of_bricks
      bricks(x,y).kind=kind
      select kind
         case 1:bricks(x,y).strength=1:endcase
         case 2:bricks(x,y).strength=2:endcase
         case 3:bricks(x,y).strength=3:endcase
         case 4:bricks(x,y).strength=4:endcase
      endselect
   `endif
endfunction

function Add_ball(x#,y#,vx#,vy#)
   if number_of_balls<10
      inc number_of_balls
      balls(number_of_balls).kind=1
      balls(number_of_balls).x=x#
      balls(number_of_balls).y=y#
      balls(number_of_balls).vx=vx#
      balls(number_of_balls).vy=vy#
      if x#=0 and y#=0 then balls(number_of_balls).captured=1
   endif
endfunction

function Add_item(kind,x#,y#)
   if number_of_items<10
   inc number_of_items
   items(number_of_items).t0=game_time
   items(number_of_items).x=x#
   items(number_of_items).y=y#
   if kind=1 then items(number_of_items).kind="T"
   if kind=2 then items(number_of_items).kind="P"
   if kind=3 then items(number_of_items).kind="B"
   if kind=4 then items(number_of_items).kind="L"
   endif
endfunction

function remove_item(num)
   dec number_of_items
   for i=num to number_of_items
      items(i).t0=items(i+1).t0
      items(i).x=items(i+1).x
      items(i).y=items(i+1).y
      items(i).kind=items(i+1).kind
   next i
endfunction

function add_paddle()
   inc number_of_paddles
endfunction

function add_particle(color,x#,y#,vx#,vy#)
   if number_of_particles<10000
   inc number_of_particles
   particles(number_of_particles).color=color
   particles(number_of_particles).x=x#
   particles(number_of_particles).y=y#
   particles(number_of_particles).vx=vx#
   particles(number_of_particles).vy=vy#
   particles(number_of_particles).t0=game_time
   endif
endfunction

function remove_brick(x,y)
   bricks(x,y).kind=0
   if rnd(10)=5 then add_item(rnd(4),(x-1)*68+34.0,y*20+10.0)
endfunction

function remove_ball(num)
   dec number_of_balls
   if number_of_balls>=num
      for i=num to number_of_balls
         balls(i).kind=balls(i+1).kind
         balls(i).t0=balls(i+1).t0
         balls(i).x=balls(i+1).x
         balls(i).y=balls(i+1).y
         balls(i).vx=balls(i+1).vx
         balls(i).vy=balls(i+1).vy
      next i
   endif
   if number_of_balls<=0 then remove_paddle()
endfunction

function remove_paddle()
   dec number_of_paddles
   paddle.width=50
   if number_of_paddles=0 then endgame()
   add_ball(0,0,0,0)
endfunction

function remove_particle(num)
   dec number_of_particles
   for i=num to number_of_particles
      particles(i).color=particles(i+1).color
      particles(i).x=particles(i+1).x
      particles(i).y=particles(i+1).y
      particles(i).vx=particles(i+1).vx
      particles(i).vy=particles(i+1).vy
      particles(i).t0=particles(i+1).t0
   next i
endfunction

function draw_bricks()
   for i=1 to 15
      for j=1 to 20
         if bricks(i,j).kind=1 then paste sprite 1,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=2 then paste sprite 2,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=3 then paste sprite 3,(i-1)*68,(j-1)*20
         if bricks(i,j).kind=4 then paste sprite 4,(i-1)*68,(j-1)*20
      next j
   next i
endfunction

function create_brick(num,red,green,blue)
   lock pixels
   for i=1 to 67
      for j=1 to 19
         set_locked_pixel(i,j,rgb(red*(200+abs(34-i)+abs(10-j)),green*(200+abs(34-i)+abs(10-j)),blue*(200+abs(34-i)+abs(10-j))))
      next j
   next i
   unlock pixels
   get image num,1,1,68,20
   sprite num,20,20,num
   hide sprite num
endfunction

function endgame()
   end
endfunction

function get_locked_pixel(x,y)
   start=get pixels pointer()
   repeat_number=get pixels pitch()
   bits_per_pixel=bitmap depth(num)/8
   pointer=start+y*repeat_number+x*bits_per_pixel
   result=*pointer
endfunction result

function set_locked_pixel(x,y,color_value)
   start=get pixels pointer()
   repeat_number=get pixels pitch()
   bits_per_pixel=bitmap depth(num)/8
   pointer=start+y*repeat_number+x*bits_per_pixel
   *pointer=color_value
endfunction

set display mode 1024,768,32
sync on
sync rate 0
sync
randomize timer()
backdrop on
color backdrop 0
set image colorkey 0,0,0
autocam off
PERFORM CHECKLIST FOR FONTS
SET TEXT FONT "arial"
EMPTY CHECKLIST
set text size 50
set text to bold
hide mouse

global spd#
global spdinc#
global maxspd#
global numbox

brand_new_game:

 ` some setup functions
make_images()
makeexplosionboxes()
ink rgb(100,0,255),0

 ` you
make object box 1,13,13,13
 ` the dummy object you point at
make object box 2,0,0,0
hide object 2
 ` the sphere that represents the thing that you don't want the ball to hit
make object sphere 3,32
position object 3,0,0,0
 ` the ball
make object sphere 4,9
 ` texture the player's objects black&white
for t=1 to 4
 texture object t,11
next t

score=0
level=1

beginanewlevelhere:

 ` out with the old before in with the new:
delobs()

if level>11 then end_of_game(score)

` get the data for the level.
  ` the "restore" and "for/next t loop" are unnecessary, but DO allow you to hard-code
   ` a different starting level.
  restore
 for t=1 to level
read spd#,spdinc#,maxspd#
read numbox,boxsize,boxdist
read boxmove#,oscilate
 next t

  ` set up some starting values for the level.
if numbox<1 then numbox=20
offset#=0.0
ballheld=1
boxleft=numbox
degree#=0.0
f#=0.1

 ` make the target boxes for the level.
x=0
y=(360/numbox)
for t=101 to 100+numbox
 make object box t,boxsize,boxsize,boxsize
 texture object t,level
 d=boxdist
 position object t,sin(x)*d,cos(x)*d,0
 x=x+y
next t

 ` make the skybox for the level.
make object cube 100,1000
set object light 100,0
set object cull 100,0
texture object 100,level
set object collision off 100
position object 100,0,0,-250

 ` show the approach to the new level.
approach(level)
position camera 0,0,-250

` this should be set right before the loop, to ensure accuracy the timer-based movement.
T1#=TIMER()

do

 ` this makes it so that in level 11, the boxes go both directions
if level=11
 if abs(boxmove#)>0.9 then f#=-f# : boxmove#=boxmove#+f#*gs#
 boxmove#=boxmove#+f#*gs#
   ` this gives you all the textures of the boxes so far, to contrast with the
    ` now black-and-white environment.
  for t=1 to 4
   texture object t,rnd(9)+1
  next t
endif

 ` timer-based movement:
GS#=(TIMER()-T1#)*0.010
T1#=TIMER()

 ` this moves and positions and points the player
offset#=offset#+(rightkey()-leftkey())*(29+level)*gs#
position object 1,sin(offset#)*20,cos(offset#)*20,0
position object 2,sin(offset#)*230,cos(offset#)*230,0
point object 1,object position x(2),object position y(2),object position z(2)

 ` degree# is a counter used to measure in/out oscillation.
degree#=degree#+gs#*4
if degree#>360.0 then degree#=degree#-360.0

 ` this positions the boxes according to the variables of the level...
  ` their speed, distance, oscillation (in/out)
x=0
y=(360/numbox)
d=(boxdist+(sin(degree#)*oscilate))
if d<50 then d=50
if d>150 then d=150
for t=101 to 100+numbox
 boxpos#=boxpos#+(boxmove#*gs#)
 if boxpos#>360.0 then boxpos#=boxpos#-360.0
 position object t,sin(boxpos#+x)*d,cos(boxpos#+x)*d,0
 x=x+y
next t

 ` if you are holding the ball, it is positioned on your paddle.
  ` this is the only place that we check the spacekey() to launch it.
if ballheld=1
 position object 4,object position x(1),object position y(1),object position z(1)
 point object 4,object position x(2),object position y(2),object position z(2)
 move object 4,11
  if spacekey() then  ballheld=0
endif


 ` these are things that happen when you are NOT holding the ball
   ` it is moved, and we check for collisions with boxes and your inner sphere.
if ballheld=0
 move object 4,spd#*gs#

  ` this checks collision with boxes, sets up new explosions, and bounces the ball
 x=object collision(4,0)
 if x>100 and x<200
  explode(x,level)
  hide object x
  set object collision off x
  redirball()
  dec boxleft
  score=score+10*level
 endif  : ` hit a box object

 ` if the ball hits your paddle/shield/cube, send it out in the same direction.
if x=1
 rotate object 4,object angle x(1),object angle y(1),object angle z(1)
endif : ` hit your paddle

 ` this detects collision on your inner sphere, deducts your score, and makes you explode.
  ` it also sets the 'ballheld' flag, and takes some speed off the ball.
if x=3
 if level>1
  score=score-level*50
  if score<0 then score=0
 endif
 ballheld=1
 explode(3,11)
 spd#=spd#-3.0
 if spd#<15.0 then spd#=15.0
endif

 endif : ` if ball is NOT HELD


  ` this keeps the ball within a circular arena (even though the screen is square)
if sqdisob(1,4)>23000
 redirball()
endif

 ` this checks to send you to the next level. it allows you to witness the end of the explosion
if boxleft<1
 inc level
for x=1 to 30
 for t=201 to 220
  move object t,15*gs#
 next t
 sync
next x
 goto beginanewlevelhere
endif

` this keeps the background moving
rotate object 100,object angle x(100)+gs#,object angle y(100)+gs#,object angle z(100)+gs#

 ` this keeps your inner sphere moving
rotate object 3,rnd(360),rnd(360),rnd(360)

` this moves the explosion bits. it is always on. they go till you can't see them anymore.
for t=201 to 220
 move object t,15*gs#
next t

 ` print score to screen:
text 20,20,str$(score)

sync : loop

function sqdisob(a,b)
 dist=(object position x(a)-object position x(b))^2+(object position y(a)-object position y(b))^2
` this provides distance checking only on the x&y axes (that's all we use here),
 ` and it reports the squared distance value, to avoid using the SQRT() command, because
  ` that's a slow command. you must then check this against the distance you want, but squared.
endfunction dist

function delobs()
 ` deletes objects to begin a new level
for t=100 to 199
 if object exist(t) then delete object t
next t
for t=201 to 220
 position object t,0,0,-300
 point object t,0,0,-400
next t
endfunction

function makeexplosionboxes()
 ` only called once. makes 20 boxes for explosions.
for t=201 to 220
 make object box t,5,5,5
 position object t,0,0,-300
 point object t,0,0,-400
 ghost object on t
 set object collision off t
next t
endfunction

function make_images()
  ` images 1-11 are made random for each game.
 for z=1 to 10
create bitmap 1,32,32
 ink rgb(rnd(150+50),rnd(150+50),rnd(150+50)),0
 box 0,0,31,31
for t=1 to 15
 ink rgb(rnd(150+50),rnd(150+50),rnd(150+50)),0
 x=rnd(29-t)
 y=rnd(29-t)
 box x,y,x+2+t,y+2+t
next t
get image z,0,0,31,31
delete bitmap 1
 next z

create bitmap 1,32,32
ink rgb(255,255,255),0
 for t=1 to 300
  dot rnd(31),rnd(31)
 next t
get image 11,0,0,31,31
delete bitmap 1

endfunction

function explode(a,b)
 ` this positions a new explosion at object position(a), and textures it as 'B'.
x=object position x(a)
y=object position y(a)
for t=201 to 220
 position object t,x,y,0
 rotate object t,rnd(360),rnd(360),rnd(360)
 texture object t,b
next t
endfunction

function redirball()
` this covers what happens when to ball hits a box or the outer bounds.
 ` it is redirected and sped up.

  ` this z-flag system checks to see whether the ball is heading IN or OUT at the moment.
   ` it it's heading IN and hits something, then it's bounced back OUT (z=1)
z=0
a=sqdisob(1,4)
move object 4,5
b=sqdisob(1,4)
move object 4,-5
if b<a then z=1
 ` if the ball is already near the outer bounds, it just comes back in.
if a>22000 or b>22000 then z=0

` this imparts a random factor to the ball as it comes back IN.
point object 4,rnd(60)-30,rnd(60)-30,0

 ` if z flag is 1, then it's rotated to face outwards.
if z=1 then zrotate object 4,object angle z(4)+200-rnd(40)

 ` this inc's the ball's speed. a new max speed of 33.3 is in effect.
spd#=spd#+spdinc#/2.0
if spd#>33.3 then spd#=33.3

endfunction

function approach(l)
  ` this shows the approach to a new level.
 for t=201 to 220
  hide object t
 next t
 for t=1 to 4
  hide object t
 next t
for t=-600 to -250 step 5
position camera 0,0,t
position object 100,0,0,t
center text 512,300,"LEVEL "+STR$(L)
sync
next t
 for t=201 to 220
  show object t
 next t
 for t=1 to 4
  show object t
 next t
endfunction

function end_of_game(s)

for t=1 to 4
 hide object t
next t

for t=201 to 220
 texture object t,rnd(9)+1
 scale object t,300,300,300
 ghost object off t
next t

make object cube 100,1000
set object light 100,0
set object cull 100,0
texture object 100,11
set object collision off 100
position object 100,0,0,-250
position camera 0,0,-250

do

GS#=(TIMER()-T1#)*0.010
T1#=TIMER()

 boxpos#=boxpos#+(2.0*gs#)
 if boxpos#>360.0 then boxpos#=boxpos#-360.0

 ` make some spinning boxes for the background
x=0
for t=201 to 210
  position object t,sin(boxpos#+x)*75,cos(boxpos#+x)*75,0
 x=x+36
next t
x=0
for t=211 to 220
 position object t,sin(-boxpos#+x)*125,cos(-boxpos#+x)*125,0
 x=x+36
next t

center text 512,280,"YOUR SCORE:"
center text 512,320,str$(s)
center text 512,380,"PERFECT SCORE:"
center text 512,420,"29370"
center text 512,640,"press [space] to play again"
center text 512,680,"or [escape] to quit"

if spacekey()
` start a new game...delete old objects first
 for t=201 to 220
  delete object t
 next t
  for t=1 to 11
   delete image t
  next t
   for t=1 to 4
    delete object t
   next t
    goto brand_new_game
endif

if escapekey() then end

sync
loop

endfunction

LEVEL_ONE_DATA:
`spd#,spdinc#,maxspd#
data 10.0,0.250,20.0
`numbox,boxsize,boxdist
data 10,50,100
`boxmove#,oscilate
data 0.035,0
` points available on this level: 100

LEVEL_Two_DATA:
`spd#,spdinc#,maxspd#
data 11.0,0.250,30.0
`numbox,boxsize,boxdist
data 40,15,100
`boxmove#,oscilate
data -0.05,10
` 800

LEVEL_Three_DATA:
`spd#,spdinc#,maxspd#
data 12.0,0.250,40.0
`numbox,boxsize,boxdist
data 20,30,100
`boxmove#,oscilate
data 0.10,25
 ` 20*30=600

LEVEL_four_DATA:
`spd#,spdinc#,maxspd#
data 13.0,0.350,40.0
`numbox,boxsize,boxdist
data 30,20,100
`boxmove#,oscilate
data -0.15,250
 ` 30*40=1200

LEVEL_five_DATA:
`spd#,spdinc#,maxspd#
data 14.0,0.350,20.0
`numbox,boxsize,boxdist
data 60,40,135
`boxmove#,oscilate
data 0.25,0
 ` 60*50=3000

LEVEL_six_DATA:
`spd#,spdinc#,maxspd#
data 15.0,0.250,30.0
`numbox,boxsize,boxdist
data 16,15,125
`boxmove#,oscilate
data -1.00,25
 ` 16*60=960

LEVEL_seven_DATA:
`spd#,spdinc#,maxspd#
data 16.0,0.250,40.0
`numbox,boxsize,boxdist
data 45,10,150
`boxmove#,oscilate
data 0.25,75
 ` 45*70=3150

LEVEL_eight_DATA:
`spd#,spdinc#,maxspd#
data 17.0,0.250,40.0
`numbox,boxsize,boxdist
data 30,20,75
`boxmove#,oscilate
data -0.15,0
  ` 30*80=2400

LEVEL_nine_DATA:
`spd#,spdinc#,maxspd#
data 18.0,0.250,30.0
`numbox,boxsize,boxdist
data 36,15,125
`boxmove#,oscilate
data 0.10,50
 ` 36*90=3240

LEVEL_ten_DATA:
`spd#,spdinc#,maxspd#
data 19.0,0.250,40.0
`numbox,boxsize,boxdist
data 60,10,150
`boxmove#,oscilate
data -0.25,75
 ` 60*100=6000

LEVEL_eleven_DATA:
`spd#,spdinc#,maxspd#
data 20.0,0.250,40.0
`numbox,boxsize,boxdist
data 72,12,100
`boxmove#,oscilate
data 0.15,50
 ` 72*110=7920

` my high score: 18,020
` perfect score: 29,370

set display mode 1024,768,32
color backdrop 0
hide mouse
sync on
autocam off

data 1,2,2, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 1,2,1, 1,1,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0,

`1=top wall
`2=left wall
`3=right wall
`4=paddle
`5=ball
ink 0,0:box 0,0,10,10:get image 100,0,0,10,10
make matrix 1,47,35,47,35
position matrix 1,0,0.5,-33
prepare matrix texture 1,100,1,1

`make top wall
make object box 1,47,1,1
position object 1,23,1,1
set object collision to boxes 1
color object 1,rgb(0,0,255)
ghost object on 1

`make left wall
make object box 2,1,1,35
position object 2,0,1,-16
set object collision to boxes 2
color object 2,rgb(0,0,255)
ghost object on 2

`make right wall
make object box 3,1,1,35
position object 3,46,1,-16
set object collision to boxes 3
color object 3,rgb(0,0,255)
ghost object on 3

`make paddle
make object box 4,4,.5,.8
color object 4,rgb(0,255,0)
ghost object on 4

`make ball
make object sphere 5,.8,50,50
color object 5,rgb(255,0,0)
ghost object on 5
set object collision to spheres 5

`make bacground
make object cube 6,17
scale object 6,100,10,100
position object 6,23,0,-18
color object 6,rgb(255,255,255)
ghost object on 6

position camera 23,30,-16
point camera 23,1,-16

`make powerups
`faster move

restart:
rnd1=rnd(640)
rnd2=rnd(480)
level=1
spd#=0.2
times#=1.5
Zmos#=0.05*times#
Xmos#=0.05*times#
Lives#=2
score#=0
ON#=100
nBposX=0
nBposZ=0
oBposX=0
oBposZ=0
Xcol#=0
Zcol#=0
newlevel:
nlevel=0
if level=1
levelx=11
levelxx=10
stepx=1
levelz=-5
stepz=-1
endif
if level=2
levelx=11
levelxx=10
stepx=2
levelz=-15
stepz=-1
endif
if level=3
levelx=1
levelxx=22
stepx=1
levelz=-25
stepz=-1
endif

for x=1 to levelx step stepx
  for z=-1 to levelz step stepz
    if object exist(ON#)=0
      make object box ON#,1.7,.4,0.7
      position object ON#,X*2+levelxx,1,Z
      set object collision to spheres ON#
      color object ON#,rgb(255,0,255)
      endif
      inc ON#
  next z
next x

start:
position object 4,23,1,-32
position object 5,23,1.5,-31
repeat
if mousemovex()=0 and mousex()<512 then xmouse=xmouse+1
if mousemovey()=0 and mousex()>512 then xmouse=xmouse-1
yrotate object 6,xmouse*1
if rnd(300)=1
rnd1=rnd(640)
rnd2=rnd(480)
position mouse rnd1,rnd2
else
position mouse rnd1,rnd2
endif
  if leftkey() and object position x(4) > 2.5
    move object left 4,spd#
    move object left 5,spd#
  endif
  if rightkey() and object position x(4) < 43.5
    move object right 4,spd#
    move object right 5,spd#
  endif
  ink rgb(255,255,255),0
  set text size 10
  text 10,10,"Lives: "+str$(lives#)
  text 100,10,"Score: "+str$(score#)
  text 550,10,"FPS: "+str$(FPS#)
  sync
until spacekey()

do
if mousemovex()=0 and mousex()<512 then xmouse=xmouse+1
if mousemovey()=0 and mousex()>512 then xmouse=xmouse-1
yrotate object 6,xmouse*1
if rnd(300)=1
rnd1=rnd(640)
rnd2=rnd(480)
position mouse rnd1,rnd2
else
position mouse rnd1,rnd2
endif
Xcol#=0
Zcol#=0
PL#=1
FPS#=screen fps()

rem set up keys for paddle
if leftkey() and object position x(4) > 2.5
  move object left 4,spd#
endif
if rightkey() and object position x(4) < 43.5
  move object right 4,spd#
endif


if object collision(5,0)
  rem check if ball hit the top wall
  if object collision(5,1)
    rem if it did reverse the Z motion
    Zmos#=-Zmos#
  endif
  rem check if ball hit a side wall
  if object collision(5,2) or Object collision(5,3)
    rem if it did reverse the X motion
    Xmos#=-Xmos#
  endif
  for x=100 to ON#
    if object exist(x)=1
      if object collision(5,x)
        if Xcol#=0
          position object 5,oBposX#,1,nBposZ#
          if object collision(5,x)=0
            Xcol#=1
          endif
        endif
        if Zcol#=0
          position object 5,nBposX#,1,oBposZ#
          if object collision(5,x)=0
            Zcol#=1
          endif
        endif
        position object 5,nBposX#,1,nBposZ#
        score#=score#+10
        delete object x
      endif
    else
        if nlevel=ON#-100 then inc level:nlevel=0:inc score,100:ON#=100:gosub newlevel
        inc nlevel
    endif
  next x
  nlevel=0
  if Xcol#=1
    Xmos#=-Xmos#
  endif
  if Zcol#=1
    Zmos#=-Zmos#
  endif
endif

if object position z(5) < -31 and object position z(5) > -32
    if object position X(5) >= object position x(4)-2*PL# and object position X(5) < object position x(4)-1.9*PL#
      Xmos#=-0.08*times#
      Zmos#=0.02*times#
    endif
    if object position X(5) >= object position x(4)-1.9*PL# and object position X(5) < object position x(4)-1.6*PL#
      Xmos#=-0.07*times#
      Zmos#=0.03*times#
    endif
    if object position X(5) >= object position x(4)-1.6*PL# and object position X(5) < object position x(4)-0.7*PL#
      Xmos#=-0.05*times#
     Zmos#=0.05*times#
    endif
    if object position X(5) >= object position x(4)-0.7*PL# and object position X(5) < object position x(4)-0.2*PL#
      Xmos#=-0.02*times#
      Zmos#=0.08*times#
    endif
    if object position X(5) >= object position x(4)-0.2*PL# and object position X(5) < object position x(4)*PL#
      Xmos#=-0.001*times#
      Zmos#=0.099*times#
    endif
    if object position X(5) >= object position x(4)*PL# and object position X(5) < object position x(4)+0.2*PL#
      Xmos#=0.001*times#
      Zmos#=0.099*times#
    endif
    if object position X(5) >= object position x(4)+0.2*PL# and object position X(5) < object position x(4)+0.7*PL#
      Xmos#=0.02*times#
      Zmos#=0.08*times#
    endif
    if object position X(5) >= object position x(4)+0.7*PL# and object position X(5) < object position x(4)+1.6*PL#
      Xmos#=0.05*times#
      Zmos#=0.05*times#
    endif
    if object position X(5) >= object position x(4)+1.6*PL# and object position X(5) < object position x(4)+1.9*PL#
      Xmos#=0.07*times#
      Zmos#=0.03*times#
    endif
    if object position X(5) >= object position x(4)+1.9*PL# and object position X(5) < object position x(4)+2*PL#
      Xmos#=0.08*times#
      Zmos#=0.02*times#
    endif
endif

if object position z(5)<-34
  if lives#>0
    lives#=lives#-1
    goto start
  else
    ink rgb(255,0,0),0
    set text font "arial"
    set text size 30
    set text opaque
    center text 320,240,"G A M E  O V E R"
    wait key
    goto restart
  endif
endif

ink rgb(255,255,255),0
set text size 10
text 10,10,"Lives: "+str$(lives#)
text 100,10,"Score: "+str$(score#)
text 550,10,"FPS: "+str$(FPS#)

oBposX# = object position X(5)
oBposZ# = object position Z(5)
nBposX# = object position X(5)+Xmos#*2
nBposZ# = object position Z(5)+Zmos#*2
nBposY# = Get Ground Height(1,nBposX#,nBposZ#)
position object 5,nBposX#,nBposY#+1,nBposZ#

sync
loop

set display mode 1280, 1024, 32
sync on
sync rate 0
hide mouse
backdrop on
color backdrop 0
randomize timer()
autocam off



#constant GridSize 5
Type GridCell
   rate#
   col as DWORD
   r
   g
   b
   a#
EndType

Dim Grid(GridSize, GridSize) as GridCell

make memblock 1, 12 + (GridSize * GridSize * 4)
write memblock dword 1, 0, GridSize
write memblock dword 1, 4, GridSize
write memblock dword 1, 8, 32

for y=0 to GridSize-1
   for x=0 to GridSize-1
      InitializeCell(x,y)
   next x
next y
generateTexture()

make object plain 1, GridSize, GridSize
position object 1, 0, 0, 0
point object 1, 0, 1, 0
texture object 1, 1
set object transparency 1, 3
set object filter 1, 0
scale object 1, (15.0/GridSize)*100.0, (15.0/GridSize)*100.0, 100.0
TileSize# = object size x(1) / GridSize



`Underlayer
make object cube 2, TileSize#
make mesh from object 1, 2
n=1
for y = 0 to GridSize-1
   for x = 0 to GridSize-1
      if x > 0 OR y > 0
         add limb 2, n, 1
         offset limb 2, n, x*TileSize#, 0.0, y*TileSize#
         inc n
      endif
   next x
next y
position object 2, -TileSize#*2, -TileSize#, -TileSize#*2
set object transparency 2, 3
make memblock 2, 16
write memblock dword 2, 0, 1
write memblock dword 2, 4, 1
write memblock dword 2, 8, 32
write memblock dword 2, 12, rgba(255,255,255,8)
make image from memblock 2,2
delete memblock 2
texture object 2, 2





`player stuff
type PlayerData
   x#
   y#
   z#
   sX#
   sY#
   sZ#
   jumpPower#
endtype
make object sphere 3, TileSize#*0.25, 24, 24

P as PlayerData
P.x# = 0.0
P.y# = TileSize#*0.125
P.z# = 0.0
P.x# = 0.0
P.y# = 0.0
P.sZ# = 0.0
P.jumpPower# = 0.0
#constant maxJump 40
make memblock 2, 12 + (4 * (maxJump+3) * 6)
write memblock dword 2, 0, 6
write memblock dword 2, 4, maxJump+3
write memblock dword 2, 8, 32

white as DWORD: white = rgb(255,255,255)
black as DWORD: black = rgb(0,0,0)
semiblack as DWORD: semiblack = rgba(255,255,255,96)
jump  as DWORD: jump  = rgba(255,0,0, 96)


position camera 0, 20, 0
point camera 0,0,0
global frameTime# = 1.0
startTime = timer()
do
   frameTime# = (frameTime# * 0.8) + ((timer() - startTime) * 0.2)
   startTime = timer()
   text 10, 10, "FPS: " + str$(screen fps())
   text 10, 30, "ts = " + str$(TileSize#)

   `Controls
   if P.y# > TileSize#*0.125
      if keystate(200)
         `up
         inc P.sZ#, frameTime# * 0.01
      endif
      if keystate(208)
         `down
         dec P.sZ#, frameTime# * 0.01
      endif
      if keystate(205)
         `right
         inc P.sX#, frameTime# * 0.01
      endif
      if keystate(203)
         `left
         dec P.sX#, frameTime# * 0.01
      endif
   endif

   P.sX# = curvevalue(0.0, P.sX#, 500.0/ frameTime#)
   inc P.sY#, frameTime# * -0.05
   P.sZ# = curvevalue(0.0, P.sZ#, 500.0/ frameTime#)


   inc P.x#, P.sX# * frameTime# * 0.001
   inc P.y#, P.sY# * frameTime# * 0.001
   inc P.z#, P.sZ# * frameTime# * 0.001
   position object 3, P.x#, P.y#, P.z#

   if P.y# <= TileSize#*0.125 AND P.sY# < 0.0 then P.sY# = 0.0

   if P.y# <= TileSize#*0.125 AND keystate(57)
      inc P.jumpPower#, frameTime# * 0.02
      if P.jumpPower# > maxJump then P.jumpPower# = maxJump
      jX# = object screen x(3) + 20.0
      jY# = object screen y(3) - maxJump

      c as dword
      for x = 0 to 5
         write memblock dword 2, 12 + (x*4), semiblack
      next x
      for y = 0 to maxJump
         if y <= P.jumpPower# then c = jump else c = 0
         y2 = maxJump-y+1
         write memblock dword 2, 12 + (0 + ((maxJump-y)*6))*4, semiblack
         for x = 1 to 4
            write memblock dword 2, 12 + (x + (y2*6))*4, c
         next x
         write memblock dword 2, 12 + (5 + ((maxJump-y)*6))*4, semiblack
      next y
      for x = 0 to 5
         write memblock dword 2, 12 + (x + ((maxJump+1)*6))*4, semiblack
      next x
      make image from memblock 3, 2
      paste image 3, jX#, jY#, 1
   else
      if P.jumpPower# > 0.0
         P.sY# = P.jumpPower#
         P.jumpPower# = 0.0
      endif
   endif



   `Underlayer
   for i = 0 to n-1
      if i mod 2 = 0
         rotate limb 2, i, limb angle x(2,i) + frameTime#*0.090, 0, 0
      else
         rotate limb 2, i, 0, 0, limb angle z(2,i) + frameTime#*0.090
      endif
   next i

   `Upper layer
   generateTexture()
   sync
loop




function generateTexture()
   for y=0 to GridSize-1
      for x=0 to GridSize-1
         inc Grid(x,y).a#, frameTime# * 0.01 * Grid(x,y).rate#
         if Grid(x,y).a# > 255.0 then InitializeCell(x, y)
         if Grid(x,y).a# < 32.0 then a# = 0.0 else a# = Grid(x,y).a#
         write memblock dword 1, 12 + (x + (y*GridSize))*4, rgba(Grid(x,y).r, Grid(x,y).g, Grid(x,y).b, a#)
      next x
   next y
   make image from memblock 1, 1
endfunction








function InitializeCell(x, y)
   Grid(x,y).rate# = 0.5 + (rnd(100) * 0.001) :`Gives range of 0.5-1.5
   Grid(x,y).a# = 0.0
   Grid(x,y).r = 191 + rnd(64)
   Grid(x,y).g = 191 + rnd(64)
   Grid(x,y).b = 191 + rnd(64)
endfunction







function rgba(r as integer,g as integer,b as integer,a as integer)
  colour as dword
  colour = (b)+(g*256)+(r*65536)+(a*16777216)
endfunction colour

set display mode 1280, 1024, 32
sync on
sync rate 0
hide mouse
backdrop on
color backdrop 0
randomize timer()
autocam off
`predefined colors
white as DWORD: white = rgb(255,255,255)
black as DWORD: black = rgb(0,0,0)
border as DWORD: border = rgba(255,255,255,96)
jump  as DWORD: jump  = rgba(255,0,0, 96)
`shadow as DWORD: shadow = rgba(0,0,0,96)


#constant GridSize 5
Type GridCell
   rate#
   col as DWORD
   r
   g
   b
   a#
EndType

Dim Grid(GridSize, GridSize) as GridCell

make memblock 1, 12 + (GridSize * GridSize * 4)
write memblock dword 1, 0, GridSize
write memblock dword 1, 4, GridSize
write memblock dword 1, 8, 32

for y=0 to GridSize-1
   for x=0 to GridSize-1
      InitializeCell(x,y)
   next x
next y
generateTexture()

make object plain 1, GridSize, GridSize
position object 1, 0, 0, 0
point object 1, 0, 1, 0
texture object 1, 1
set object transparency 1, 3
set object filter 1, 0
scale object 1, (15.0/GridSize)*100.0, (15.0/GridSize)*100.0, 100.0
TileSize# = object size x(1) / GridSize



`Underlayer
make object cube 2, TileSize#
make mesh from object 1, 2
n=1
for y = 0 to GridSize-1
   for x = 0 to GridSize-1
      if x > 0 OR y > 0
         add limb 2, n, 1
         offset limb 2, n, x*TileSize#, 0.0, y*TileSize#
         inc n
      endif
   next x
next y
position object 2, -TileSize#*2, -TileSize#, -TileSize#*2
set object transparency 2, 3
make memblock 2, 16
write memblock dword 2, 0, 1
write memblock dword 2, 4, 1
write memblock dword 2, 8, 32
write memblock dword 2, 12, rgba(255,255,255,8)
make image from memblock 2,2
delete memblock 2
texture object 2, 2





`player stuff
type PlayerData
   x#
   y#
   z#
   sX#
   sY#
   sZ#
   jumpPower#
endtype
make object sphere 3, TileSize#*0.25, 24, 24

P as PlayerData
P.x# = 0.0
P.y# = TileSize#*0.125
P.z# = 0.0
P.x# = 0.0
P.y# = 0.0
P.sZ# = 0.0
P.jumpPower# = 0.0
#constant maxJump 40
make memblock 2, 12 + (4 * (maxJump+3) * 6)
write memblock dword 2, 0, 6
write memblock dword 2, 4, maxJump+3
write memblock dword 2, 8, 32


`Make shadow
#constant shadowRes 63
make memblock 3, 12 + (shadowRes * shadowRes * 4)
write memblock dword 3, 0, shadowRes
write memblock dword 3, 4, shadowRes
write memblock dword 3, 8, 32
center# = (shadowRes*0.50)
a as dword
for y=0 to shadowRes-1
   for x = 0 to shadowRes-1
      a# = sqrt(((center#-y)*(center#-y)) + ((center#-x)*(center#-x)))
      a# = a# / sqrt((shadowRes*shadowRes)* 0.25)
      a = 192-(a#*192)
      if a < 0 then a = 0 else if a > 255 then a = 255
      write memblock dword 3, 12 + ((x + (y*shadowRes))*4), rgba(0,0,0,a)
   next x
next y

make image from memblock 4, 3
delete memblock 3
make object plain 4, TileSize#*0.25, TileSize#*0.25
position object 4, 0.0, 0.000, 0.0
xrotate object 4, 90
texture object 4, 4
set object transparency 4,3
set object light 4,0










position camera 0, 20, 0
point camera 0,0,0
global frameTime# = 1.0
startTime = timer()
do
   frameTime# = (frameTime# * 0.8) + ((timer() - startTime) * 0.2)
   startTime = timer()

   text 10, 10, "FPS: " + str$(screen fps())
   text 10, 30, "ts = " + str$(TileSize#)

   `Controls
   if P.y# > TileSize#*0.125
      if keystate(200)
         `up
         inc P.sZ#, frameTime# * 0.01
      endif
      if keystate(208)
         `down
         dec P.sZ#, frameTime# * 0.01
      endif
      if keystate(205)
         `right
         inc P.sX#, frameTime# * 0.01
      endif
      if keystate(203)
         `left
         dec P.sX#, frameTime# * 0.01
      endif
   endif

   P.sX# = curvevalue(0.0, P.sX#, 500.0/ frameTime#)
   inc P.sY#, frameTime# * -0.05
   P.sZ# = curvevalue(0.0, P.sZ#, 500.0/ frameTime#)


   inc P.x#, P.sX# * frameTime# * 0.001
   inc P.y#, P.sY# * frameTime# * 0.001
   inc P.z#, P.sZ# * frameTime# * 0.001
   position object 3, P.x#, P.y#, P.z#
   position object 4, P.x#, 0.1, P.z#

   if P.y# <= TileSize#*0.125 AND P.sY# < 0.0 then P.sY# = 0.0

   if P.y# <= TileSize#*0.125 AND keystate(57)
      gosub MakeJumpBar
   else
      if P.jumpPower# > 0.0
         P.sY# = P.jumpPower#+20.0
         P.jumpPower# = 0.0
      endif
   endif



   `Underlayer
   for i = 0 to n-1
      if i mod 2 = 0
         rotate limb 2, i, limb angle x(2,i) + frameTime#*0.090, 0, 0
      else
         rotate limb 2, i, 0, 0, limb angle z(2,i) + frameTime#*0.090
      endif
   next i

   `Upper layer
   generateTexture()
   sync
loop
end




MakeJumpBar:
   inc P.jumpPower#, frameTime# * 0.02
   if P.jumpPower# > maxJump then P.jumpPower# = maxJump
   jX# = object screen x(3) + 20.0
   jY# = object screen y(3) - maxJump

   c as dword
   for x = 0 to 5
      write memblock dword 2, 12 + (x*4), border
   next x
   for y = 0 to maxJump
      if y <= P.jumpPower# then c = jump else c = 0
      y2 = maxJump-y+1
      write memblock dword 2, 12 + (0 + ((maxJump-y)*6))*4, border
      for x = 1 to 4
         write memblock dword 2, 12 + (x + (y2*6))*4, c
      next x
      write memblock dword 2, 12 + (5 + ((maxJump-y)*6))*4, border
   next y
   for x = 0 to 5
      write memblock dword 2, 12 + (x + ((maxJump+1)*6))*4, border
   next x
   make image from memblock 3, 2
   paste image 3, jX#, jY#, 1
return
















function generateTexture()
   for y=0 to GridSize-1
      for x=0 to GridSize-1
         inc Grid(x,y).a#, frameTime# * 0.01 * Grid(x,y).rate#
         if Grid(x,y).a# > 255.0 then InitializeCell(x, y)
         if Grid(x,y).a# < 32.0 then a# = 0.0 else a# = Grid(x,y).a#
         write memblock dword 1, 12 + (x + (y*GridSize))*4, rgba(Grid(x,y).r, Grid(x,y).g, Grid(x,y).b, a#)
      next x
   next y
   make image from memblock 1, 1
endfunction








function InitializeCell(x, y)
   Grid(x,y).rate# = 0.5 + (rnd(100) * 0.001) :`Gives range of 0.5-1.5
   Grid(x,y).a# = 0.0
   Grid(x,y).r = 191 + rnd(64)
   Grid(x,y).g = 191 + rnd(64)
   Grid(x,y).b = 191 + rnd(64)
endfunction







function rgba(r as integer,g as integer,b as integer,a as integer)
  colour as dword
  colour = (b)+(g*256)+(r*65536)+(a*16777216)
endfunction colour

`Started: 17/04/2005 -> 3:20am
`Description: short breakout program to help any new programmers to visualise other methods of detecting collision,
`             and how to use user defined types effectively.
`             not a particularly great game tho ^_^

`constant describing the force of gravity
#constant grav = 0.2
#constant padSize = 50.0
#constant blockSize = 30.0
#constant tailSize = 5
`type describing a 2D vector
type vector
   x as float
   y as float
endtype

`type describing an object with movement and position vectors
type object
   move as vector
   pos as vector
endtype

`type describing a surface with force and position vectors
type surface
   force as vector
   pos as vector
endtype

`type describing a entity which has a position a force and may be active or inactive
`i refuse to use DarkBasic boolean as it causes many problems in some functions where they wont work
`i strongly reccomend you do NOT use booleans in your program as it causes many internal bugs of darkbasic to surface
type entity
   isActive as integer
   pos as vector
endtype

`variable to hold the position and movement vector of the ball
ball as object
   ball.move.x = 5
   ball.move.y = -10
   ball.pos.x = 400
   ball.pos.y = 400

`define an array to hold the positions and forces of the walls
dim wall(1) as surface
   `Left wall
   wall(0).pos.x = 10
   wall(0).force.x = 10
   `Right Wall
   wall(1).pos.x = 790
   wall(1).force.x = -10
   `Top Wall
   wall(0).pos.y = 10
   wall(0).force.y = 10
   `Lower Wall
   wall(1).pos.y = 590
   wall(1).force.y = 0

`define an array to hold the positions and forces of the pads
pad as surface
   `values for the 1st pad
   pad.pos.y = 500
   pad.force.x = -500
   pad.force.y = -1000

`define an array to hold the positions of the ball tail
dim tail(tailSize) as vector
   for tailNum = 0 to 5
      tail(tailNum).x = ball.pos.x
      tail(tailNum).y = ball.pos.y
   next tailNum

`define an array for the blocks
dim blocks(49) as entity
   for xPos = 0 to 9
   for yPos = 0 to 4
      blocks(blockNum).isActive = 1
      blocks(blockNum).pos.x = 130 + 60 * xPos
      blocks(blockNum).pos.y = 120 + 40 * yPos
      inc blockNum
   next yPos
   next xPos
`setup directX display
set display mode 800,600,32

`define the sychronisation rate and flip the buffers twice
sync on : sync rate 30
sync : sync

`hide the mouse cursor
hide mouse

`main loop
do
   `user controls the pad and checks for collision with the wall
   pad.pos.x = mousex()
   pad.force.x = mouseMovex()
   if abs(pad.pos.x - wall(0).pos.x) < padSize then pad.pos.x = wall(0).pos.x + padSize
   if abs(pad.pos.x - wall(1).pos.x) < padSize then pad.pos.x = wall(1).pos.x - padSize
   `allow user to reset the ball
   if spacekey() && ball.pos.y = wall(1).pos.y
   ball.move.x = 10
   ball.move.y = -20
   ball.pos.x = 400
   ball.pos.y = 400
   endif
   `calculate the users x force
   userX# = curveValue( (rightkey()-leftkey()) * 0.4 , userX# , 10 )
   `call ball control function to refresh the ball data
   controlBall()
   `draw walls
   drawBox( wall(0).pos.x , wall(0).pos.y , wall(1).pos.x , wall(1).pos.y , rgb(255,0,0) )
   drawBox( wall(0).pos.x + 10 , wall(0).pos.y + 10 , wall(1).pos.x - 10 , wall(1).pos.y - 10 , rgb(128,0,0) )
   drawBox( wall(0).pos.x + 20 , wall(0).pos.y + 20 , wall(1).pos.x - 20 , wall(1).pos.y - 20 , rgb(64,0,0) )
   drawBox( wall(0).pos.x + 30 , wall(0).pos.y + 30 , wall(1).pos.x - 30 , wall(1).pos.y - 30 , rgb(32,0,0) )
   `draw tail of ball first so the ball with have priority on screen display
   for tailPos = 0 to 5
      drawBall( tail(tailPos).x , tail(tailPos).y , 5 , 2 , rgb(0,128,255) )
   next tailPos
   inc tailNum
   `control move the pointer to the next ball
   if tailNum > tailSize then tailNum = 0
   tail(tailNum).x = ball.pos.x
   tail(tailNum).y = ball.pos.y
   `draw ball
   drawBall( ball.pos.x , ball.pos.y , 10 , 3 , rgb(0,0,255) )
   `draw pads
   drawPad( pad.pos.x , pad.pos.y , padSize , rgb(255,128,0) )
   `draw blocks
   for blockNum = 0 to 49
      if blocks(blockNum).isActive = 1 then drawPad( blocks(blockNum).pos.x , blocks(blockNum).pos.y , blockSize , RGB(64,0,128) )
   next blockNum
   `synchronise the screen
   sync
   `clear screen to avoid pixel dragging
   cls
   `end main loop
loop

`function to control movement of the ball
function controlBall()
   null = make vector2(1)
      set vector2 1 , ball.move.x , ball.move.y
      magnitude# = length vector2(1)
      divide vector2 1 , magnitude#
      repeat
         for blockNum = 0 to 49
            if blocks(blockNum).isActive = 1
               if ( abs(ball.pos.x - blocks(blockNum).pos.x) <= blockSize ) && ( abs(ball.pos.y - blocks(blockNum).pos.y) <= blockSize / 4 )
                  blocks(blockNum).isActive = 0
                  ball.move.y = - ball.move.y
               endif
               inc totalBlocks
            endif
         next blockNum
         if totalBlocks = 0
            for blockNum = 0 to 49
               blocks(blockNum).isActive = 1
            next blockNum
         endif
         if ( abs(ball.pos.x - pad.pos.x) <= padSize ) && ( abs(ball.pos.y - pad.pos.y) <= padSize / 4 )
            inc ball.move.x , - (ball.pos.x - pad.pos.x) * (1/pad.force.x)
            ball.move.y = - 20
         endif
         `work out the inverse square law of the forces on the walls and add pad force
         `inverse square law = ( 1 / distance^2 ) * force
         xForce# = ((1 / (3+abs(ball.pos.x - wall(0).pos.x))^2) * wall(0).force.x) + ((1 / (1+abs(ball.pos.x - wall(1).pos.x))^2) * wall(1).force.x / magnitude#)
         yForce# = ((3 / (1+abs(ball.pos.y - wall(0).pos.y))^2) * wall(0).force.y) + ((1 / (1+abs(ball.pos.y - wall(1).pos.y))^2) * wall(1).force.y / magnitude#)
         `add the wall force to the ball movement vectors. add gravity
         inc ball.move.x , xForce#
         inc ball.move.y , yForce# + grav / magnitude#
         `add movement vector and user input to the ball position
         inc ball.pos.x , ball.move.x / magnitude#
         inc ball.pos.y , ball.move.y / magnitude#
         `check for actual wall collision
         if ball.pos.x < wall(0).pos.x
            ball.pos.x = wall(0).pos.x
         endif
         if ball.pos.x > wall(1).pos.x
            ball.pos.x = wall(1).pos.x
         endif
         if ball.pos.y < wall(0).pos.y
            ball.pos.y = wall(0).pos.y
         endif
         if ball.pos.y > wall(1).pos.y
            ball.pos.y = wall(1).pos.y
         endif
         inc count# , 1 / magnitude#
      until count# > 1
   null = delete vector2(1)
endfunction

`function to draw the ball
function drawBall( xPos , yPos , size# , segments , color)
   increment# = size# / segments
   for seg = 1 to segments
      ink rgb( rgbr(color)/seg , rgbg(color)/seg , rgbb(color)/seg ) , 0
      circle xPos , yPos , increment# * seg
   next seg
endfunction

`function to draw a box
function drawBox( lf , up , rt , dn , color)
   ink color , 0
   line lf , up , rt , up
   line rt , up , rt , dn
   line rt , dn , lf , dn
   line lf , dn , lf , up
endfunction

`function to draw a pad
function drawPad( xPos , yPos , size# , color )
   ink color , 0
   drawBox( xPos - size# , yPos - size# / 4 , xPos + size# , yPos + size# / 4 , rgb( rgbr(color)/2 , rgbg(color)/2 , rgbb(color)/2 ) )
   drawBox( xPos - (size# * 0.5) , yPos - (size# * 0.5) / 4 , xPos + (size# * 0.5) , yPos + (size# * 0.5) / 4 , color )
endfunction

Rem Project: breakout
Rem Created: 14/04/2005 22:57:49

Rem ***** Main Source File *****

set display mode 1024,768,32
sync on
sync rate 100
autocam off
color backdrop 0
hide light 0
set ambient light 20
make light 1
position light 1,-10,40,20
position camera 0,10,-20
point camera 0,0,0

gosub make_textures

make object sphere 1,0.5,20,20
set object specular power 1,60
set object specular 1,rgb(200,200,200)

x#=6
z#=6
xspeed#=0.1
zspeed#=0.1

gosub make_bricks
gosub make_walls

do

gosub move_ball
gosub move_bricks
gosub collision_with_bricks
gosub collision_with_walls

text 0,0,str$(screen fps())
sync
loop

make_textures:

cls
for n=0 to 100
ink rgb(n+155,0,0),0
line 0,n,100,n
next n
get image 1,0,0,100,100

cls
for n=0 to 100
ink rgb(0,n+155,0),0
line 0,n,100,n
next n
get image 2,0,0,100,100

cls
for n=0 to 100
ink rgb(0,0,n+155),0
line 0,n,100,n
next n
get image 3,0,0,100,100

cls
for n=0 to 100
ink rgb(n+155,0,n+155),0
line 0,n,100,n
next n
get image 4,0,0,100,100

cls
for n=0 to 100
ink rgb(n+155,n+85,0),0
line 0,n,100,n
next n
get image 5,0,0,100,100

cls
for n=0 to 100
ink rgb(0,n+155,n+155),0
line 0,n,100,n
next n
get image 6,0,0,100,100

return

make_bricks:

make object cube 10,1
hide object 10

brickseed=100
numberofbricks=25
x=-4
z=-4
for brick=brickseed to brickseed+numberofbricks-1
if brick-brickseed<>12 then make object sphere brick,1.6,20,20 else make object sphere brick,2,4,4
glue object to limb brick,10,0
`scale object brick,200,100,200
image=rnd(5)+1
if brick-brickseed<>12 then texture object brick,image else texture object brick,1
set object specular power brick,60
set object specular brick,rgb(200,200,200)
position object brick,x,0,z
inc x,2
if x>4 then x=-4:inc z,2
next brick

return

make_walls:

make object plain 20,20,20
texture object 20,3
xrotate object 20,-90
ghost object on 20

return

move_bricks:

if upkey()=1 then move object 10,.1
if downkey()=1 then move object 10,-.1
if leftkey()=1 then turn object left 10,1
if rightkey()=1 then turn object right 10,1

return


move_ball:

inc x#,xspeed#
inc z#,zspeed#

position object 1,x#,0,z#


return

collision_with_bricks:

for brick=brickseed to brickseed+numberofbricks
if object exist(brick)=1
distleft#=intersect object (brick,object position x(1),object position y(1),object position z(1),object position x(1)+2,object position y(1),object position z(1))
if distleft#=0 then distleft#=1000
if distleft#<0.5 then xspeed#=xspeed#*-1:delete object brick:exit
distright#=intersect object (brick,object position x(1),object position y(1),object position z(1),object position x(1)-2,object position y(1),object position z(1))
if distright#=0 then distright#=1000
if distright#<0.5 then xspeed#=xspeed#*-1:delete object brick:exit
distinfront#=intersect object (brick,object position x(1),object position y(1),object position z(1),object position x(1),object position y(1),object position z(1)+2)
if distinfront#=0 then distinfront#=1000
if distinfront#<0.5 then zspeed#=zspeed#*-1:delete object brick:exit
distbehind#=intersect object (brick,object position x(1),object position y(1),object position z(1),object position x(1),object position y(1),object position z(1)-2)
if distbehind#=0 then distbehind#=1000
if distbehind#<0.5 then zspeed#=zspeed#*-1:delete object brick:exit
endif
next brick


return

collision_with_walls:

if x#>10 then x#=10:xspeed#=xspeed#*-1
if x#<-10 then x#=-10:xspeed#=xspeed#*-1

if z#>10 then z#=10:zspeed#=zspeed#*-1
if z#<-10 then z#=-10:zspeed#=zspeed#*-1

return