Sorry your browser is not supported!

Rem Project: top down racer
Rem Created: 14/03/2007 11:04:37

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

set display mode 1024,768,32
sync on
sync rate 60
hide light 0
color backdrop 0

make light 1
position light 1,0,50,100
set light range 1,500


`constants
matrixsizex=100
matrixsizez=100
xsegments=10
zsegments=10
tileimagesize=64
numberofcars=6

camx#=matrixsizex/2.0
camy#=80
camz#=matrixsizez/2.0

type tiletype

imagenumber as integer
tilenumber as integer
height as float
posx as float
posy as float
waypoint as integer

endtype

type cartype

objectnumber as integer
x as float
y as float
z as float
fi as float
fl as float
fd as float
fb as float
maxfd as float
maxfb as float
fx as float
fz as float
ax as float
az as float
vx as float
vz as float
ang as float
turnspeed as float
slow as integer
waypoint as integer
waypointset as integer
targetangle as float

endtype

type waypointtype

x as float
z as float

endtype

gosub make_track
gosub make_cars


position camera camx#,camy#,camz#
point camera camx#,0,camz#


ink -1,0
do
`text 0,0,str$(screen fps())
`text 0,0,"inline friction: "+str$(inlinefriction#)
`text 0,20,"car angle: "+str$(car(player).ang)
`text 0,40,"direction of travel"+str$(directionoftravel#)
`text 0,60,"difference: "+str$(angle#)
`text 0,80,"lateral friction: "+str$(lateralfriction#)
`text 0,100,"waypoint: "+str$(car(2).waypoint)
`text 0,120,"waypointx: "+str$(waypoint(car(2).waypoint).x)
`text 0,140,"waypointz: "+str$(waypoint(car(2).waypoint).z)

gosub move_player
gosub ai
gosub move_cars
gosub collision

sync
loop




collision:

for n=1 to numberofcars
tilex=int(car(n).x/(matrixsizex/xsegments))
tilez=int(car(n).z/(matrixsizez/zsegments))
if tilex>xsegments-1 then tilex=xsegments-1
if tilez>zsegments-1 then tilez=zsegments-1
if tile(tilex,tilez).imagenumber=5
  car(n).slow=1
  set object emissive car(n).objectnumber,rgb(255,128,0)
else 
  car(n).slow=0
  set object emissive car(n).objectnumber,rgb(80,80,80)
endif
next n

return

ai:

for n=1 to numberofcars
  if n<>player
    car(n).fd=car(n).maxfd
    if car(n).slow=1 then car(n).fb=car(n).maxfb else car(n).fb=0
    if car(n).waypointset=0
      inc car(n).waypoint
      if car(n).waypoint>20 then car(n).waypoint=1
      car(n).waypointset=1
      oldang#=car(n).ang 
    endif
    point object car(n).objectnumber,waypoint(car(n).waypoint).x,0,waypoint(car(n).waypoint).z
    car(n).targetangle=object angle y(car(n).objectnumber)
    rotate object car(n).objectnumber,0,oldang#,0
    rotate object car(n).objectnumber,0,curveangle(car(n).targetangle,car(n).ang,10),0
    car(n).ang=object angle y(car(n).objectnumber)
    tilex=int(car(n).x/(matrixsizex/xsegments))
    tilez=int(car(n).z/(matrixsizez/zsegments))
    if tile(tilex,tilez).waypoint=car(n).waypoint then car(n).waypointset=0
  endif
next n

return

move_player:

player=1

if upkey()=1 then car(player).fd=car(player).maxfd else car(player).fd=0
if downkey()=1 or car(player).slow=1 then car(player).fb=car(player).maxfb else car(player).fb=0

if leftkey()=1 then dec car(player).ang,car(player).turnspeed
if rightkey()=1 then inc car(player).ang,car(player).turnspeed

return

move_cars:

for n=1 to numberofcars



`calculate resultant velocity size and direction of travel from previous loop
vresultant#=sqrt(car(n).vx^2+car(n).vz^2)
directionoftravel#=atanfull(car(n).vx,car(n).vz)

`calculate angle between car and direction of travel
angle#=differencebetweentwoangles(car(n).ang,directionoftravel#)

`calculate inline friction size
inlinefriction#=(car(n).fi+car(n).fb)*vresultant#*cos(angle#)
if inlinefriction#<0 then inlinefriction#=0
`calculate x and z components of inline friction
inlinefrictionx#=inlinefriction#*sin(directionoftravel#)
inlinefrictionz#=inlinefriction#*cos(directionoftravel#)

`calculate lateral friction size
lateralfriction#=car(n).fl*vresultant#*sin(angle#)

`calculate x and z components of lateral friction
lateralfrictionx#=lateralfriction#*sin(directionoftravel#)
lateralfrictionz#=lateralfriction#*cos(directionoftravel#)

`calculate total friction
totalfrictionx#=(inlinefrictionx#+lateralfrictionx#)
totalfrictionz#=(inlinefrictionz#+lateralfrictionz#)

`calculate x and z force components due to drive
car(n).fx=car(n).fd*sin(car(n).ang)
car(n).fz=car(n).fd*cos(car(n).ang)

`calculate new x and z velocity components due to driving and frictional forces
inc car(n).vx,car(n).fx-totalfrictionx#
inc car(n).vz,car(n).fz-totalfrictionz#

`update positions
inc car(n).x,car(n).vx
inc car(n).z,car(n).vz
car(n).y=get ground height(1,car(n).x,car(n).z)

rotate object car(n).objectnumber,0,car(n).ang,0
position object car(n).objectnumber,car(n).x,car(n).y,car(n).z

next n


return


make_cars:

dim car(numberofcars) as cartype

for n=1 to numberofcars
  car(n).objectnumber=free_object()
  make object box car(n).objectnumber,1,0.2,2
  
  if n=1 then color object car(n).objectnumber,rgb(255,0,0)
  if n=2 then color object car(n).objectnumber,rgb(255,255,0)
  if n=3 then color object car(n).objectnumber,rgb(255,0,255)
  if n=4 then color object car(n).objectnumber,rgb(0,255,0)
  if n=5 then color object car(n).objectnumber,rgb(0,255,255)
  if n=6 then color object car(n).objectnumber,rgb(0,0,255)
  
  disable object zdepth car(n).objectnumber
  
  wheel1=free_object()
  make object box wheel1,0.4,0.2,0.4
  position object wheel1,-0.5,0,0.7
  disable object zdepth wheel1
  color object wheel1,rgb(0,0,0)
  glue object to limb wheel1,car(n).objectnumber,0
  wheel2=free_object()
  make object box wheel2,0.4,0.2,0.4
  position object wheel2,0.5,0,0.7
  disable object zdepth wheel2
  color object wheel2,rgb(0,0,0)
  glue object to limb wheel2,car(n).objectnumber,0
  wheel3=free_object()
  make object box wheel3,0.6,0.2,0.5
  position object wheel3,-0.5,0,-0.7
  disable object zdepth wheel3
  color object wheel3,rgb(0,0,0)
  glue object to limb wheel3,car(n).objectnumber,0
  wheel4=free_object()
  make object box wheel4,0.6,0.2,0.5
  position object wheel4,0.5,0,-0.7
  disable object zdepth wheel4
  color object wheel4,rgb(0,0,0)
  glue object to limb wheel4,car(n).objectnumber,0
  body=free_object()
  make object box body,0.4,0.3,2.4
  glue object to limb body,car(n).objectnumber,0
  disable object zdepth body
  tail=free_object()
  make object box tail,1.2,0.3,0.4
  position object tail,0,0,-1.3
  glue object to limb tail,car(n).objectnumber,0
  disable object zdepth tail
   
  
  
 if xoffset=0 then xoffset=4 else xoffset=0
  car(n).x=13+xoffset
  car(n).y=0.5
  car(n).z=25-n*2
  car(n).fi=0.01 `force due to inline friction
  car(n).fl=0.03 `force due to lateral friction
  car(n).maxfd=0.01+n*0.0005 `force due to drive
  car(n).maxfb=0.04 `force due to braking friction
  car(n).turnspeed=2
  position object car(n).objectnumber,car(n).x,car(n).y,car(n).z
next n

return

make_track:


make matrix 1,matrixsizex,matrixsizez,xsegments,zsegments

`grid
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for y=0 to tileimagesize step 8
for x=0 to tileimagesize step 8
if white=0 then white=1 else white=0
if white=1
box x,y,x+8,y+8
endif
next x
next y

for n=0 to 4
line 0,n,tileimagesize,n
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n

grid=2
get image grid,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road vertical
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n

road1=8
get image road1,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1



`road horizontal
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1

ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
box n*tileimagesize/10.0,tileimagesize-6,(n+1)*tileimagesize/10.0,tileimagesize-2
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
box n*tileimagesize/10.0,tileimagesize-6,(n+1)*tileimagesize/10.0,tileimagesize-2
next n


road2=6
get image road2,0,0,tileimagesize,tileimagesize,1

set current bitmap 0
delete bitmap 1

`road bend 7
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1

ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
next n

box tileimagesize-6,tileimagesize-6,tileimagesize-2,tileimagesize-2


road7=7
get image road7,0,0,tileimagesize,tileimagesize,1

set current bitmap 0
delete bitmap 1

`road bend 9
inc numberofimages
temp=free_sprite()
sprite temp,-100,-100,road7
mirror sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road9=9
get image road9,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road bend 3
inc numberofimages
flip sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road3=3
get image road3,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road bend 1
inc numberofimages
mirror sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road1=1
get image road1,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1
         






`grass
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(0,200,0),0
box 0,0,tileimagesize,tileimagesize
ink rgb(0,220,0),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(0,210,0),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
blur bitmap 1,1
grass=5
get image grass,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`create matrix texture
ink 0,0
dim tile(xsegments,zsegments) as tiletype
create bitmap 1,xsegments*tileimagesize,zsegments*tileimagesize
restore datastatements

create bitmap 1,9*tileimagesize,tileimagesize
for imagenumber=1 to 9
  if image exist(imagenumber)=1
    paste image imagenumber,(imagenumber-1)*tileimagesize,0
  endif
next imagenumber
matrixtexture=free_image()
get image matrixtexture,0,0,9*tileimagesize,tileimagesize
delete bitmap 1

prepare matrix texture 1,matrixtexture,9,1
set matrix trim 1,0.003,0.003

`read texture map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).imagenumber
  next x
next z

`read height map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).height
  next x
next z

dim waypoint(40) as waypointtype
`read waypoint map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).waypoint
    if tile(x,z).waypoint>0
      if tile(x,z).imagenumber=8 or tile(x,z).imagenumber=6 or tile(x,z).imagenumber=2 then offsetx#=0.5:offsetz#=0.5
      if tile(x,z).imagenumber=7 then offsetx#=0.8:offsetz#=0.2
      if tile(x,z).imagenumber=9 then offsetx#=0.2:offsetz#=0.2
      if tile(x,z).imagenumber=3 then offsetx#=0.2:offsetz#=0.8
      if tile(x,z).imagenumber=1 then offsetx#=0.8:offsetz#=0.8
      waypoint(tile(x,z).waypoint).x=(x+offsetx#)*matrixsizex/xsegments
      waypoint(tile(x,z).waypoint).z=(z+offsetz#)*matrixsizez/zsegments
    endif
  next x
next z

tile=0
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    inc tile
    tile(x,z).tilenumber=tile
    set matrix tile 1,x,z,tile(x,z).imagenumber
    set matrix height 1,x,z,tile(x,z).height
  next x
next z

matnum=1

For Z = 1 To zsegments - 1
    For X = 1 To xsegments - 1

      rem Get matrix heights
      h8# = Get Matrix Height(MatNum,x,z-1)
      h4# = Get Matrix Height(MatNum,x-1,z)
      h#  = Get Matrix Height(MatNum,x,z)
      h2# = Get Matrix Height(MatNum,x,z)

      rem Calculate projected angle X using heights
      x1#=(x-1)*25.0 : y1#=h#
      x2#=(x+0)*25.0 : y2#=h4#
      dx#=x2#-x1#
      dy#=y2#-y1#
      ax# = AtanFull(dx#,dy#)
      ax# = WrapValue(90-ax#)

      rem Calculate projected angle Z using heights
      z1# = (z-1)*25.0 : y1#=h2#
      z2# = (z+0)*25.0 : y2#=h8#
      dz# = z2#-z1#
      dy# = y2#-y1#
      az# = AtanFull(dz#,dy#)
      az# = WrapValue(90-az#)

      rem Make normal from projected angle
      nx# = Sin(ax#)
      ny# = Cos(ax#)
      nz# = Sin(az#)

      rem Setting matrix normal for smoothness
      Set Matrix Normal MatNum,x,z,nx#,ny#,nz#

    Next X
  Next Z

`normal(1,xsegments,zsegments)


update matrix 1

return


function differencebetweentwoangles(angle2#,angle1#)


angle2#=wrapvalue(angle2#)
angle1#=wrapvalue(angle1#)
if angle1#>180 then dec angle1#,360
if angle2#>180 then dec angle2#,360
difference#=abs(angle2#-angle1#)
if difference#>180 then difference#=abs(difference#-360)

endfunction difference#



function normal(MatNum,MapSizeX,MapSizeZ)

for x=1 to MapSizeX-1
   for z=1 to MapSizeZ-1
      rem create regular normals for Terrain array

      rem  Vertices on the matrix
      rem    x-1,z-1    x,z-1
      rem    x-1,z      x,z

      rem Get stored heights
      h8#=tile(x,z-1).height
      h4#=tile(x-1,z).height
      h1#=tile(x,z).height

      rem Calculate projected angle X using heights
      y1#=h1#
      y2#=h4#
      rem X distance is a function of stepX#
      dx#=stepX#/10
      rem Y distance is the difference in height
      dy#=y2#-y1#
      ax#=atanfull(dx#,dy#)
      ax#=wrapvalue(90-ax#)

      rem Calculate projected angle Z using heights
      y1#=h1#
      y2#=h8#
      rem Z distance is a function of stepZ#
      dz#=stepZ#/10
      rem Y distance is the difference in height
      dy#=y2#-y1#
      az#=atanfull(dz#,dy#)
      az#=wrapvalue(90-az#)

      rem Make normal from projected angle
      nx# = Sin(ax#)
      ny# = Cos(ax#)
      nz# = Sin(az#)

      rem Setting matrix normal for smoothness
      Set Matrix Normal MatNum,x,z,nx#,ny#,nz#

   Next x
Next z
EndFunction




function free_image()

repeat
  inc n
until image exist(n)=0

endfunction n

function free_sprite()

repeat
  inc n
until sprite exist(n)=0

endfunction n


function free_object()

repeat
  inc n
until object exist(n)=0

endfunction n

datastatements:

`texturemap
data 5,5,5,5,5,5,5,5,5,5
data 5,7,6,6,6,6,6,9,5,5
data 5,8,5,5,5,5,5,1,9,5
data 5,1,6,6,6,9,5,5,8,5
data 5,5,5,5,5,1,9,5,8,5
data 5,7,6,9,5,5,8,5,8,5
data 5,8,5,1,6,6,3,5,8,5
data 5,2,5,5,5,5,5,5,8,5
data 5,1,6,6,6,6,6,6,3,5
data 5,5,5,5,5,5,5,5,5,5

`heightmap
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,0,4,9,9,9
data 0,0,0,0,0,0,4,9,9,9
data 0,0,0,3,3,3,0,9,9,9
data 0,0,0,3,3,3,0,4,4,4
data 0,0,0,5,5,5,0,0,0,0
data 0,0,0,5,5,5,0,0,0,0
data 0,0,0,5,5,5,0,0,0,0

`waypoints
data 00,00,00,00,00,00,00,00,00,00
data 00,11,00,00,12,00,00,13,00,00
data 00,00,00,00,00,00,00,00,14,00
data 00,10,09,00,00,08,00,00,00,00
data 00,00,00,00,00,00,07,00,00,00
data 00,02,00,03,00,00,00,00,15,00
data 00,01,00,00,04,05,06,00,00,00
data 00,00,00,00,00,00,00,00,16,00
data 00,20,19,00,00,18,00,00,17,00
data 00,00,00,00,00,00,00,00,00,00

set display mode 1024,768,32
sync on
backdrop on
sync rate 60
color backdrop rgb(128,128,255)
hide mouse
wall=0:offset=210:startx=10:startz=60:accel#=0.01:turnmax#=1.5:maxspeed#=0.1:start=0:laps_to_win=10:win=0:scol=192
dim col(5):dim bcol(5):dim cars#(5,3):dim laps(5,2)
total_cars=5
for x=0 to 5
  cars#(x,1)=0.0:cars#(x,2)=0.0:cars#(x,3)=maxspeed#
next x
gosub make_track
gosub make_lights
gosub make_cars
gosub laps_board
set global collision on
quit=0
starttime=timer()
while quit=0
  if start=2
    newtime=timer()-starttime
    dt#=newtime-oldtime
    oldtime=newtime
    uturn=0
    if leftkey()
      cars#(0,2)=cars#(0,2)-0.05
      if cars#(0,2)<-turnmax# then cars#(0,2)=-turnmax#
      uturn=1
    endif
    if rightkey()
      cars#(0,2)=cars#(0,2)+0.05
      if cars#(0,2)>turnmax# then cars#(0,2)=turnmax#
      uturn=1
    endif
    if upkey()
      cars#(0,1)=cars#(0,1)+accel#
      if cars#(0,1)>cars#(0,3)*dt# then cars#(0,1)=cars#(0,3)*dt#
    endif
    if downkey() then cars#(0,1)=cars#(0,1)-accel#
    for x=0 to total_cars
      if x>0
        turn=0
        if abs(object position x(car+x))+abs(object position z(car+x))<250.0
          this_offset=0
        else
          if object position x(car+x)<0.0
            this_offset=-offset
          else
            this_offset=offset
          endif
        endif
        car_angle=object angle y(car+x)
        if this_offset <> 0
          dist#=sqrt((object position x(car+x)-this_offset)^2+object position z(car+x)^2)
          if object position x(car+x)-this_offset<>0
            angle=atan((object position z(car+x))/(object position x(car+x)-this_offset))
          else
            angle=90
          endif
          if object position x(car+x)-this_offset<=0
            angle=angle+180
          else
            if object position z(car+x)<0 then angle=angle+360
          endif
          track_angle=90-angle
          if track_angle<0 then track_angle=track_angle+360
          if car_angle>330 and track_angle<30 then track_angle=track_angle+360
          if car_angle<30 and track_angle>330 then track_angle=track_angle-360
        else
          if laps(x,1)=0 or (laps(x,1)=1 and laps(x,2)=1)
            track_angle=315
          else
            track_angle=225
          endif
        endif
        turn=0
        if this_offset<0
          track_angle=track_angle-180
          if track_angle<0 then track_angle=track_angle+360
          if car_angle>330 and track_angle<30 then track_angle=track_angle+360
          if car_angle<30 and track_angle>330 then track_angle=track_angle-360
          if car_angle>track_angle then gosub turn_left
          if dist#>160+x and car_angle+15>track_angle then gosub turn_left
          if dist#<140-x and car_angle-15<track_angle then gosub turn_right
        endif
        if this_offset>0
          if car_angle<track_angle then gosub turn_right
          if dist#>160.0+x and car_angle-15<track_angle then gosub turn_right
          if dist#<140.0-x and car_angle+15>track_angle then gosub turn_left
        endif
        if this_offset=0
          if car_angle<track_angle then gosub turn_right
          if car_angle>track_angle then gosub turn_left
        endif
        for y=0 to total_cars
          if  y<>x
            dist#=sqrt((object position x(car+x)-object position x(car+y))^2+(object position z(car+x)-object position z(car+y))^2)
            if dist#<50.0
              dist2#=sqrt((object position x(car+x)+cos(object angle y(car+x))*dist#-object position x(car+y))^2+(object position z(car+x)-sin(object angle y(car+x))*dist#-object position z(car+y))^2)
              if dist2#<15.0
                dist=150-sqrt((object position x(car+x)-this_offset)^2+(object position z(car+x))^2)
                if dist=0 then dist=-1
                cars#(x,2)=cars#(x,2)+sgn(dist)*0.4
                if abs(cars#(x,2))>turnmax# then cars#(x,2)=turnmax#*sgn(cars#(x,2))
                y=5
              endif
            endif
          endif
        next y
        for y=2 to total_walls
          ds#=intersect object(y,object position x(car+x),0,object position z(car+x),object position x(car+x)+cos(object angle y(car+x)+30)*30,0,object position z(car+x)-sin(object angle y(car+x)+30)*30)
          if ds#>0.0 and ds#<15.0
            gosub turn_left
          endif
          ds#=intersect object(y,object position x(car+x),0,object position z(car+x),object position x(car+x)+cos(object angle y(car+x)-30)*30,0,object position z(car+x)-sin(object angle y(car+x)-30)*30)
          if ds#>0.0 and ds#<15.0
            gosub turn_right
          endif
        next y
        if turn=0 then cars#(x,2)=cars#(x,2)*0.5
        cars#(x,1)=cars#(x,1)+accel#
        if cars#(x,1)>cars#(x,3)*dt# then cars#(x,1)=cars#(x,3)*dt#
        if cars#(x,1)<0.0 then cars#(x,1)=cars#(x,1)*0.8
        lastx#=object position x(car+x)
        lastz#=object position z(car+x)
        yrotate object car+x,object angle y(car+x)+cars#(x,2)
        position object car+x,object position x(car+x)+cos(object angle y(car+x))*cars#(x,1),0,object position z(car+x)-sin(object angle y(car+x))*cars#(x,1)
        hit=object collision(car+x,0)
        if hit>0
          cars#(x,1)=-cars#(x,1)
          position object car+x,lastx#,0,lastz#
          this_offset=atan((object position z(hit)-object position z(car+x))/(object position x(hit)-object position x(car+x)))-object angle y(car+x)
          if this_offset=0 then this_offset=1
          cars#(x,2)=cars#(x,2)+sgn(this_offset)*0.2
          if abs(cars#(x,2))>turnmax# then cars#(x,2)=turnmax#*sgn(cars#(x,2))
        endif
        if object angle y(car+x)<0 then yrotate object car+x,object angle y(car+x)+360
        if object angle y(car+x)>360 then yrotate object car+x,object angle y(car+x)-360
      endif
      if object position x(car+x)>offset+100 then laps(x,1)=1
      if object position x(car+x)<-offset-100 then laps(x,2)=1
      if object position x(car+x)>60
        if laps(x,1)=1 and laps(x,2)=1
          inc laps(x,0):if laps(x,0)=laps_to_win then win=1
          laps(x,1)=0:laps(x,2)=0
        endif
      endif
      if win=1 then cars#(x,1)=0
    next x
    x=0
    if uturn=0 then cars#(0,2)=cars#(0,2)*0.5
    if cars#(0,1)<0.0 then cars#(0,1)=cars#(0,1)*0.9
    lastx#=object position x(car)
    lastz#=object position z(car)
    lasty#=object angle y(car)
    yrotate object car,object angle y(car)+cars#(0,2)
    position object car,lastx#+cos(lasty#)*cars#(0,1),0,lastz#-sin(object angle y(car))*cars#(0,1)
    if (object collision(car,0) >0)
      cars#(0,1)=-cars#(0,1)
      position object car,lastx#,0,lastz#
    endif
    if object position x(car)>offset+100 then laps(0,1)=1
    if object position x(car)<-offset-100 then laps(0,2)=1
  else
    if start=0
      for j=1 to 6
        ink rgb(128+j*10,128+j*10,128+j*10),0
        box 375+j,150+j,625-j,200-j
      next j
      inc scol
      if scol>250 then scol=192
      ink rgb(scol,scol,scol),0
      text 400,165,"Press SPACEBAR to start"
      if spacekey() then start=1
    else
      for j=1 to 6
        if light(j,1)<251 and light(j,2)<251 and light(j,3)<251
          light(j,1)=light(j,1)+4
          light(j,2)=light(j,2)+4
          light(j,3)=light(j,3)+4
          color object lights+j,rgb(light(j,1),light(j,2),light(j,3))
          j=6
        else
          if j=6 then start=2
        endif
      next j
    endif
  endif
  paste image 2,400,0
  ink 0,0
  for z=0 to 5
    set cursor 570-len(str$(laps(z,0)))*10,z*20+22
    print laps(z,0)
    sprite z+1,420+laps(z,0)*10+laps(z,1)*3+laps(z,2)*3,z*20+20,3
  next z
  paste image 4,435,600
  position camera 0,520,0
  point camera 0,0,0
  sync
endwhile
end

function sgn(x)
  v=0
  if x<0 then v=-1
  if x>0 then v=1
endfunction v
turn_right:
  cars#(x,2)=cars#(x,2)+0.1
  turn=1
  if cars#(x,2)>turnmax# then cars#(x,2)=turnmax#
return
turn_left:
  cars#(x,2)=cars#(x,2)-0.1
  turn=1
  if cars#(x,2) < -turnmax# then cars#(x,2)=-turnmax#
return
make_track:
  inc wall
  make object plain wall,100,20
  create bitmap 1,100,20
  ink rgb(255,255,255),0
  box 0,0,100,20
  ink 0,0
  for x=0 to 80 step 20
    box x,0,x+10,10
    box x+10,10,x+20,20
  next x
  get image 1,0,0,100,20
  delete bitmap 1
  set current bitmap 0
  texture object wall,1
  rotate object wall,90,45,0
  position object wall,50,-10,50

  width_out=35
  width_in=18
  for angle=-135 to 135 step 10
    inc wall
    xpos#=cos(angle)*200
    zpos#=sin(angle)*200
    make object box wall,width_out,10,1
    position object wall,xpos#+offset,0,zpos#
    yrotate object wall,90-angle
    inc wall
    xpos#=cos(angle+180)*200
    zpos#=sin(angle+180)*200
    make object box wall,width_out,10,1
    position object wall,xpos#-offset,0,zpos#
    yrotate object wall,90-angle
    inc wall
    xpos#=cos(angle)*100
    zpos#=sin(angle)*100
    make object box wall,width_in,10,1
    position object wall,xpos#+offset,0,zpos#
    yrotate object wall,90-angle
    inc wall
    xpos#=cos(angle+180)*100
    zpos#=sin(angle+180)*100
    make object box wall,width_in,10,1
    position object wall,xpos#-offset,0,zpos#
    yrotate object wall,90-angle
  next angle
  inc wall
  make object box wall,93,10,1
  position object wall,-100,0,-32
  yrotate object wall,-45
  inc wall
  make object box wall,93,10,1
  position object wall,-100,0,32
  yrotate object wall,45
  inc wall
  make object box wall,93,10,1
  position object wall,100,0,-32
  yrotate object wall,45
  inc wall
  make object box wall,93,10,1
  position object wall,100,0,32
  yrotate object wall,-45
  inc wall
  make object box wall,80,10,1
  position object wall,-28,0,-101
  yrotate object wall,-45
  inc wall
  make object box wall,80,10,1
  position object wall,28,0,-101
  yrotate object wall,45
  inc wall
  make object box wall,80,10,1
  position object wall,-28,0,101
  yrotate object wall,45
  inc wall
  make object box wall,80,10,1
  position object wall,28,0,101
  yrotate object wall,-45
  total_walls=wall
return

make_cars:
car=wall+1
make object box car,10,1,5
make object cylinder car+1,3
xrotate object car+1,90.0
make mesh from object 1,car+1
delete object car+1
add limb car,1,1
offset limb car,1,3,0,2
add limb car,2,1
offset limb car,2,-4,0,3
add limb car,3,1
offset limb car,3,3,0,-2
add limb car,4,1
offset limb car,4,-4,0,-3
clone object car+1,car
clone object car+2,car
clone object car+3,car
clone object car+4,car
clone object car+5,car
col(0)=rgb(0,0,255)
col(1)=rgb(0,255,255)
col(2)=rgb(0,255,0)
col(3)=rgb(255,255,0)
col(4)=rgb(255,0,255)
col(5)=rgb(255,0,0)
bcol(0)=rgb(0,0,192)
bcol(1)=rgb(0,192,192)
bcol(2)=rgb(0,192,0)
bcol(3)=rgb(192,192,0)
bcol(4)=rgb(192,0,192)
bcol(5)=rgb(192,0,0)
for x=0 to 5
  color object car+x,col(x)
  color limb car+x,1,0:color limb car+x,2,0:color limb car+x,3,0:color limb car+x,4,0
  position object car+x,startx+x*10,0,startz-x*10
  yrotate object car+x,315
next x
return

make_lights:
  lights=wall
  dim light(6,3)
  data 128,0,0,128,128,64,128,128,64,128,128,64,128,128,64,0,128,0
  for j=1 to 6
    read light(j,1):read light(j,2):read light(j,3)
    make object sphere wall+j,15
    position object wall+j,70,0,200+(6-j)*20
    color object wall+j,rgb(light(j,1),light(j,2),light(j,3))
  next j
  wall=wall+6
return

laps_board:
  create bitmap 2,190,150
  ink rgb(0,128,0),0:box 0,0,190,150
  ink 0,0:box 10,20,180,140
  ink rgb(255,255,255),0
  set text font "arial":set text to bold:set text size 20
  text 70,0,"LAPS"
  for x=0 to 5
    ink bcol(x),0:box 20,x*20+21,145,x*20+39
    ink col(x),0:box 150,x*20+21,170,x*20+39
  next x
  get image 2,0,0,190,150
  delete bitmap 2
  create bitmap 3,20,20
  ink 0,0:box 0,0,20,20
  ink rgb(5,5,5),0
  for r=1 to 3
    circle 5,15,r:circle 15,15,r
  next r
  line 3,15,3,5:line 3,5,15,10:line 15,10,18,15:line 18,15,3,15
  get image 3,0,0,20,20
  delete bitmap 3
  create bitmap 3,150,150
  ink rgb(32,32,128),0:box 0,0,150,150
  ink rgb(128,128,255),0
  set text font "arial":set text size 20:set text to bold
  text 40,20,"BLUE CAR"
  set text size 14:ink rgb(128,255,128),0
  text 10,5,"First car to "+str$(laps_to_win)+" laps wins"
  set text size 12:set text to normal
  ink rgb(255,255,255),0
  line 10,75,40,75:line 10,75,20,65:line 10,75,20,85
  text 10,85,"turn left"
  line 110,75,140,75:line 140,75,130,65:line 140,75,130,85
  text 110,85,"turn right"
  line 75,40,75,70:line 75,40,65,50:line 75,40,85,50
  text 85,50,"speed":text 85,60,"up"
  line 75,110,75,140:line 75,140,65,130:line 75,140,85,130
  text 45,110,"slow":text 45,120,"down"
  get image 4,0,0,150,150
  delete bitmap 3
  set current bitmap 0
  set text size 20:set text to bold
return

starttime=timer()

newtime=timer()-starttime
dt#=newtime-oldtime
oldtime=newtime

`The Usual Setup
sync on
sync rate 30
autocam off
hide mouse
randomize timer()
if check display mode(1024,768,32)=1
    set display mode 1024,768,32
endif
set text font "Gungsuh"
`Variables
sw=screen width()
sh=screen height()
type car_info
     acc as float
     wpt as integer
     lap as integer
     finish as boolean
endtype
dim car(8) as car_info
type way_point
     x as integer
     z as integer
endtype
dim way(20) as way_point
null=make vector2(1)
null=make vector2(2)
dim pt(8) as string
pt(1)="st"
pt(2)="nd"
pt(3)="rd"
for i=4 to 8
    pt(i)="th"
next i
place=8
dim comment(8) as string
comment(1)="Congradulations, you are God"
comment(2)="Ok, now you'll have to play again"
comment(3)="You still get a medal"
comment(4)="Do better"
comment(5)="Now your not even in the top 50%"
comment(6)="Shame"
comment(7)="You could have done worse"
comment(8)="Seek help"
`Stolen from Hobgoblin Lord
type note_thing
   note as integer
   speed as integer
   volume as integer
endtype
dim master_note(-1) as note_thing
make_midi("R",25,2,"a4 a4 a4 g5")
load music "r.mid",1
`Grass
make_image_memblock(1,32,32,32)
for x=1 to 32
    for y=1 to 32
        memblock_dot(1,x,y,rgb(rnd(128),rnd(128)+127,0))
    next y
next x
make image from memblock 10,1
`Road
for x=1 to 32
    for y=1 to 32
        c=rnd(20)+127
        memblock_dot(1,x,y,rgb(c,c,c))
    next y
next x
make image from memblock 11,1
`Wall
for x=1 to 32
    for y=1 to 32
        c=rnd(60)
        memblock_dot(1,x,y,rgb(c,c,c))
    next y
next x
make image from memblock 12,1
`Boost
for x=1 to 32
    for y=1 to 32
        memblock_dot(1,x,y,rgb(255,x*50 mod 256,0))
    next y
next x
make image from memblock 15,1
delete memblock 1
set text size 14
color backdrop rgb(29, 94, 99)
`Choose Track
track=1
repeat
if escapekey()=1
   end
endif
sync
set cursor 0,0
print "Select a track"
print ""
dim trackname(3) as string
trackname(1)="Winding Willow"
trackname(2)="Spring Track"
trackname(3)="Checker Field"
sprite 1,-10,-10,10
size sprite 1,10,10
for i=1 to 3
    if i=track
       ink rgb(123, 123, 238),0
       arrow$=" <--------"
    else
       ink -1,0
       arrow$=""
    endif
    print trackname(i)+arrow$
next i
select track
    case 1
        restore track1
    endcase
    case 2
        restore track2
    endcase
    case 3
        restore track3
    endcase
endselect
for x=1 to 30
    for z=1 to 30
        read road
        select road
            case 0
                set sprite image 1,10
            endcase
            case 1
                set sprite image 1,11
            endcase
            case 2
                set sprite image 1,12
            endcase
            case 3
                set sprite image 1,15
            endcase
        endselect
        paste sprite 1,x*10+200,400-z*10
    next z
next x
track=track-upkey()+downkey()
if track<1
   track=1
endif
if track>3
   track=3
endif
ink -1,0
until returnkey()=1
delete sprite 1
`Make Car
set camera range 10,10000
color backdrop rgb(0, 210, 255)
make object box 1,50,30,100
make object box 2,10,10,15
make mesh from object 1,2
delete object 2
add limb 1,1,1
offset limb 1,1,0,20,-40
delete mesh 1
make object box 2,60,6,20
make mesh from object 1,2
delete object 2
add limb 1,2,1
offset limb 1,2,0,23,-40
delete mesh 1
make object sphere 2,100,6,6
scale object 2,6,25,25
make mesh from object 1,2
delete object 2
add limb 1,3,1
offset limb 1,3,28,-10,30
add limb 1,4,1
offset limb 1,4,-28,-10,30
add limb 1,5,1
offset limb 1,5,28,-10,-30
add limb 1,6,1
offset limb 1,6,-28,-10,-30
delete mesh 1
scale object 1,50,50,50
`Car colors
make_image_memblock(1,1,1,32)
for image=1 to 8
    memblock_dot(1,1,1,rgb(rnd(255),rnd(255),rnd(255)))
    make image from memblock image,1
next image
`Black Tire
memblock_dot(1,1,1,rgb(0,0,0))
make image from memblock 9,1
delete memblock 1
`Speedometer
make_image_memblock(1,256,128,32)
for thickness=0 to 2
    memblock_circle(1,128,128+thickness,128,rgb(255,255,255))
next thickness
for ang=-90 to 90 step 10
    memblock_line(1,int((cos(ang)-sin(ang)*30+129)),int((sin(ang)-cos(ang)*30+129)),int((cos(ang)-sin(ang)*120+129)),int((sin(ang)-cos(ang)*120+129)),rgb(255,255,255))
next ang
make image from memblock 13,1
delete memblock 1
sprite 1,sw-256,sh-152,13
hide sprite 1
`Speedometer needle
make_image_memblock(1,10,120,32)
memblock_circle(1,5,115,5,rgb(255,0,0))
for thickness=-2 to 2
    memblock_line(1,5+thickness,110,5+thickness,1,rgb(255,0,0))
next thickness
make image from memblock 14,1
delete memblock 1
sprite 2,sw-130,sh-24,14
offset sprite 2,0,115
hide sprite 2
`Make enemies
for car=2 to 8
    clone object car,1
next car
for car=1 to 8
    texture object car,car   
    for i=3 to 6
        texture limb car,i,9
    next i
    position object car,cos(car*180)*40+3700,0,car*40+2100
next car
`Make track
obj=9
dim track(30,30)
select track
   case 1
      restore track1
   endcase
   case 2
      restore track2
   endcase
   case 3
      restore track3
   endcase
endselect   
for x=1 to 30
    for z=1 to 30
        read road
        track(x,z)=road
        if road<2
            make object plain obj,200,200,1
            xrotate object obj,90
            position object obj,x*200,-20,z*200
            texture object obj,10+road
        else
            if road=2
                make object box obj,200,50,200
                position object obj,x*200,5,z*200
                texture object obj,12
            else
                make object plain obj,200,200,1
                xrotate object obj,90
                position object obj,x*200,-20,z*200
                texture object obj,15
            endif
        endif
        inc obj
    next z
next x
`Set waypoints for ai and keeping track of place
select track
    case 1
        way(0).x=19
        way(0).z=13
        way(1).x=20
        way(1).z=16
        way(2).x=26
        way(2).z=18
        way(3).x=29
        way(3).z=22
        way(4).x=23
        way(4).z=27
        way(5).x=15
        way(5).z=26
        way(6).x=13
        way(6).z=17
        way(7).x=11
        way(7).z=16
        way(8).x=8
        way(8).z=19
        way(9).x=8
        way(9).z=25
        way(10).x=4
        way(10).z=24
        way(11).x=4
        way(11).z=15
        way(12).x=7
        way(12).z=11
        way(13).x=8
        way(13).z=4
        way(14).x=17
        way(14).z=4
        way(15).x=20
        way(15).z=3
        way(16).x=21
        way(16).z=7
        way(17).x=18
        way(17).z=10
        numways=17
    endcase
    case 2
        way(0).x=19
        way(0).z=15
        way(1).x=23
        way(1).z=16
        way(2).x=25
        way(2).z=6
        way(3).x=23
        way(3).z=3
        way(4).x=10
        way(4).z=3
        way(5).x=6
        way(5).z=10
        way(6).x=3
        way(6).z=13
        way(7).x=5
        way(7).z=18
        way(8).x=4
        way(8).z=23
        way(9).x=6
        way(9).z=26
        way(10).x=11
        way(10).z=25
        way(11).x=15
        way(11).z=28
        way(12).x=26
        way(12).z=27
        way(13).x=27
        way(13).z=22
        way(14).x=17
        way(14).z=21
        way(15).x=14
        way(15).z=10
        way(16).x=18
        way(16).z=9
        numways=16
    endcase
    case 3
        way(0).x=17
        way(0).z=15
        way(1).x=12
        way(1).z=15
        way(2).x=12
        way(2).z=6
        way(3).x=4
        way(3).z=5
        way(4).x=4
        way(4).z=10
        way(5).x=6
        way(5).z=12
        way(6).x=3
        way(6).z=16
        way(7).x=6
        way(7).z=26
        way(8).x=12
        way(8).z=23
        way(9).x=15
        way(9).z=24
        way(10).x=20
        way(10).z=23
        way(11).x=26
        way(11).z=22
        way(12).x=26
        way(12).z=13
        way(13).x=24
        way(13).z=5
        way(14).x=21
        way(14).z=5
        numways=14
    endcase
endselect
`Smooth glide to show off
set text size 100
position camera 0,5000,0
point camera 3000,0,3000
for i=1 to 400
    sync
    txt$="Get Ready!  "
    if i=310
        play music 1
    endif
    if i>=310
       txt$=txt$+str$((400-i)/30+1)
    endif
    ink rgb(0, 0, 160),0
    center text screen width()/2-5,screen height()/2-55,txt$
    ink -1,0
    center text screen width()/2,screen height()/2-50,txt$
    position camera curvevalue(object position x(1),camera position x(),80),curvevalue(1000,camera position y(),80),curvevalue(object position z(1),camera position z(),80)
    rotate camera curveangle(90,camera angle x(),80),curveangle(0,camera angle y(),80),curveangle(0,camera angle z(),80)
next i
`Final bit of setup
rotate camera 90,0,0
set text size 24
show sprite 1
show sprite 2
`Main Loop
repeat
if escapekey()=1
   end
endif
sync
`Display HUD
text 0,0,"Lap: "+str$(car(1).lap+1)
text 0,30,"Place: "+str$(place)+pt(place)
speed$=str$(int(abs(car(1).acc*3)))+" mph"
text sw-text width(speed$),sh-24,speed$
rotate sprite 2,abs(car(1).acc*3)-90
`Control player
oldx#=object position x(1)
oldz#=object position z(1)
`text 0,60,"X: "+str$(int(oldx#/200+0.5))+" Z: "+str$(int(oldz#/200+0.5))
road=track(int(oldx#/200+0.5),int(oldz#/200+0.5))
select road
    case 0
        friction#=.95
    endcase
    case 1
        friction#=.98
    endcase
    case 3
        friction#=1.2
    endcase
endselect
car(1).acc=car(1).acc*friction#+(((upkey()+keystate(17))>0)-((downkey()+keystate(31))>0)*.4)*.7
move object 1,car(1).acc
turn=((rightkey()+keystate(32))>0)-((leftkey()+keystate(30))>0)
yrotate object 1,object angle y(1)+turn*4
rotate limb 1,3,0,turn*10,0
rotate limb 1,4,0,turn*10,0
rotate limb 1,5,0,-turn*10,0
rotate limb 1,6,0,-turn*10,0
newx#=object position x(1)
newz#=object position z(1)
colwith=object collision(1,0)
if colwith>0
   position object 1,oldx#+(newx#-object position x(colwith))*.01,0,oldz#+(newz#-object position z(colwith))*.01
   car(1).acc=car(1).acc*.1
endif
wx=way(car(1).wpt).x*200
wz=way(car(1).wpt).z*200
set vector2 1,object position x(1),object position z(1)
set vector2 2,wx,wz
subtract vector2 2,1,2
dist#=length vector2(2)
if dist#<1000
   car(1).wpt=car(1).wpt+1
   if car(1).wpt>numways
      car(1).wpt=0
      car(1).lap=car(1).lap+1
   endif
endif
position camera object position x(1),1000,object position z(1)
tx=int(object position x(1)/200+0.5)
tz=int(object position z(1)/200+0.5)
if car(1).lap=5 and tx>16 and tx<22 and tz=13
    car(1).finish=1
endif
`Control ai
for ai=2 to 8
    ca#=object angle y(ai)
    wx=way(car(ai).wpt).x*200
    wz=way(car(ai).wpt).z*200
    point object ai,wx,0,wz
    na#=object angle y(ai)
    rotate object ai,0,curveangle(na#,ca#,10),0
    road=track(int(object position x(ai)/200+0.5),int(object position z(ai)/200+0.5))
    select road
        case 0
            friction#=.95
        endcase
        case 1
            friction#=.98
        endcase
        case 3
            friction#=1.2
        endcase
    endselect
    car(ai).acc=car(ai).acc*friction#+rnd(100)/100.0+.1
    oldx#=object position x(ai)
    oldz#=object position z(ai)
    move object ai,car(ai).acc
    newx#=object position x(ai)
    newz#=object position z(ai)   
    colwith=object collision(ai,0)
    if colwith>0
       position object ai,oldx#+(newx#-object position x(colwith))*.01,0,oldz#+(newz#-object position z(colwith))*.01
       car(ai).acc=car(ai).acc*.1
    endif
    set vector2 1,object position x(ai),object position z(ai)
    set vector2 2,wx,wz
    subtract vector2 2,1,2
    dist#=length vector2(2)
    if dist#<150
       car(ai).wpt=car(ai).wpt+1
       if car(ai).wpt>numways
          car(ai).wpt=0
          car(ai).lap=car(ai).lap+1
       endif
    endif
    tx=int(object position x(ai)/200+0.5)
    tz=int(object position z(ai)/200+0.5)
    if car(ai).lap=5 and tx>16 and tx<22 and tz=13
        car(ai).finish=1
    endif
next ai
place=1
for i=2 to 8
    if car(i).lap>car(1).lap or car(i).lap=car(1).lap and car(i).wpt=>car(1).wpt
       inc place
    endif
next i
until car(1).finish=1
`Display final info
delete objects 1,obj-1
delete sprite 1
delete sprite 2
color backdrop 0
set text size 50
cls
place=1
for i=2 to 8
    if car(i).finish=1
        inc place
    endif
next i
center text screen width()/2,screen height()/2-25,"You ranked "+str$(place)+pt(place)
set text size 30
center text screen width()/2,screen height()/2+15,comment(place) 
sync
wait key
end
track1:
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
data 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,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,3,1,1,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,2
data 2,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,2,2,2,2,2,2,2,0,1,1,0,0,0,2
data 2,0,0,1,1,1,1,1,1,1,1,1,0,0,0,2,2,0,0,0,0,0,0,0,1,1,0,0,0,2
data 2,0,1,1,1,0,0,0,0,0,0,0,0,2,2,2,0,1,1,1,1,1,1,1,1,1,0,0,0,2
data 2,0,1,1,1,0,0,0,0,2,2,2,2,2,2,0,1,1,0,0,1,1,1,1,1,0,0,0,0,2
data 2,0,1,1,0,0,0,0,2,2,2,0,0,0,2,1,1,0,0,0,0,0,0,0,0,0,0,0,0,2
data 2,0,1,3,0,0,0,2,2,2,0,0,0,0,2,1,1,0,0,2,2,2,2,2,2,2,2,2,2,2
data 2,0,1,1,0,0,2,2,0,0,0,0,0,0,2,1,1,0,0,0,0,0,0,0,0,0,0,0,2,2
data 2,0,1,1,0,0,2,2,0,0,0,0,0,0,2,0,1,1,1,1,1,0,0,0,0,0,0,0,0,2
data 2,0,0,1,1,0,2,0,0,0,0,0,0,0,2,0,0,1,1,1,1,1,1,1,1,0,0,0,0,2
data 2,0,0,1,1,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,0,1,1,1,1,1,0,0,0,2
data 2,0,0,1,1,0,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,1,1,0,0,0,2
data 2,0,1,1,0,0,2,2,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,0,0,1,1,0,0,2
data 2,1,1,0,0,0,2,0,0,1,1,1,1,0,0,0,0,2,0,0,0,0,2,0,0,1,1,0,0,2
data 2,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,2,0,0,0,0,2,0,0,1,1,0,0,2
data 2,1,1,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,2,0,0,0,2,0,0,1,1,0,0,2
data 2,0,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,2,0,0,0,2,0,1,1,1,0,0,2
data 2,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,2,0,0,2,0,1,1,3,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,2,0,2,0,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,2,2,0,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,2
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
track2:
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
data 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,2
data 2,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,0,0,0,1,1,1,0,0,0,2
data 2,0,0,0,0,0,0,1,1,1,1,0,0,2,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,2
data 2,0,0,0,1,1,1,1,1,1,0,2,2,2,2,2,2,2,2,2,2,0,0,1,1,1,0,0,0,2
data 2,0,0,1,1,1,1,1,0,0,0,2,2,0,0,0,0,0,0,0,2,0,1,1,1,0,0,0,0,2
data 2,0,1,1,1,0,0,0,0,2,2,2,0,0,0,0,0,0,0,0,2,0,1,1,1,0,0,0,0,2
data 2,0,1,1,0,0,2,2,2,2,0,0,0,0,0,0,0,0,0,0,2,2,0,1,1,0,0,0,0,2
data 2,0,1,1,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,1,1,0,0,0,2
data 2,1,1,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,1,1,0,0,2
data 2,1,1,0,0,2,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,2,2,0,0,1,1,0,0,2
data 2,1,1,0,0,2,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,2,2,0,0,1,1,0,2
data 2,1,1,0,0,2,0,0,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,2,0,0,1,3,0,2
data 2,1,1,0,0,2,0,1,1,0,2,2,2,2,0,0,0,0,1,1,1,0,0,2,0,0,1,1,0,2
data 2,1,1,0,0,2,0,1,1,0,0,0,0,0,2,2,0,0,0,1,1,1,0,2,0,0,1,1,0,2
data 2,1,1,1,0,2,0,1,1,1,1,1,1,1,1,0,2,0,0,0,1,1,0,2,0,0,1,1,0,2
data 2,3,1,1,0,2,0,0,1,1,1,1,1,1,1,1,0,2,0,0,1,1,0,2,2,0,1,1,0,2
data 2,1,1,1,0,2,0,0,0,0,0,0,0,0,1,1,1,0,2,0,1,1,0,2,2,0,1,1,0,2
data 2,1,1,1,0,2,2,2,2,2,2,2,2,0,0,1,1,0,2,0,1,1,0,2,2,0,1,1,0,2
data 2,1,1,1,0,2,0,0,0,0,0,0,2,0,0,1,1,0,2,0,1,1,0,2,2,0,1,1,0,2
data 2,0,1,1,0,2,0,0,0,0,0,1,1,1,1,1,1,0,2,0,1,1,0,2,2,0,1,1,0,2
data 2,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,2,0,1,1,0,2,2,0,1,1,0,2
data 2,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,2,0,1,1,0,0,0,0,1,1,0,2
data 2,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,2,2,0,1,1,1,0,0,1,1,1,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,1,1,1,1,1,1,1,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,1,1,1,1,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
track3:
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
data 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,2
data 2,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,2
data 2,0,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,2
data 2,0,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,2
data 2,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,2,0,0,0,0,1,1,1,1,0,0,2
data 2,0,1,1,1,0,0,2,0,0,0,0,0,0,0,2,0,2,0,2,0,2,0,0,1,1,1,0,0,2
data 2,0,1,1,1,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,0,0,1,1,1,0,0,2
data 2,0,0,1,1,0,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,0,0,0,1,1,0,0,0,2
data 2,0,0,1,1,1,0,0,0,0,0,0,2,0,2,0,0,0,2,0,2,0,0,1,1,0,0,0,0,2
data 2,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,0,2,0,2,0,0,1,1,0,0,0,0,0,2
data 2,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,2,0,2,0,1,1,0,0,0,0,0,2
data 2,0,0,0,0,0,0,1,1,0,0,1,1,1,1,1,0,2,0,2,0,0,1,1,0,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,2,0,2,0,1,1,0,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,2,0,2,0,0,0,3,0,0,0,0,0,2
data 2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,1,0,0,2,0,2,0,0,1,0,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,2,0,2,0,0,0,1,0,0,0,0,0,2
data 2,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,0,1,0,0,0,0,0,2
data 2,0,0,0,0,1,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,0,1,1,0,0,0,0,0,2
data 2,0,0,0,1,1,1,1,0,0,2,0,2,0,2,0,2,0,2,0,0,0,1,1,0,0,0,0,0,2
data 2,0,0,1,1,1,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,0,1,0,0,0,0,0,0,2
data 2,0,0,1,1,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0,1,0,0,0,0,0,0,2
data 2,0,0,1,1,0,0,2,0,2,0,2,0,2,0,2,0,0,0,2,0,1,1,1,0,0,0,0,0,2
data 2,0,0,1,1,1,1,1,1,1,1,0,2,0,2,0,0,0,2,0,0,1,1,1,0,0,0,0,0,2
data 2,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,2
data 2,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,2
data 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,1,1,0,0,0,0,0,0,0,2
data 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,2
data 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,2
data 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
`function stolen from Hobgoblin Lord (http://forum.thegamecreators.com/?m=forum_view&t=96232&b=6)
function make_midi(file as string,instrument as integer,tempo as integer,notes as string)
SPEED=135
notes=" "+notes
for a = 1 to len(notes)
   watch$=mid$(notes,a)
   if watch$=" "
      start=a:test_note$=""
      repeat
         inc start
         new$=mid$(notes,start)
         if new$<>" "
            test_note$=test_note$+new$
         endif
      until new$=" " or start=len(notes)
    note_on=1
    if len(test_note$)=1
      select lower$(test_note$)
         case "q":SPEED=135:endcase
         case "8":speed=134:endcase
         case "h":speed=140:endcase
         case "r":array insert at bottom master_note():count=array count(master_note())
            master_note(count).note=0:master_note(count).speed=SPEED:master_note(count).volume=0
         endcase
      endselect
      note_on=0
    else
      temp_note$=left$(test_note$,1):temp_octave=val(right$(test_note$,1))
      select lower$(temp_note$)
         case "c":note_base=0:endcase
         case "d":note_base=2:endcase
         case "e":note_base=4:endcase
         case "f":note_base=5:endcase
         case "g":note_base=7:endcase
         case "a":note_base=9:endcase
         case "b":note_base=11:endcase
      endselect
      inc note_base,Temp_octave*12
      if len(test_note$)=3 then inc note_base
    endif
      if note_on=1
        array insert at bottom master_note()
        count=array count(master_note())
        master_note(count).note=note_base
        master_note(count).speed=SPEED
        master_note(count).volume=127
      endif
    endif
   next a
   `figure bytes in the track
   track_total=20+((array count(master_note())+1)*9)
   if file exist("making_bytes.txt")=1 then delete file "making_bytes.txt"
   open to write 1,"making_bytes.txt"
   write long 1,track_total
   close file 1
   open to read 1,"making_bytes.txt"
      read byte 1,track_bytesD
      read byte 1,track_bytesc
      read byte 1,track_bytesB
      read byte 1,track_bytesA
   close file 1
   `create the actual midi file
   file=file+".mid"
   if file exist(file)=1 then delete file file
      open to write 1,file
      `write the header
      write byte 1,77:write byte 1,84:write byte 1,104:write byte 1,100:write byte 1,0:write byte 1,0:write byte 1,0:write byte 1,6
      write byte 1,0:write byte 1,0:write byte 1,0:write byte 1,1
      `write track header
      write byte 1,TEMPO:write byte 1,192 `affects duration
      write byte 1,77:write byte 1,84:write byte 1,114:write byte 1,107
      `number of bytes in the track
      write byte 1,track_bytesa:write byte 1,track_bytesb:write byte 1,track_bytesc:write byte 1,track_bytesd
      `instrument and delta set up
      write byte 1,0:write byte 1,192:write byte 1,INSTRUMENT `instrument
      write byte 1,0:write byte 1,255:write byte 1,89:write byte 1,2:write byte 1,0:write byte 1,0:write byte 1,0:write byte 1,255:write byte 1,81:write byte 1,3:write byte 1,9:write byte 1,39:write byte 1,192:write byte 1,0
      `write the notes
      `turn the note on
      for count = 0 to array count(master_note())
         write byte 1,144:write byte 1,master_note(count).note:write byte 1,master_note(count).volume:write byte 1,master_note(count).speed:write byte 1,64
         `turn it off
         write byte 1,128:write byte 1,master_note(count).note:write byte 1,0:write byte 1,0
      next count
      `write track end
      write byte 1,255,:write byte 1,47,:write byte 1,0,:write byte 1,1
      close file 1
endfunction
function make_image_memblock(memblock,width,height,depth)
make memblock memblock,width*height*depth*4+12
write memblock dword memblock,0,width
write memblock dword memblock,4,height
write memblock dword memblock,8,depth
endfunction
function memblock_dot(memblock,xcoord,ycoord,colour as dword)
width=memblock dword(memblock,0)
write memblock dword memblock,((ycoord-1)*width+xcoord-1)*4+12,colour
endfunction
function memblock_line(memblock,x1,y1,x2,y2,colour as dword)
width=memblock dword(memblock,0)
if abs(x2-x1)>abs(y2-y1)
    m#=(y2-y1+0.0)/(x2-x1+0.0)
    b#=y1-m#*x1
    minx=min(x1,x2)
    maxx=max(x1,x2)
    for ix=minx to maxx
        iy=int(m#*ix+b#+0.5)
        write memblock dword memblock,((iy-1)*width+ix-1)*4+12,colour
    next ix
else
    miny=min(y1,y2)
    maxy=max(y1,y2)
    if x2=x1
       for iy=miny to maxy
           write memblock dword memblock,((iy-1)*width+x1-1)*4+12,colour
       next iy
    else
        m#=(x2-x1+0.0)/(y2-y1+0.0)
        b#=y1-1/m#*x1
        for iy=miny to maxy
            ix=int(m#*(iy-b#)+0.5)
            write memblock dword memblock,((iy-1)*width+ix-1)*4+12,colour
        next ix
    endif
endif
endfunction
function memblock_circle(memblock,centerx,centery,radius,colour as dword)
bx=centerx-radius
py1=centery+sqrt(radius^2-(bx-centerx)^2)
py2=centery-sqrt(radius^2-(bx-centerx)^2)
ex=centerx+radius
width=memblock dword(memblock,0)
size=get memblock size(1)
for x=bx to ex
    y1=centery+sqrt(radius^2-(x-centerx)^2)
    y2=centery-sqrt(radius^2-(x-centerx)^2)
    miny=min(py1,y1)
    maxy=max(py1,y1)
    for y=miny to maxy
        pos=((y-1)*width+x-1)*4+12
        if pos>11 and pos<size
           write memblock dword memblock,pos,colour
        endif
    next y
    miny=min(py2,y2)
    maxy=max(py2,y2)
    for y=miny to maxy
        pos=((y-1)*width+x-1)*4+12
        if pos>11 and pos<size
           write memblock dword memblock,pos,colour
        endif
    next y
    py1=y1
    py2=y2
next x
endfunction
function min(value1#,value2#)
if value1#<value2#
   a#=value1#
else
   a#=value2#
endif
endfunction a#
function max(value1#,value2#)
if value1#>value2#
   a#=value1#
else
   a#=value2#
endif
endfunction a#

Rem Project: top down racer
Rem Created: 14/03/2007 11:04:37

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

set display mode 1024,768,32
sync on
sync rate 60
hide light 0
color backdrop 0

make light 1
position light 1,0,50,100
set light range 1,500


`constants
matrixsizex=100
matrixsizez=100
xsegments=10
zsegments=10
tileimagesize=64
numberofcars=6

camx#=matrixsizex/2.0
camy#=80
camz#=matrixsizez/2.0

type tiletype

imagenumber as integer
tilenumber as integer
height as float
posx as float
posy as float
waypoint as integer

endtype

type cartype

objectnumber as integer
x as float
y as float
z as float
fi as float
fl as float
fd as float
fb as float
maxfd as float
maxfb as float
fx as float
fz as float
ax as float
az as float
vx as float
vz as float
ang as float
turnspeed as float
slow as integer
waypoint as integer
waypointset as integer
targetangle as float
lap as integer

endtype

type waypointtype

x as float
z as float

endtype

gosub make_track
gosub make_cars


position camera camx#,camy#,camz#
point camera camx#,0,camz#


ink -1,0
sync
sync
text 0,0,"Get ready ...."
sync
wait 2000
do

for n=1 to numberofcars
text 0,20*n,"Car"+str$(n)+" lap: "+str$(car(n).lap+1)+" of 3"
next n
`text 0,200,"Waypoints reached: "+str$(waypointsreached)
text 0,200,"Position: "+str$(position)
gosub move_player
gosub ai
gosub move_cars
gosub collision

sync
loop




collision:

for n=1 to numberofcars

for target=1 to numberofcars
  if n<>target
    if object collision(car(n).objectnumber,car(target).objectnumber)=1
      collision=1
      exit 
    else 
      collision=0
    endif
  endif
next target

tilex=int(car(n).x/(matrixsizex/xsegments))
tilez=int(car(n).z/(matrixsizez/zsegments))
if tilex>xsegments-1 then tilex=xsegments-1
if tilez>zsegments-1 then tilez=zsegments-1
if tile(tilex,tilez).imagenumber=5 then ongrass=1 else ongrass=0

if collision=1 or ongrass=1
   car(n).slow=1 
   set object emissive car(n).objectnumber,rgb(255,128,0)
else 
  car(n).slow=0
  set object emissive car(n).objectnumber,rgb(80,80,80)
endif


next n

return

ai:

for n=1 to numberofcars
  if n<>player
    car(n).fd=car(n).maxfd
    if car(n).slow=1 then car(n).fb=car(n).maxfb else car(n).fb=0
    if car(n).waypointset=0
      inc car(n).waypoint
      if car(n).waypoint>20 then car(n).waypoint=1: inc car(n).lap:if car(n).lap>2 then winner=n:goto gameover
      car(n).waypointset=1
      oldang#=car(n).ang 
    endif
    point object car(n).objectnumber,waypoint(car(n).waypoint).x,0,waypoint(car(n).waypoint).z
    car(n).targetangle=object angle y(car(n).objectnumber)
    rotate object car(n).objectnumber,0,oldang#,0
    rotate object car(n).objectnumber,0,curveangle(car(n).targetangle,car(n).ang,10),0
    car(n).ang=object angle y(car(n).objectnumber)
    tilex=int(car(n).x/(matrixsizex/xsegments))
    tilez=int(car(n).z/(matrixsizez/zsegments))
    if tile(tilex,tilez).waypoint=car(n).waypoint then car(n).waypointset=0
  endif
next n

return


move_player:

player=1

if upkey()=1 then car(player).fd=car(player).maxfd else car(player).fd=0
if downkey()=1 or car(player).slow=1 then car(player).fb=car(player).maxfb else car(player).fb=0

if leftkey()=1 then dec car(player).ang,car(player).turnspeed
if rightkey()=1 then inc car(player).ang,car(player).turnspeed

tilex=int(car(1).x/(matrixsizex/xsegments))
tilez=int(car(1).z/(matrixsizez/zsegments))

if tile(tilex,tilez).waypoint>0 and tile(tilex,tilez).waypoint<>car(1).waypoint then inc waypointsreached
if tile(tilex,tilez).waypoint<>0 then car(1).waypoint=tile(tilex,tilez).waypoint



if waypointsreached>17 and car(1).waypoint=1
  inc car(1).lap
  if car(1).lap>2 then winner=1:goto gameover
  waypointsreached=0
endif

position=1
for n=2 to numberofcars
if car(n).waypoint-1>car(1).waypoint and car(n).lap>= car(1).lap then inc position
next n



return

move_cars:

for n=1 to numberofcars



`calculate resultant velocity size and direction of travel from previous loop
vresultant#=sqrt(car(n).vx^2+car(n).vz^2)
directionoftravel#=atanfull(car(n).vx,car(n).vz)

`calculate angle between car and direction of travel
angle#=differencebetweentwoangles(car(n).ang,directionoftravel#)

`calculate inline friction size
inlinefriction#=(car(n).fi+car(n).fb)*vresultant#*cos(angle#)
if inlinefriction#<0 then inlinefriction#=0
`calculate x and z components of inline friction
inlinefrictionx#=inlinefriction#*sin(directionoftravel#)
inlinefrictionz#=inlinefriction#*cos(directionoftravel#)

`calculate lateral friction size
lateralfriction#=car(n).fl*vresultant#*sin(angle#)

`calculate x and z components of lateral friction
lateralfrictionx#=lateralfriction#*sin(directionoftravel#)
lateralfrictionz#=lateralfriction#*cos(directionoftravel#)

`calculate total friction
totalfrictionx#=(inlinefrictionx#+lateralfrictionx#)
totalfrictionz#=(inlinefrictionz#+lateralfrictionz#)

`calculate x and z force components due to drive
car(n).fx=car(n).fd*sin(car(n).ang)
car(n).fz=car(n).fd*cos(car(n).ang)

`calculate new x and z velocity components due to driving and frictional forces
inc car(n).vx,car(n).fx-totalfrictionx#
inc car(n).vz,car(n).fz-totalfrictionz#

`update positions
inc car(n).x,car(n).vx
inc car(n).z,car(n).vz
car(n).y=get ground height(1,car(n).x,car(n).z)

rotate object car(n).objectnumber,0,car(n).ang,0
position object car(n).objectnumber,car(n).x,car(n).y,car(n).z

next n


return


make_cars:

dim car(numberofcars) as cartype

for n=1 to numberofcars
  car(n).objectnumber=free_object()
  make object box car(n).objectnumber,1,0.2,2
  
  if n=1 then color object car(n).objectnumber,rgb(255,0,0)
  if n=2 then color object car(n).objectnumber,rgb(255,255,0)
  if n=3 then color object car(n).objectnumber,rgb(255,0,255)
  if n=4 then color object car(n).objectnumber,rgb(0,255,0)
  if n=5 then color object car(n).objectnumber,rgb(0,255,255)
  if n=6 then color object car(n).objectnumber,rgb(0,0,255)
  
  disable object zdepth car(n).objectnumber
  
  wheel1=free_object()
  make object box wheel1,0.4,0.2,0.4
  position object wheel1,-0.5,0,0.7
  disable object zdepth wheel1
  color object wheel1,rgb(0,0,0)
  glue object to limb wheel1,car(n).objectnumber,0
  wheel2=free_object()
  make object box wheel2,0.4,0.2,0.4
  position object wheel2,0.5,0,0.7
  disable object zdepth wheel2
  color object wheel2,rgb(0,0,0)
  glue object to limb wheel2,car(n).objectnumber,0
  wheel3=free_object()
  make object box wheel3,0.6,0.2,0.5
  position object wheel3,-0.5,0,-0.7
  disable object zdepth wheel3
  color object wheel3,rgb(0,0,0)
  glue object to limb wheel3,car(n).objectnumber,0
  wheel4=free_object()
  make object box wheel4,0.6,0.2,0.5
  position object wheel4,0.5,0,-0.7
  disable object zdepth wheel4
  color object wheel4,rgb(0,0,0)
  glue object to limb wheel4,car(n).objectnumber,0
  body=free_object()
  make object box body,0.4,0.3,2.4
  glue object to limb body,car(n).objectnumber,0
  disable object zdepth body
  tail=free_object()
  make object box tail,1.2,0.3,0.4
  position object tail,0,0,-1.3
  glue object to limb tail,car(n).objectnumber,0
  disable object zdepth tail
   
  
  
 if xoffset=0 then xoffset=4 else xoffset=0
  car(n).x=13+xoffset
  car(n).y=0.5
  car(n).z=25-n*2
  car(n).fi=0.01 `force due to inline friction
  car(n).fl=0.04 `force due to lateral friction
  car(n).maxfd=0.01+n*0.003 `force due to drive
  car(n).maxfb=0.04 `force due to braking friction
  car(n).turnspeed=2
  position object car(n).objectnumber,car(n).x,car(n).y,car(n).z
next n

return

make_track:


make matrix 1,matrixsizex,matrixsizez,xsegments,zsegments

`grid
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for y=0 to tileimagesize step 8
for x=0 to tileimagesize step 8
if white=0 then white=1 else white=0
if white=1
box x,y,x+8,y+8
endif
next x
next y

for n=0 to 4
line 0,n,tileimagesize,n
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n

grid=2
get image grid,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road vertical
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box tileimagesize-6,n*tileimagesize/10.0,tileimagesize-2,(n+1)*tileimagesize/10.0
next n

road1=8
get image road1,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1



`road horizontal
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1

ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
box n*tileimagesize/10.0,tileimagesize-6,(n+1)*tileimagesize/10.0,tileimagesize-2
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
box n*tileimagesize/10.0,tileimagesize-6,(n+1)*tileimagesize/10.0,tileimagesize-2
next n


road2=6
get image road2,0,0,tileimagesize,tileimagesize,1

set current bitmap 0
delete bitmap 1

`road bend 7
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1

ink rgb(120,120,120),0
box 0,0,tileimagesize,tileimagesize
ink rgb(100,100,100),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(140,140,140),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n

ink -1,0
for n=0 to 9 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
next n
ink rgb(255,0,0),0
for n=1 to 10 step 2
box 2,n*tileimagesize/10.0,6,(n+1)*tileimagesize/10.0
box n*tileimagesize/10.0,2,(n+1)*tileimagesize/10.0,6
next n

box tileimagesize-6,tileimagesize-6,tileimagesize-2,tileimagesize-2


road7=7
get image road7,0,0,tileimagesize,tileimagesize,1

set current bitmap 0
delete bitmap 1

`road bend 9
inc numberofimages
temp=free_sprite()
sprite temp,-100,-100,road7
mirror sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road9=9
get image road9,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road bend 3
inc numberofimages
flip sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road3=3
get image road3,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`road bend 1
inc numberofimages
mirror sprite temp
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
paste sprite temp,0,0

road1=1
get image road1,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1
         






`grass
inc numberofimages
create bitmap 1,tileimagesize,tileimagesize
set current bitmap 1
ink rgb(0,200,0),0
box 0,0,tileimagesize,tileimagesize
ink rgb(0,220,0),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
ink rgb(0,210,0),0
for n=1 to 600
dot rnd(tileimagesize),rnd(tileimagesize)
next n
blur bitmap 1,1
grass=5
get image grass,0,0,tileimagesize,tileimagesize,1
set current bitmap 0
delete bitmap 1

`create matrix texture
ink 0,0
dim tile(xsegments,zsegments) as tiletype
create bitmap 1,xsegments*tileimagesize,zsegments*tileimagesize
restore datastatements

create bitmap 1,9*tileimagesize,tileimagesize
for imagenumber=1 to 9
  if image exist(imagenumber)=1
    paste image imagenumber,(imagenumber-1)*tileimagesize,0
  endif
next imagenumber
matrixtexture=free_image()
get image matrixtexture,0,0,9*tileimagesize,tileimagesize
delete bitmap 1

prepare matrix texture 1,matrixtexture,9,1
set matrix trim 1,0.003,0.003

`read texture map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).imagenumber
  next x
next z

`read height map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).height
  next x
next z

dim waypoint(40) as waypointtype
`read waypoint map
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    read tile(x,z).waypoint
    if tile(x,z).waypoint>0
      if tile(x,z).imagenumber=8 or tile(x,z).imagenumber=6 or tile(x,z).imagenumber=2 then offsetx#=0.5:offsetz#=0.5
      if tile(x,z).imagenumber=7 then offsetx#=0.8:offsetz#=0.2
      if tile(x,z).imagenumber=9 then offsetx#=0.2:offsetz#=0.2
      if tile(x,z).imagenumber=3 then offsetx#=0.2:offsetz#=0.8
      if tile(x,z).imagenumber=1 then offsetx#=0.8:offsetz#=0.8
      waypoint(tile(x,z).waypoint).x=(x+offsetx#)*matrixsizex/xsegments
      waypoint(tile(x,z).waypoint).z=(z+offsetz#)*matrixsizez/zsegments
    endif
  next x
next z

tile=0
for z=zsegments-1 to 0 step -1
  for x=0 to xsegments-1
    inc tile
    tile(x,z).tilenumber=tile
    set matrix tile 1,x,z,tile(x,z).imagenumber
    set matrix height 1,x,z,tile(x,z).height
  next x
next z

matnum=1

For Z = 1 To zsegments - 1
    For X = 1 To xsegments - 1

      rem Get matrix heights
      h8# = Get Matrix Height(MatNum,x,z-1)
      h4# = Get Matrix Height(MatNum,x-1,z)
      h#  = Get Matrix Height(MatNum,x,z)
      h2# = Get Matrix Height(MatNum,x,z)

      rem Calculate projected angle X using heights
      x1#=(x-1)*25.0 : y1#=h#
      x2#=(x+0)*25.0 : y2#=h4#
      dx#=x2#-x1#
      dy#=y2#-y1#
      ax# = AtanFull(dx#,dy#)
      ax# = WrapValue(90-ax#)

      rem Calculate projected angle Z using heights
      z1# = (z-1)*25.0 : y1#=h2#
      z2# = (z+0)*25.0 : y2#=h8#
      dz# = z2#-z1#
      dy# = y2#-y1#
      az# = AtanFull(dz#,dy#)
      az# = WrapValue(90-az#)

      rem Make normal from projected angle
      nx# = Sin(ax#)
      ny# = Cos(ax#)
      nz# = Sin(az#)

      rem Setting matrix normal for smoothness
      Set Matrix Normal MatNum,x,z,nx#,ny#,nz#

    Next X
  Next Z

`normal(1,xsegments,zsegments)


update matrix 1

return


function differencebetweentwoangles(angle2#,angle1#)


angle2#=wrapvalue(angle2#)
angle1#=wrapvalue(angle1#)
if angle1#>180 then dec angle1#,360
if angle2#>180 then dec angle2#,360
difference#=abs(angle2#-angle1#)
if difference#>180 then difference#=abs(difference#-360)

endfunction difference#



function normal(MatNum,MapSizeX,MapSizeZ)

for x=1 to MapSizeX-1
   for z=1 to MapSizeZ-1
      rem create regular normals for Terrain array

      rem  Vertices on the matrix
      rem    x-1,z-1    x,z-1
      rem    x-1,z      x,z

      rem Get stored heights
      h8#=tile(x,z-1).height
      h4#=tile(x-1,z).height
      h1#=tile(x,z).height

      rem Calculate projected angle X using heights
      y1#=h1#
      y2#=h4#
      rem X distance is a function of stepX#
      dx#=stepX#/10
      rem Y distance is the difference in height
      dy#=y2#-y1#
      ax#=atanfull(dx#,dy#)
      ax#=wrapvalue(90-ax#)

      rem Calculate projected angle Z using heights
      y1#=h1#
      y2#=h8#
      rem Z distance is a function of stepZ#
      dz#=stepZ#/10
      rem Y distance is the difference in height
      dy#=y2#-y1#
      az#=atanfull(dz#,dy#)
      az#=wrapvalue(90-az#)

      rem Make normal from projected angle
      nx# = Sin(ax#)
      ny# = Cos(ax#)
      nz# = Sin(az#)

      rem Setting matrix normal for smoothness
      Set Matrix Normal MatNum,x,z,nx#,ny#,nz#

   Next x
Next z
EndFunction




function free_image()

repeat
  inc n
until image exist(n)=0

endfunction n

function free_sprite()

repeat
  inc n
until sprite exist(n)=0

endfunction n


function free_object()

repeat
  inc n
until object exist(n)=0

endfunction n

datastatements:

`texturemap
data 5,5,5,5,5,5,5,5,5,5
data 5,7,6,6,6,6,6,9,5,5
data 5,8,5,5,5,5,5,1,9,5
data 5,1,6,6,6,9,5,5,8,5
data 5,5,5,5,5,1,9,5,8,5
data 5,7,6,9,5,5,8,5,8,5
data 5,8,5,1,6,6,3,5,8,5
data 5,2,5,5,5,5,5,5,8,5
data 5,1,6,6,6,6,6,6,3,5
data 5,5,5,5,5,5,5,5,5,5

`heightmap
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,4,4,4,4,4
data 0,0,0,0,0,0,4,9,9,9
data 0,0,0,0,0,0,4,9,9,9
data 0,0,0,3,3,3,0,9,9,9
data 0,0,0,3,3,3,0,4,4,4
data 0,0,0,5,5,5,0,0,0,0
data 0,0,0,5,5,5,0,0,0,0
data 0,0,0,5,5,5,0,0,0,0

`waypoints
data 00,00,00,00,00,00,00,00,00,00
data 00,11,00,00,12,00,00,13,00,00
data 00,00,00,00,00,00,00,00,14,00
data 00,10,09,00,00,08,00,00,00,00
data 00,00,00,00,00,00,07,00,00,00
data 00,02,00,03,00,00,00,00,15,00
data 00,01,00,00,04,05,06,00,00,00
data 00,00,00,00,00,00,00,00,16,00
data 00,20,19,00,00,18,00,00,17,00
data 00,00,00,00,00,00,00,00,00,00

gameover:

text 0,250,"Car "+str$(winner)+" wins!"
text 0,270,"You finished in position "+str$(position)
if winner=1 then text 0,290,"Congratulations!!!" else text 0,290,"Unlucky!!!"
sync
wait 2000
wait key
end

Acelpage. The lapmeter thing was cute, and the AI control and car avoidance was implemented rather well to.

Daemon. Even though I didn't get to see the AI in action, the multiple tracks, textures, sound, speedometer, boost and general feel of the car were great. Well done.

Rem Project: Pong
Rem Created: 10/3/2006 6:32:35 PM

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

sync on
sync rate 0
randomize timer()
speed# = 1.5
ball_x# = 320
ball_y# = 240
ball_x_momentum# = 1.5
ball_y_momentum# = 1.5
clock# = timer() + 10
instructions# = timer() + 10000
do

   rem move the ball
   inc ball_y#, ball_y_momentum#
   inc ball_x#, ball_x_momentum#

   rem make the ball bounce off of walls
   if ball_y# < 0 or ball_y# > 480 then ball_y_momentum# = -ball_y_momentum#

   rem let the players move the paddle
   p1m# = 0
   p2m# = 0
   if upkey() then dec p2y#, 4: p1m# = -1
   if downkey() then inc p2y#, 4: p2m# = 1

   if keystate(17) then dec p1y#, 4: p1m# = -1
   if keystate(31) then inc p1y#, 4: p1m# = 1

   if p1y# < 0 then p1y# = 0
   if p2y# < 0 then p2y# = 0
   if p1y# > 440 then p1y# = 440
   if p2y# > 440 then p2y# = 440

   rem if the ball hits the paddle
   if ball_x# < 40 and ball_y# > p1y# and ball_y# < p1y# + 40 then ball_x_momentum# = -ball_x_momentum#: ball_y_momentum# = ball_y_momentum# + p1m#

   rem if the ball hits the paddle
   if ball_x# > 600 and ball_y# > p2y# and ball_y# < p2y# + 40 then ball_x_momentum# = -ball_x_momentum#: ball_y_momentum# = ball_y_momentum# + p2m#

   rem if the ball hits the side, give a point and start over
   if ball_x# < 0
      inc p2#
      gosub restart
   endif
   if ball_x# > 640
      inc p1#
      gosub restart
   endif


   cls
   gosub render
   sync


   repeat
   until timer() > clock#
   clock# = clock# + 10

loop

render:
   box ball_x# - 5, ball_y# - 5, ball_x# + 5, ball_y# + 5, rgb(0, 255, 0), rgb(255, 0, 0), rgb(0, 0, 255), rgb(255, 255, 255)
   box 0, p1y#, 40, p1y# + 40, rgb(255, 255, 255), rgb(0, 0, 255), rgb(255, 0, 0), rgb(0, 255, 0)
   box 600, p2y#, 640, p2y# + 40, rgb(255, 255, 255), rgb(0, 0, 255), rgb(255, 0, 0), rgb(0, 255, 0)

   text 0, 0, "Player 1: " + str$(p1#)
   text 640 - text width("Player 2: " + str$(p2#)), 0, "Player 2: " + str$(p2#)
   text 0, 480 - text height(" "), "Frames Per Seconds: " + str$(screen fps())

   if timer() < instructions#
      center text 320, 120, "A Pong Game"
      center text 320, 120 + text height(" "), "by Code Dragon"
      center text 320, 240, "Player 1 uses W and S to move"
      center text 320, 240 + text height(" "), "Player 2 uses the arrow keys to move"
      center text 320, 400 - text height(" "), "Have fun"
   endif

   if keystate(197)
      lost# = timer()
      text 640 - text width("Game Paused"), 480 - text height(" "), "Game Paused"
      sync
      wait 50
      repeat
      until keystate(197)
      wait 50
      clock# = clock# + (timer() - lost#)
   endif
return

rem reset the ball and make it faster in a random direction
restart:
inc speed#, .06
ball_x# = 320
ball_y# = 240
ball_x_momentum# = ((rnd(1) * 2) - 1) * speed#
ball_y_momentum# = ((rnd(1) * 2) - 1) * speed#
return

Rem Project: SuperPong
Rem Created: 3/26/2007 4:42:36 PM

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

SYSTEM_init()

BALL_new()
PADDLE_new(1)
PADDLE_new(3)
BALL_push(0, 0, 0, .01)

do

  PADDLE_update()
  BALL_update()

  text 0, 0, "FPS: " + str$(screen fps())
  sync

loop


function SYSTEM_init()

  sync on
  sync rate 0

  BALL_init()
  PADDLE_init()

endfunction

Rem *** Include File: BALL.dba ***
Rem Created: 3/26/2007 4:43:23 PM

Rem Included in Project: C:\Program Files\The Game Creators\Dark Basic Professional\Projects\SuperPong\SuperPong.dbpro

type ball
  object as dword
  px as float
  py as float
  pz as float
  sx as float
  sy as float
  sz as float
endtype

function BALL_init()

  global dim ball() as ball

endfunction

function BALL_new()

  array insert at bottom ball()
  ball().object = make_obj_sphere(1)

endfunction

function BALL_delete(index as dword)

  delete object ball(index).object
  array delete element ball(), index

endfunction

function BALL_push(index as dword, x as float, y as float, z as float)

  inc ball(index).sx, x
  inc ball(index).sy, y
  inc ball(index).sz, z

endfunction

function BALL_position(index as dword, x as float, y as float, z as float)

  ball(index).px = x
  ball(index).py = y
  ball(index).pz = z

endfunction

function BALL_update()

  local total as integer
  local index as dword

  total = array count(ball())
  if total = -1 then exitfunction

  for index = 0 to total
    inc ball(index).px, ball(index).sx
    inc ball(index).py, ball(index).sy
    inc ball(index).pz, ball(index).sz
    position object ball(index).object, ball(index).px, ball(index).py, ball(index).pz
  next index

endfunction

Rem *** Include File: PADDLE.dba ***
Rem Created: 3/27/2007 3:15:29 PM

Rem Included in Project: C:\Program Files\The Game Creators\Dark Basic Professional\Projects\SuperPong\SuperPong.dbpro

type paddle
  object as dword
  controller as dword

  `the controller variable defines who moves the paddle
  #constant paddle_controller_none = 0
  #constant paddle_controller_arrowkeys = 1
  #constant paddle_controller_WASD = 2
  #constant paddle_controller_mouse = 3
  #constant paddle_controller_AI = 4

  px as float
  py as float
  pz as float
endtype

function PADDLE_init()

  global dim paddle() as paddle

endfunction

function PADDLE_new(controller as dword)

  array insert at bottom paddle()
  paddle().object = make_obj_box(2, 2, .2)
  paddle().controller = controller

endfunction

function PADDLE_delete(index as dword)

  delete object paddle(index).object
  array delete element paddle(), index

endfunction

function PADDLE_position(index as dword, x as float, y as float, z as float)

  paddle(index).px = x
  paddle(index).py = y
  paddle(index).pz = z

endfunction

function PADDLE_update()

  local total as integer
  local index as dword
  local controller as dword
  local x as float
  local y as float

  total = array count(paddle())
  if total = -1 then exitfunction

  for index = 0 to total

    `get controller movement
    controller = paddle(index).controller
    x = 0
    y = 0
    select controller
      case paddle_controller_arrowkeys
        x = (rightkey() - leftkey()) / 20.0
        y = (upkey() - downkey()) / 20.0
      endcase
      case paddle_controller_WASD
      endcase
      case paddle_controller_mouse
        x = mousemovex() / 100.0
        y = -mousemovey() / 100.0
      endcase
      case paddle_controller_AI
      endcase
    endselect

    inc paddle(index).px, x
    inc paddle(index).py, y

    position object paddle(index).object, paddle(index).px, paddle(index).py, paddle(index).pz

  next index

endfunction

Rem *** Include File: Dynamic Media.dba ***
Rem Created: 3/26/2007 4:46:04 PM

Rem Included in Project: C:\Program Files\The Game Creators\Dark Basic Professional\Projects\SuperPong\SuperPong.dbpro

function free_obj()

  local id as dword

  repeat
    inc id
  until object exist(id) = 0

endfunction id

function make_obj_sphere(size as float)

  local id as dword

  id = free_obj()
  make object sphere id, size

endfunction id

function make_obj_box(width as float, height as float, depth as float)

  local id as dword

  id = free_obj()
  make object box id, width, height, depth

endfunction id

autocam off : hide mouse `basic setup
sync on : sync rate 60

type paddle

   obj as integer
   x as float
   y as float
   z as float
   speed as float
   score as integer

endtype

type ball

   obj as integer
   speed as float
   x as float
   z as float
   yang as float
   collision as boolean
   lastHit

   transition as integer

endtype

type powerup

   obj as integer
   current as integer
   appear as integer
   dissappear as integer
   isthere as integer
   x as float
   y as float
   z as float

endtype

dim paddle(1) as paddle
dim ball(0) as ball
dim powerup(0) as powerup

global currVersion as integer `the current kind of pong being played
currVersion = 1 `basic pong (2)=brick,(3)=other???

setup(1)

do

manageUser()
manageComp()
managePowerUps()
manageBall()
manageDisplay()
if currVersion = 2 then manageBricks()

if ball(0).transition > 0
   transition(ball(0).transition)
endif

sync : loop

function clamp(a#,b#,c#)

   if c# < a# then c# = a#
   if c# > b# then c# = b#

endfunction c#

function transition(t)

   v = currVersion
   true as boolean
   true = 0

   if v = 1

      if t = 2

         delete object 2
         delete object 3
         delete object 4

         repeat
            xa = object angle x(1)
            ya = object angle y(1)
            za = object angle z(1)

            rotate object 1,xa+1,ya+1,za+1
            sync

            if object angle x(1) = 360 and object angle y(1) = 360 and object angle z(1) = 360 then true = 1

         until true

         dumpObjects()
         setup(2)
         wait 500
         currVersion = 2
         exitfunction

      endif

   endif

   if v = 2

      if t = 1

         delete object 2
         delete object 3
         delete object 4

         for b = 200 to 219
            if object exist (b) then delete object b
         next b

         repeat
            xa = object angle x(1)
            ya = object angle y(1)
            za = object angle z(1)

            rotate object 1,xa+1,ya+1,za+1
            sync

            if object angle x(1) = 360 and object angle y(1) = 360 and object angle z(1) = 360 then true = 1

         until true

         dumpObjects()
         setup(1)
         wait 500
         currVersion = 1
         exitfunction

      endif

   endif

endfunction

function createBoard() `makes the playing board

   make object box 1,50,0.5,100 `board
   position object 1,0,0-object size y(1)/2,0 `place it so the top is at y-coordinate 0

   make object box 10,4,10,100
   make mesh from object 1,10 `so we can turn it into a limb
   add limb 1,1,1
   offset limb 1,1,27,0,0
   add limb 1,2,1
   offset limb 1,2,-27,0,0
   delete object 10
   delete mesh 1

   color object 1,0
   color limb 1,1,rgb(155,155,55)
   color limb 1,2,rgb(155,155,55)

   make object sphere 10,-5000

endfunction

function setupCamera()

   position camera 0,100,-100
   point camera 0,0,0
   position mouse screen width()/2,screen height()/2 `for convience, set it at middle of screen

endfunction

function createUser() `make the user paddle and such

   make object box 2,10,4,2 `player paddle
   color object 2,rgb(255,55,55)
   paddle(0).obj = 2

endfunction

function createComp()

   clone object 3,2 `computer paddle
   color object 3,rgb(55,255,55)
   paddle(1).obj = 3

endfunction

function createBall() `creates the ball to be hit

   make object sphere 4,5.5
   color object 4,rgb(55,55,255)
   ball(0).obj = 4
   ball(0).transition = 0
   resetBall()

endfunction

function createSpecials()

   make object cube 100,5 `this will be the collision-object
   color object 100,rgb(155,155,155)
   ghost object on 100
   hide object 100
   powerup(0).obj = 100
   powerup(0).current = 0
   powerup(0).appear = timer() + 20000
   powerup(0).dissappear = timer() + 25000
   powerup(0).isthere = 0
   powerup(0).y = 2.5

   make object box 101,3.5,3.5,1 `this is to go to curveball
   `texture it
   color object 101,rgb(55,155,55)
   hide object 101

   make object box 102,3.5,3.5,1 `this will be the powerup to go to brick-ball (lol)
   `texture it
   color object 102,rgb(155,55,55)
   hide object 102

   make object box 103,3.5,3.5,1 `this will be the powerup to go to brick-ball (lol)
   `texture it
   color object 103,rgb(55,55,155)
   hide object 103

endfunction

function createBricks()

   for b = 200 to 219

      make object box b,5,2,2
      placeBrick(b)

   next b

endfunction

function manageUser() `take care of user input and actions

   o = paddle(0).obj
   x# = object position x(2)
   y# = object position y(2)
   z# = object position z(2)
   ox# = x#
   inc x#,mousemovex()/2 `mouse sensitivity
   x# = clamp(-20,20,x#) `clamp the value between -20 and 20
   paddle(0).speed = x#-ox# `set it's speed/direction for future reference

   position object o,x#,y#,z#
   paddle(0).x = x#

endfunction

function manageComp() `HORRIBLE AI CODE...needs serious help

   o = paddle(1).obj
   m# = abs(paddle(0).speed) `this is just so there is some relation between the speed of the player and that of the computer
   if m# = 0 then m# = 1 `if the player doesn't move, then i'll let the computer move 1
   m# = m#/2`Computer Difficulty (m#/1 = definite loss)

   x# = object position x(o)
   y# = object position y(o)
   z# = object position z(o)
   ox# = x#

      if ball(0).x > ox#
         x# = ox# + m#
      else
         if ball(0).x < ox#
            x# = ox# - m#
         endif
      endif


   x# = clamp(-20,20,x#)
   position object o,x#,y#,z#
   paddle(1).x = x#
   paddle(1).speed = x#-ox#

endfunction

function manageBall()

   o = ball(0).obj `just a reference to the object number
   m# = ball(0).speed
   ox# = object position x(o) `the previous x
   oz# = object position z(o) `the previous z
   y# = object position y(o) `just a reference to the y position
   yan# = ball(0).yang `the object angle

   nx# = ox#+(m#*cos(yan#)) `uses trig to find new position
   nz# = oz#+(m#*sin(yan#))

   nnx# = clamp(-23.5,23.5,nx#) `this is to check for collision with walls
   if nnx# <> nx# `collision occured (needed to clamp)

      yan# = 180-yan#`yan# - 180
      inc m#,0.1
      nx# = nnx#
   endif
   position object o,nx#,y#,nz#
   ball(0).x = nx#
   ball(0).z = nz#

   nnz# = clamp(-48.5,48.5,nz#) `this is to check if a score
   if nnz# <> nz# `a score

      if nz# < 0 `computer scored

         inc paddle(1).score

      else

         inc paddle(0).score

      endif
      resetBall()
      t = timer() + 500
      repeat
         manageUser()
         manageComp()
         sync
      until timer() > t
      exitfunction

   else

      `this checks for collision between ball and paddle
      if nz# < 0 `this will set the obejct to check collision with
         col = 0
      else
         col = 1
      endif

      if object collision (o,paddle(col).obj) = 1 and ball(0).collision = 0

         ball(0).collision = 1
         yan# = yan# - 180
         inc m#,0.2
         ball(0).lastHit = col `0 = player, 1 = computer

         if nx# < object position x(paddle(col).obj) `this is to give it an extra bounce
            yan# = yan#-10
         else
            if nx# > object position x(paddle(col).obj)
               yan# = yan#+10
            endif
         endif

         if paddle(col).speed > 0
            inc yan#,4
         else
            if paddle(col).speed < 0
               inc yan#,-4
            endif
         endif

      else

         ball(0).collision = 0

      endif

   endif

   ball(0).yang = wrapvalue(yan#)
   m# = clamp(0.9,2.5,m#)
   ball(0).speed = m#

endfunction

function manageBricks()

   for b = 200 to 219

      if object collision (ball(0).obj,b) = 1

         sx = object screen x(b)
         sy = object screen y(b)

         red = rgbr(point(sx,sy))
         green = rgbg(point(sx,sy))
         blue = rgbb(point(sx,sy))

         s = red+green+blue

         s = s/150
         if s = 0 then s = 1

         inc paddle(ball(0).lastHit).score,s

         placeBrick(b)

         ball(0).yang = 180-ball(0).yang
         ball(0).speed = ball(0).speed + 0.1
         exitfunction

      endif

   next b

endfunction

function manageDisplay()

   text 80,100,str$(paddle(1).score)
   text 80,140,str$(paddle(0).score)

   if len(str$(paddle(0).score)) > len(str$(paddle(1).score))
      temp$ = str$(paddle(0).score)
   else
      temp$ = str$(paddle(1).score)
   endif

   s$ = ""
   for i = 1 to len(temp$)
      s$ = s$ + "-"
   next i

   text 80,120,s$

endfunction

function managePowerUps()

   if powerup(0).current = -1

      a = rnd(25) + 15
      d = a + rnd(20) + 10
      d = d * 1000
      a = a * 1000

      powerup(0).current = 0
      powerup(0).appear = a+timer()
      powerup(0).dissappear = d + timer()
      exitfunction

   endif

   if powerup(0).current = 0

      `print  "waiting..."

      if timer() >= powerup(0).appear

         repeat
            c = rnd(1)+1
         until c <> currVersion
         powerup(0).current = c
         powerup(0).isthere = 1
         x = rnd(40)-20
         z = rnd(80)-40
         powerup(0).x = x
         powerup(0).z = z

         o = powerup(0).obj
         position object o,x,powerup(0).y,z
         show object o
         position object 100+c,x,powerup(0).y,z
         show object 100+c

      endif
      exitfunction

   endif

   if powerup(0).isthere = 1

     ` print "it's there"

      c = powerup(0).current + 100
      xa# = object angle x(c)
      ya# = object angle y(c)
      za# = object angle z(c)

      rotate object c,xa#+1,ya#-1,za#+1

      if timer() >= powerup(0).dissappear
         powerup(0).current = -1
         powerup(0).isthere = 0
         hide object powerup(0).obj
         hide object c
         exitfunction
      endif

      if object collision (powerup(0).obj,ball(0).obj) = 1
         powerup(0).current = -1
         powerup(0).isthere = 0
         hide object powerup(0).obj
         hide object c
         ball(0).transition = c-100
         exitfunction
      endif

   endif

endfunction

function placeBrick(o)

   position object o,rnd(40)-20,1,rnd(60)-30

   for b = 200 to 219

      if b <> o
         if object exist(b)
            if object collision(o,b)
               placeBrick(o)
            endif
         endif
      endif
   next b

   color object o,rgb(rnd(254)+1,rnd(254)+1,rnd(254)+1)

endfunction

function resetBall() `positions ball

   position object ball(0).obj,0,object size y(4)/2,0 `puts it at ground level
   ball(0).speed = 1
   ball(0).x = 0
   ball(0).z = 0
   ball(0).yang = -90

endfunction

function resetPaddles()

   position object 2,0,object size y(2)/2,-49
   paddle(0).x = 0
   paddle(0).z = -49
   paddle(0).y = object size y(2)/2

   position object 3,object position x(2),object position y(2),object position z(2)*-1 `so you only need to change one set of values if you change size
   paddle(1).x = 0
   paddle(1).z = 49
   paddle(1).y = object size y(3)/2

endfunction

function dumpObjects() `just to clean everything up

   if object exist(1) then delete object 1
   if object exist(2) then delete object 2
   if object exist(3) then delete object 3
   if object exist(4) then delete object 4
   if object exist(10) then delete object 10
   if object exist(15) then delete object 15
   if object exist(100) then delete object 100
   if object exist(101) then delete object 101
   if object exist(102) then delete object 102
   if object exist(103) then delete object 103

   for b = 200 to 219

      if object exist(b) then delete object b

   next b

endfunction

function resetGame() `as in, when you start over

   dumpObjects()
   setup(1)

endfunction

function setup(t) `the start

   createBoard()
   setupCamera()
   createUser()
   createComp()
   resetPaddles()
   createBall()
   createSpecials()
   if t = 2 then createBricks()

endfunction

remstart

List of Information:

Object 1 - the board on bottom
Object 2 - Player's paddle
Object 3 - Computer's paddle
Object 4 - The Ball
***
Object 15 - Background
***
Object 100 - Collision cube for powerups
Object 101 - A powerup
Object 102 - Another powerup
Object 103 - Another one
***
200-219 - bricks

remend

Rem Project: SuperPong
Rem Created: 3/26/2007 4:42:36 PM

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

SYSTEM_init()

global win as boolean
global score1 as dword
global score2 as dword
global speed as float
global repush as dword

local keypress as string
local direction as float

do

BALL_nuke()
PADDLE_nuke()
GOAL_nuke()
GENERATOR_nuke()
OBSTACLE_nuke()

do

  cls

  set text size 64
  center text screen width()/2, screen height()/4, "SuperPong"
  set text size 32

  center text screen width()/2, screen height()/2-40, "(1) Classic"
  center text screen width()/2, screen height()/2, "(2) Adventure"
  center text screen width()/2, screen height()/2+40, "(3) Quit"
  
  keypress = inkey$()
  if keypress = "1" or keypress = "2" then exit
  if keypress = "3" then end
  set text size 16
  text screen width()-text width("(C) Code Dragon 2007"), screen height()-20, "(C) Code Dragon 2007"

  sync

loop

levelnum = 0

if keypress = "1"

  speed = .1
  repush = 1
  score1 = 0
  score2 = 0

  LEVELLOADER_load("Classic.txt")
  
  CAMERA_rotate(0, 180, camera_distance)
  
  do
    BALL_update()
    PADDLE_update()
    
    if repush
      dec repush
      if repush = 0
        inc speed, .01
        direction = rnd(90) + (rnd(1)*4-1)*45
        BALL_push(0, newxvalue(0, direction, speed), 0, newzvalue(0, direction, speed))
      endif
    endif
    
    CAMERA_update(0)
    center text screen width()/2, 0, "Classic"
    text 0, 0, "Blue Score: " + str$(score2)
    text screen width() - text width("Red Score: " + str$(score1)), 0, "Red Score: " + str$(score1)
    if escapekey() then exit
    sync
    
  loop
  
else

  levelnum = 1
  LEVELLOADER_load("Level 1.txt")

  do

    GOAL_update()
    
    if win
      win = 0
      do
        cls
        set text size 64
        center text screen width()/2, screen height()/2-20, "Congratulations!"
        center text screen width()/2, screen height()/2+30, "You Win!"
        set text size 32
        center text screen width()/2, screen height()-40, "Press enter key to continue"
        if returnkey() then exit
        sync
      loop
      exit
    endif
    
    GENERATOR_update()
    BALL_update()
    PADDLE_update()

    CAMERA_update(1)
    center text screen width()/2, 0, "Level " + str$(levelnum) + ": " + levelname
    if escapekey() then exit
    sync

  loop
  
endif

loop


function SYSTEM_init()
  
  sync on
  sync rate 60

  set display mode 1280, 768, 32

  ink rgb(0, 255, 0), 0
  set text font "Comic Sans MS"
  set text size 64

  hide mouse
  disable escapekey

  FILEEXTRACTER_init()
  LEVELLOADER_init()
  CAMERA_init()
  BALL_init()
  PADDLE_init()
  GENERATOR_init()
  GOAL_init()
  OBSTACLE_init()

endfunction
Rem *** Include File: BALL.dba ***
Rem Created: 3/26/2007 4:43:23 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

type ball
  object as dword
  px as float
  py as float
  pz as float
  sx as float
  sy as float
  sz as float
endtype

function BALL_init()

  dim ball() as ball

endfunction

function BALL_new()

  local index as dword

  array insert at bottom ball()
  ball().object = make_obj_sphere(1)
  color object ball().object, rgb(255, 0, 255)

  index = array count(ball())

endfunction index

function BALL_delete(index as dword)

  delete object ball(index).object
  array delete element ball(), index

endfunction

function BALL_nuke()

  local total as integer
  local index as dword
  
  total = array count(ball())
  if total = -1 then exitfunction
  
  for index = 0 to total
    BALL_delete(0)
  next index

endfunction

function BALL_push(index as dword, x as float, y as float, z as float)

  inc ball(index).sx, x
  inc ball(index).sy, y
  inc ball(index).sz, z
  
endfunction

function BALL_stop(index as dword)

  ball(index).sx = 0
  ball(index).sy = 0
  ball(index).sz = 0
  
endfunction

function BALL_position(index as dword, x as float, y as float, z as float)

  ball(index).px = x
  ball(index).py = y
  ball(index).pz = z
  position object ball(index).object, x, y, z

endfunction

function BALL_update()

  local total as integer
  local index as dword
  local generator_total as integer
  local generator as dword
  local colx as float
  local coly as float
  local colz as float
  local skip as boolean

  total = array count(ball())
  if total = -1 then exitfunction
  
  generator_total = array count(generator())

  for index = 0 to total
  
    `delete ball if it's too far away
    if obj_distance(ball(index).object, 0, 0, 0) > 100
    
      BALL_delete(index)
      dec total
      if total = -1 then exitfunction
      
    else

      if object collision(ball(index).object, 0)
      
        `calculate collision
        colx = get object collision x()
        coly = get object collision y()
        colz = get object collision z()
        dec ball(index).px, colx
        dec ball(index).py, coly
        dec ball(index).pz, colz

        `make the ball bounce
        if colx then colx = -2 * ball(index).sx
        if coly then coly = -2 * ball(index).sy
        if colz then colz = -2 * ball(index).sz

        BALL_push(index, colx, coly, colz)

      endif

      `apply momentum
      inc ball(index).px, ball(index).sx
      inc ball(index).py, ball(index).sy
      inc ball(index).pz, ball(index).sz
      
      if levelnum = 0 and abs(ball(index).pz) > 15
        if ball(index).pz > 15
          inc score1
        else
          inc score2
        endif
        
        BALL_position(index, 0, 0, 0)
        BALL_stop(index)
        repush = 90
        
      endif

      position object ball(index).object, ball(index).px, ball(index).py, ball(index).pz
      
    endif

  next index

endfunction
Rem *** Include File: CAMERA.dba ***
Rem Created: 3/27/2007 7:19:36 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

global camera_zenith as float
global camera_azimuth as float
global camera_distance as float
global camera_x as float
global camera_y as float
global camera_z as float

function CAMERA_init()

  autocam off

endfunction

function CAMERA_rotate(zenith as float, azimuth as float, distance as float)

  camera_zenith = zenith
  camera_azimuth = azimuth
  camera_distance = distance

endfunction

function CAMERA_position(x as float, y as float, z as float)

  camera_x = x
  camera_y = y
  camera_z = z

endfunction

function CAMERA_orbit(degrees as dword)

  local caption as string
  
  if levelnum
    caption = "Level " + str$(levelnum) + ": " + levelname
  else
    caption = levelname
  endif

  repeat
    inc camera_azimuth
    dec degrees
    CAMERA_update(0)
    center text screen width()/2, screen height()/2, caption
    sync
  until degrees = 0

endfunction

function CAMERA_spiral(degrees as float)

  repeat
    inc camera_azimuth, 1.5
    inc camera_distance
    dec degrees, 1.5
    CAMERA_update(0)
    center text screen width()/2, screen height()/2, "Level " + str$(levelnum) + ": " + levelname
    center text screen width()/2, screen height()/2+64, "Clear"
    sync
  until degrees <= 0

endfunction

function CAMERA_swing(zenith as float, azimuth as float, distance as float)

  local caption as string
  local interval as dword
  local time as dword

  if levelnum
    caption = "Level " + str$(levelnum) + ": " + levelname
    interval = 75
    time = 100
  else
    caption = levelname
    interval = 40
    time = 250
  endif

  for count = 0 to time
    camera_zenith = curveangle(zenith, camera_zenith, interval)
    camera_azimuth = curveangle(azimuth, camera_azimuth, interval)
    camera_distance = curvevalue(distance, camera_distance, interval)
    CAMERA_update(0)
    if levelnum then center text screen width()/2, screen height()/2, caption
    sync
  next count

endfunction

function CAMERA_update(controllable as boolean)

  local x as float
  local y as float
  local z as float

  `control camera using mouse
  if controllable
    dec camera_zenith, -mousemovey() / 10.0
    inc camera_azimuth, mousemovex() / 10.0
    inc camera_distance, -mousemovez() / 100.0
  endif

  `keep sphereical coordinates within boundaries
  if camera_zenith < 1 then camera_zenith = 1
  if camera_zenith > 179 then camera_zenith = 179
  camera_azimuth = wrapvalue(camera_azimuth)
  if camera_distance < 1 then camera_distance = 1
  if controllable and camera_distance > 90 then camera_distance = 90

  `convert spherical coordinates to cartesian cordinates
  x = camera_x + camera_distance * cos(camera_azimuth) * sin(camera_zenith)
  y = camera_y + camera_distance * cos(camera_zenith)
  z = camera_z + camera_distance * sin(camera_azimuth) * sin(camera_zenith)

  position camera x, y, z
  point camera camera_x, camera_y, camera_z

endfunction
Rem *** Include File: Dynamic Media.dba ***
Rem Created: 3/26/2007 4:46:04 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

function free_obj()

  local id as dword

  repeat
    inc id
  until object exist(id) = 0

endfunction id

function free_img()

  local id as dword

  repeat
    inc id
  until image exist(id) = 0

endfunction id

function free_spr()

  local id as dword

  repeat
    inc id
  until sprite exist(id) = 0

endfunction id

function get_image(left as dword, top as dword, right as dword, bottom as dword, textureflag as dword)

  local id as dword

  id = free_img()
  get image id, left, top, right, bottom, textureflag

endfunction id

function make_spr(xpox as integer, ypos as integer, img as dword)

  local id as dword

  id = free_img()
  sprite id, xpos, ypos, img

endfunction id

function open_to_read(filename as string)

  local id as dword
  id = free_file()
  open to read id, filename

endfunction id

function free_file()

  local id as dword

  repeat
    inc id
  until file open(id) = 0

endfunction id

function make_obj_sphere(size as float)

  local id as dword

  id = free_obj()
  make object sphere id, size

endfunction id

function make_obj_cube(size as float)

  local id as dword

  id = free_obj()
  make object cube id, size

endfunction id

function make_obj_box(width as float, height as float, depth as float)

  local id as dword

  id = free_obj()
  make object box id, width, height, depth

endfunction id
Rem *** Include File: GENERATOR.dba ***
Rem Created: 3/30/2007 4:00:09 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

type generator
  object as dword
  px as float
  py as float
  pz as float
  
  bx as float
  by as float
  bz as float

  delay as dword
  time as dword

endtype

function GENERATOR_init()

  global dim generator() as generator

endfunction

function GENERATOR_new()

  local index as dword

  array insert at bottom generator()
  generator().object = make_obj_cube(.8)
  set object collision off generator().object
  color object generator().object, rgb(255, 255, 0)
  generator().delay = 60
  generator().time = generator().delay

  index = array count(generator())

endfunction index

function GENERATOR_delete(index as dword)

  delete object generator(index).object
  array delete element generator(), index

endfunction

function GENERATOR_nuke()

  local total as integer
  local index as dword

  total = array count(generator())
  if total = -1 then exitfunction

  for index = 0 to total
    GENERATOR_delete(0)
  next index

endfunction

function GENERATOR_set(index as dword, speed as dword, x as float, y as float, z as float)

  generator(index).delay = speed
  generator(index).bx = x
  generator(index).by = y
  generator(index).bz = z

endfunction

function GENERATOR_position(index as dword, x as float, y as float, z as float)

  generator(index).px = x
  generator(index).py = y
  generator(index).pz = z
  position object generator(index).object, x, y, z

endfunction

function GENERATOR_update()

  local total as integer
  local index as dword
  local ball as dword

  total = array count(generator())
  if total = -1 then exitfunction

  for index = 0 to total

    dec generator(index).time
    if generator(index).time = 0

      generator(index).time = generator(index).delay

      ball = BALL_new()
      BALL_position(ball, generator(index).px, generator(index).py, generator(index).pz)
      BALL_push(ball, generator(index).bx, generator(index).by, generator(index).bz)

    endif

    `yrotate object generator(index).object, 2+object angle y(generator(index).object)

  next index

endfunction
Rem *** Include File: GOAL.dba ***
Rem Created: 3/31/2007 7:15:57 AM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

global goal_amount as dword

type goal
  object as dword
  px as float
  py as float
  pz as float
  size as float
endtype

function GOAL_init()

  dim goal() as goal

endfunction

function GOAL_new(size as float)

  local index as dword

  array insert at bottom goal()
  goal().object = make_obj_cube(size)
  goal().size = size
  set object collision off goal().object
  color object goal().object, rgb(0, 255, 0)
  
  index = array count(goal())

endfunction index

function GOAL_delete(index as dword)

  delete object goal(index).object
  array delete element goal(), index
  
endfunction

function GOAL_nuke()

  local total as integer
  local index as dword

  total = array count(goal())
  if total = -1 then exitfunction

  for index = 0 to total
    GOAL_delete(0)
  next index

endfunction

function GOAL_position(index as dword, x as float, y as float, z as float)

  goal(index).px = x
  goal(index).py = y
  goal(index).pz = z
  position object goal(index).object, x, y, z

endfunction

function GOAL_update()

  local total as integer
  local index as dword
  local ball_total as integer
  local ball as dword
  
  total = array count(goal())
  if total = -1 then exitfunction
  
  ball_total = array count(ball())
  
  for index = 0 to total

    if ball_total > -1
      for ball = 0 to ball_total
        if objs_distance(goal(index).object, ball(ball).object) < goal(index).size
          BALL_delete(ball)
          dec ball_total
          dec goal_amount
          if goal_amount = 0
            LEVELLOADER_unload()
            inc levelnum
            if file exist("Level " + str$(levelnum) + ".txt") = 0
              win = 1
              exitfunction
            endif
            LEVELLOADER_load("Level " + str$(levelnum) + ".txt")
            exitfunction
          endif
          exit
        endif
      next ball
    endif

    xrotate object goal(index).object, 1+object angle x(goal(index).object)
    yrotate object goal(index).object, 1+object angle y(goal(index).object)

  next index
  
  text screen width() - text width("Goals Needed: " + str$(goal_amount)) - 10, 0, "Goals Needed: " + str$(goal_amount)

endfunction
Rem *** Include File: LEVELLOADER.dba ***
Rem Created: 3/31/2007 8:12:10 AM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

global levelnum as dword
global levelname as string

function LEVELLOADER_init()

  dim vals(10) as float

endfunction

function LEVELLOADER_load(levelstr as string)

  local level as dword
  local str as string
  local count as dword
  local returnval as dword

  level = open_to_read(levelstr)
  
  while file end(level) = 0
    read string level, str
    
    select str
    
      case "[name]"
        read string level, levelname
      endcase
      
      case "[player]"
        read string level, str
        repeat
          csv$(str)
          for count = 0 to 3
            vals(count) = val(csv$(""))
          next count
          returnval = PADDLE_new(vals(0))
          PADDLE_position(returnval, vals(1), vals(2), vals(3))
          read string level, str
        until str = ""
      endcase
      
      case "[ball]"
        read string level, str
        repeat
          csv$(str)
          for count = 0 to 5
            vals(count) = val(csv$(""))
          next count
          returnval = BALL_new()
          BALL_position(returnval, vals(0), vals(1), vals(2))
          BALL_push(returnval, vals(3), vals(4), vals(5))
          read string level, str
        until str = ""
      endcase
      
      case "[generator]"
        read string level, str
        repeat
          csv$(str)
          for count = 0 to 6
            vals(count) = val(csv$(""))
          next count
          returnval = GENERATOR_new()
          GENERATOR_position(returnval, vals(0), vals(1), vals(2))
          GENERATOR_set(returnval, vals(3), vals(4), vals(5), vals(6))
          read string level, str
        until str = ""
      endcase
      
      case "[goal]"
        read string level, str
        goal_amount = val(str)
        read string level, str
        repeat
          csv$(str)
          for count = 0 to 3
            vals(count) = val(csv$(""))
          next count
          returnval = GOAL_new(vals(3))
          GOAL_position(returnval, vals(0), vals(1), vals(2))
          read string level, str
        until str = ""
      endcase
      
      case "[obstacle]"
        read string level, str
        repeat
          csv$(str)
          for count = 0 to 5
            vals(count) = val(csv$(""))
          next count
          OBSTACLE_new(vals(0), vals(1), vals(2), vals(3), vals(4), vals(5))
          read string level, str
        until str = ""
      endcase
      
      case "[camera]"
      
        read string level, str
        csv$(str)
        for count = 0 to 2
          vals(count) = val(csv$(""))
        next count
        
        read string level, str
        csv$(str)
        for count = 3 to 5
          vals(count) = val(csv$(""))
        next count
        
        read string level, str
        vals(6) = val(str)
        
        read string level, str
        csv$(str)
        for count = 7 to 9
          vals(count) = val(csv$(""))
        next count
        
        CAMERA_position(vals(0), vals(1), vals(2))
        CAMERA_rotate(vals(3), vals(4), vals(5))
        set text size 64
        CAMERA_orbit(vals(6))
        CAMERA_swing(vals(7), vals(8), vals(9))
        
      endcase
      
    endselect
    
  endwhile
  
  set text size 32

endfunction

function LEVELLOADER_unload()

  set text size 64
  set text font "Comic Sans MS"
  CAMERA_spiral(270)
  set text size 32

  BALL_nuke()
  GENERATOR_nuke()
  GOAL_nuke()
  PADDLE_nuke()
  OBSTACLE_nuke()
  
endfunction
Rem *** Include File: Math.dba ***
Rem Created: 3/29/2007 4:15:55 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

function objs_distance(object1 as dword, object2 as dword)

  local distance as float

  distance = sqrt((object position x(object1) - object position x(object2))^2 + (object position y(object1) - object position y(object2))^2 + (object position z(object1) - object position z(object2))^2)

endfunction distance

function obj_distance(object1 as dword, x as float, y as float, z as float)

  local distance as float

  distance = sqrt((object position x(object1) - x)^2 + (object position y(object1) - y)^2 + (object position z(object1) - z)^2)

endfunction distance
Rem *** Include File: PADDLE.dba ***
Rem Created: 3/27/2007 3:15:29 PM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

type paddle
  object as dword
  controller as dword

  `the controller variable defines who moves the paddle
  #constant paddle_controller_none = 0
  #constant paddle_controller_arrowkeys = 1
  #constant paddle_controller_WASD = 2
  #constant paddle_controller_mouse = 3
  #constant paddle_controller_AI = 4

  px as float
  py as float
  pz as float
endtype

function PADDLE_init()

  dim paddle() as paddle

endfunction

function PADDLE_new(controller as dword)

  local index as dword

  array insert at bottom paddle()
  paddle().object = make_obj_box(2.5, 2.5, .4)
  paddle().controller = controller
  select controller
    case 1
      color object paddle().controller, rgb(255, 0, 0)
    endcase
    case 2
      color object paddle().controller, rgb(0, 255, 255)
    endcase
  endselect

  index = array count(paddle())

endfunction index

function PADDLE_delete(index as dword)

  delete object paddle(index).object
  array delete element paddle(), index

endfunction

function PADDLE_nuke()

  local total as integer
  local index as dword

  total = array count(paddle())
  if total = -1 then exitfunction

  for index = 0 to total
    PADDLE_delete(0)
  next index

endfunction

function PADDLE_position(index as dword, x as float, y as float, z as float)

  paddle(index).px = x
  paddle(index).py = y
  paddle(index).pz = z
  position object paddle(index).object, x, y, z

endfunction

function PADDLE_update()

  local total as integer
  local index as dword
  local controller as dword
  local x as float
  local y as float
  local ball as dword
  local ball_total as integer

  total = array count(paddle())
  if total = -1 then exitfunction
  
  ball_total = array count(ball())

  for index = 0 to total

    `get controller movement
    controller = paddle(index).controller
    x = 0
    y = 0
    select controller
      case paddle_controller_arrowkeys
        x = (rightkey() - leftkey()) / 20.0
        y = (upkey() - downkey()) / 20.0
      endcase
      case paddle_controller_WASD
        x = (keystate(32) - keystate(30)) / 20.0
        y = (keystate(17) - keystate(31)) / 20.0
      endcase
      case paddle_controller_mouse
        x = mousemovex() / 100.0
        y = -mousemovey() / 100.0
      endcase
      case paddle_controller_AI
      endcase
    endselect
    
    if levelnum = 0
      x = y*2
      y = 0
      if paddle(index).px < -8 and x < 0 then paddle(index).px = -8
      if paddle(index).px > 8 and x > 0 then paddle(index).px = 8
    endif

    inc paddle(index).px, x
    inc paddle(index).py, y

    position object paddle(index).object, paddle(index).px, paddle(index).py, paddle(index).pz

    if ball_total > -1
      for ball = 0 to ball_total
        if object collision(paddle(index).object, ball(ball).object)
          `make the ball inherit some of the paddle's momentum
          BALL_push(ball, x/2, y/2, 0)
        endif
      next ball
    endif

  next index

endfunction
Rem *** Include File: String.dba ***
Rem Created: 3/31/2007 8:24:43 AM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

global csv_start as dword
global csv_values as string

`extracts individual values from a comma separated values string
function csv$(called_values as string)

  local count as dword
  local return_value as string

  `if the function was called with values, replace the saved values
  if called_values <> ""
    csv_values = called_values
    csv_start = 1
    exitfunction ""
  endif

  `if all the tokens have been taken return end of string
  if csv_start > len(csv_values) then exitfunction "END OF STRING"

  `look for a comma
  for count = csv_start to len(csv_values)

    `if the character's a comma, return the token
    if mid$(csv_values, count) = ","
      return_value = right$(left$(csv_values, count - 1), count - csv_start)
      csv_start = count + 1
      exitfunction return_value
    endif

  next count

  `no comma found, so return last token
  return_value = right$(csv_values, count - csv_start)
  csv_start = count

endfunction return_value
Rem *** Include File: FILEEXTRACTER.dba ***
Rem Created: 4/2/2007 8:26:00 AM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

function FILEEXTRACTER_init()

  local currentlevel as dword
  local str as string

  restore leveldata

  do
    read str
    if str = "[name]"
      if file open(1) = 1 then close file 1
      if currentlevel
        if file exist("Level " + str$(currentlevel) + ".txt") then delete file "Level " + str$(currentlevel) + ".txt"
        open to write 1, "Level " + str$(currentlevel) + ".txt"
      else
        if file exist("Classic.txt") then delete file "Classic.txt"
        open to write 1, "Classic.txt"
      endif
      
      inc currentlevel
    endif
    if str = "EOD" then exit
    write string 1, str
  loop
  close file 1

endfunction

leveldata:


data "[name]"
data "Classic"
data ""
data "[player]"
data "1, 0, 0, -10"
data "2, 0, 0, 10"
data ""
data "[ball]"
data "0, 0, 0, 0, 0, 0"
data ""
data "[obstacle]"
data "0, -1.5, 0, 19, .5, 20"
data "9.25, -.25, 0, .5, 2, 20"
data "-9.25, -.25, 0, .5, 2, 20"
data ""
data "[camera]"
data "0, 0, 0"
data "70, 0, 30"
data "90"
data "0, 180, 30"
data ""
data "[name]"
data "Easy"
data ""
data "[player]"
data "1, 0, 0, 0"
data "2, -5, 0, 5"
data ""
data "[generator]"
data "5, 0, -5, 60, -.1, 0, .1"
data ""
data "[goal]"
data "1"
data "-10, 0, 10, 2"
data ""
data "[camera]"
data "-2.5, 0, 2.5"
data "60, 0, 30"
data "270"
data "70, -60, 20"
data ""
data "[name]"
data "Zigzag"
data ""
data "[player]"
data "1, 0, 0, -10"
data "2, 0, 0, 10"
data ""
data "[generator]"
data "0, 0, 0, 30, -.1, 0, -.1"
data ""
data "[goal]"
data "3"
data "-40, 0, 0, 3"
data ""
data "[camera]"
data "-20, 0, 0"
data "40, 90, 50"
data "180"
data "80, -30, 35"
data ""
data "[name]"
data "Bounce System"
data ""
data "[player]"
data "1, 0, 0, -15"
data "2, 5, 0, 15"
data ""
data "[generator]"
data "-8, 0, 18, 60, .1, 0, -.1"
data ""
data "[goal]"
data "5"
data "4, 0, 0, 1"
data ""
data "[obstacle]"
data "0, -1, 0, 2, .5, 20"
data "-1.25, .25, 0, .5, 2, 20"
data "0, 1.5, 0, 2, .5, 20"
data "1.25, .25, 2.5, .5, 2, 25"
data "9, -1, 0, 2, .5, 20"
data "7.75, .25, 0, .5, 2, 20"
data "9, 1.5, 0, 2, .5, 20"
data "10.25, .25, 0, .5, 2, 20"
data ""
data "[camera]"
data "4, 0, 0"
data "50, 0, 40"
data "180"
data "80, -40, 30"
data ""
data "[name]"
data "Vertical Tunnel"
data ""
data "[player]"
data "1, 0, -5, -5"
data "2, 0, -5, 5"
data ""
data "[generator]"
data "0, -5, 19, 30, -.1, .1, -.1"
data "19, -5, 0, 30, .1, .1, .1"
data "0, -5, -19, 30, .1, .1, .1"
data "-19, -5, 0, 30, .1, .1, -.1"
data ""
data "[goal]"
data "8"
data "0, 50, 0, 12"
data ""
data "[obstacle]"
data "20, 15, 0, 1, 60, 39"
data "0, 15, 20, 39, 60, 1"
data "-20, 15, 0, 1, 60, 39"
data "0, 15, -20, 39, 60, 1"
data "0, -15.5, 0, 39, 1, 39"
data ""
data "[camera]"
data "0, 0, 0"
data "35, 90, 100"
data "180"
data "15, -55, 10"
data "EOD"
Rem *** Include File: OBSTACLE.dba ***
Rem Created: 4/2/2007 11:28:54 AM

Rem Included in Project: C:Program FilesThe Game CreatorsDark Basic ProfessionalProjectsSuperPongSuperPong.dbpro

type obstacle
  object as dword
endtype

function OBSTACLE_init()

  dim obstacle() as obstacle

endfunction

function OBSTACLE_new(x as float, y as float, z as float, width as float, height as float, depth as float)

  array insert at bottom obstacle()
  obstacle().object = make_obj_box(width, height, depth)
  position object obstacle().object, x, y, z

endfunction

function OBSTACLE_delete(index as dword)

  delete object obstacle(index).object
  array delete element obstacle(), index

endfunction

function OBSTACLE_nuke()

  local total as integer
  local index as dword

  total = array count(obstacle())
  if total = -1 then exitfunction

  for index = 0 to total
    OBSTACLE_delete(0)
  next index

endfunction

set display mode 1024,768,32
set camera range 1,5000
backdrop on
color backdrop 0
hide mouse
sync rate 60
sync on
paddle=1
table=2
net=3
ball=4
paddle2=5
score_comp=6
score_player=7
paddle_texture=1
table_texture=2
net_texture=3
ball_texture=4
score1=5
score2=6
paddle_rim=1
paddle_handle=2
net_post=3
paddlex#=0.0
paddley#=0.0
paddlez#=605.0
pad2x#=50.0
pad2y#=0.0
pad2z#=-605.0
pad2xv#=0.0
pad2yv#=0.0
pad2xm#=3.0
pad2ym#=3.0
border#=350.0
gravity#=0.05
friction#=0.9
table_height=-45
play=0
make_play=0
dim score(2)
dim ballhit(2)
ballhit(1)=0
ballhit(2)=0
servedir=1
make light 1
position light 1,0,250,1050
position light 0,0,500,0
set image colorkey 0,0,0
gosub make_paddle
instance object paddle2,paddle
gosub make_table
position object table,0,table_height-5,0
gosub make_net
position object net,0,table_height+25,0
gosub make_ball
gosub make_scoreboard
yrotate object score_comp,270
yrotate object score_player,270
position object score_comp,400,0,50
position object score_player,400,0,550
position camera 0,250,1050
point camera 0,0,0
while not escapekey()
  gosub move_paddle
  gosub move_camera
  if play=0
    ink rgb(255,255,255),0
    if servedir=1
      box 665,325,805,345
      set cursor 670,327
    else
      box 850,640,990,660
      set cursor 855,642
    endif
    ink 0,0
    set text font "arial"
    set text size 16
    print "SPACEBAR to serve"
  endif
  if spacekey()
    if play=0 then play=1
  endif
  if not spacekey()
    if play=1
      play=2
      gosub ball_serve
    endif
  endif
  if play=2
    ballyv#=ballyv#-gravity#
    ballx#=ballx#+ballxv#
    bally#=bally#+ballyv#
    ballz#=ballz#+ballzv#
    if bally#<table_height+10
      if ballx#>=-400 and ballx#<=400 and ballz#>=-600 and ballz#<=600
        ballyv#=-ballyv#*friction#
        bally#=bally#+ballyv#
        if ballz#<0 then inc ballhit(2)
        if ballz#>0 then inc ballhit(1)
      endif
    endif
    if ballz#<-605 then gosub computer
    if ballz#>605 and ballz#<615 then gosub player
    if ballz#>-10 and ballz#<10 then gosub net
    if bally#<table_height then gosub ball_stop
    if abs(ballz#)>700 then gosub ball_stop
    position object ball,ballx#,bally#,ballz#
    xrotate object ball,object angle x(ball)+6.0
    if makeplay>0
      if ballhit(3-makeplay)=1 and ballhit(makeplay)=0 then gosub ball_stop
    endif
  endif
  sync
endwhile
end
update_score:
  set current bitmap score1
  ink rgb(0,255,255),0
  box 0,0,50,50
  ink rgb(0,0,128),0
  set cursor 10,10
  set text font "arial"
  set text size 20
  print score(1)
  get image score1,0,0,50,50
  set current bitmap score2
  ink rgb(0,255,255),0
  box 0,0,50,50
  ink rgb(0,0,128),0
  set cursor 10,10
  print score(2)
  get image score2,0,0,50,50
  set current bitmap 0
  texture object score_comp,score1
  texture object score_player,score2
return
move_camera:
  if upkey()
    pitch camera up 90.0
    move camera 1
    point camera 0,0,0
  endif
  if downkey()
    pitch camera down 90.0
    move camera 1
    point camera 0,0,0
  endif
return
move_paddle:
  xmove=mousemovex()
  ymove=mousemovey()
  swing=mouseclick()
  paddlex#=paddlex#-xmove
  paddley#=paddley#-ymove
  if paddlex#<-border# or paddlex#>border# then paddlex#=paddlex#+xmove
  if paddley#<-border# or paddley#>border# then paddley#=paddley#+ymove
  if swing>0 and swinging=0 then swinging=1
  if swinging=1
    paddle_swing#=paddle_swing#+3.0
    if paddle_swing#>30.0
      paddle_swing#=30.0
      if swing=0 then swinging=2
    endif
  endif
  if swinging=2
    paddle_swing#=paddle_swing#-3.0
    if paddle_swing#<0 then swinging=0:paddle_swing#=0.0
  endif
  yrotate object paddle,180+paddle_swing#
  position object paddle,paddlex#,paddley#,paddlez#
  if ballz#>0
    pad2xv#=pad2xv#-(pad2x#-50.0)/100.0
    if abs(pad2xv#)>pad2xm# then pad2xv#=pad2xv#+(pad2x#-50.0)/100.0
    pad2yv#=pad2yv#-(pad2y#-50.0)/100.0
    if abs(pad2yv#)>pad2ym# then pad2yv#=pad2yv#+(pad2y#-50.0)/100.0
  endif
  if ballz#<0
    pad2xv#=pad2xv#-(pad2x#-ballx#)/50.0
    if abs(pad2xv#)>pad2xm# then pad2xv#=sgn(pad2xv#)*pad2xm#
    pad2yv#=pad2yv#-(pad2y#-bally#)/50.0
    if abs(pad2yv#)>pad2ym# then pad2yv#=sgn(pad2yv#)*pad2ym#
  endif
  pad2x#=pad2x#+pad2xv#
  if pad2y#>400.0 then pad2y#=400.0
  pad2y#=pad2y#+pad2yv#
  if pad2y#<0.0 then pad2y#=0.0
  position object paddle2,pad2x#,pad2y#,pad2z#
  if ballhit(1)>1 or ballhit(2)>1 or (ballhit(1)=1 and ballhit(2)=1)
    gosub ball_stop
  endif
return
net:
  if bally#<table_height+50
    ballzv#=sgn(ballz#)*2.0
    ballyv#=0.0
  endif
return
return
player:
loc=sqrt((paddlex#-ballx#)^2+(paddley#-bally#)^2)
if loc<=50
  ballzv#=-ballzv#*friction#
  if swinging>0
    ballzv#=ballzv#*(1.0+paddle_swing#/60.0)
    ballyv#=ballyv#+1.0-ymove/100.0
    if ballyv#<0.0 then balyv#=1.0
    ballxv#=ballxv#-xmove/2.0
  endif
  ballz#=ballz#+ballzv#
  make_play=2
  ballhit(1)=0:ballhit(2)=0
endif
return
computer:
loc=sqrt((pad2x#-ballx#)^2+(pad2y#-bally#)^2)
if loc<=100
  ballzv#=-ballzv#*friction#
  ballzv#=ballzv#*(1.0+paddle_swing#/60.0)
  ballyv#=ballyv#+1.0
  if ballyv#<0.0 then ballyv#=1.0
  ballxv#=-sgn(ballx#)
  ballz#=ballz#+ballzv#
  make_play=1
  ballhit(1)=0:ballhit(2)=0
endif
return
return
ball_stop:
  if ballhit(make_play)>0 and ballhit(3-make_play)=0
    inc score(make_play)
  else
    inc score(3-make_play)
  endif
  play=0
  ballx#=50.0
  bally#=50.0
  ballz#=-600.0
  ballhit(1)=0
  ballhit(2)=0
  hide object ball
  gosub update_score
return
ball_serve:
  if servedir=1
    ballx#=pad2x#
    bally#=pad2y#
    ballz#=-600.0
    ballxv#=-sgn(pad2x#)
    ballyv#=3.0
    ballzv#=8.0
    make_play=1
  else
    ballx#=paddlex#
    bally#=paddley#
    ballz#=600.0
    ballxv#=-sgn(paddlex#)
    ballyv#=3.0
    ballzv#=-8.0
    make_play=2
  endif
  show object ball
  servedir=3-servedir
return
make_ball:
create bitmap 1,20,20
ink rgb(255,255,255),0
box 0,0,20,20
ink rgb(128,128,128),0
for x=0 to 20 step 2
  for y=0 to 20 step 2
    dot x,y
  next y
next x
get image ball_texture,0,0,20,20
delete bitmap 1
make object sphere ball,20
texture object ball,ball_texture
set shadow shading on ball
position object ball,0,0,2000
return
make_paddle:
create bitmap 1,200,200
ink 0,0
line 0,0,200,200
ink rgb(0,0,255),0
for x=1 to 98
  circle 100,100,x
next x
get image paddle_texture,0,0,200,200
delete bitmap 1
set current bitmap 0
make object plain paddle,100,100
texture object paddle,1
set object transparency paddle,1
make object cylinder paddle+1,100
scale object paddle+1,100,5,100
xrotate object paddle+1,90.0
make mesh from object paddle_rim,paddle+1
delete object paddle+1
add limb paddle,1,paddle_rim
color limb paddle,paddle_rim,rgb(0,0,255)
texture limb paddle,paddle_rim,paddle_texture
offset limb paddle,paddle_rim,0,0,2.5
make object box paddle+1,40,15,8
zrotate object paddle+1,-45.0
make mesh from object paddle+1,paddle_handle
delete object paddle+1
add limb paddle,2,paddle_handle
color limb paddle,paddle_handle,rgb(64,64,64)
offset limb paddle,paddle_handle,45.0,-45.0,2.5
ghost object on paddle
fade object paddle,150
return
make_table:
create bitmap 1,400,600
ink rgb(0,255,0),0
box 0,0,400,600
ink rgb(255,255,255),0
box 5,5,390,10
box 5,5,10,595
box 390,5,395,595
box 5,590,395,595
box 198,5,202,595
get image table_texture,0,0,400,600
delete bitmap 1
set current bitmap 0
make object box table,800,10,1200
texture object table,table_texture
return
make_net:
create bitmap 1,800,50
ink 0,0
box 0,0,800,50
ink rgb(128,128,128),0
for x=-50 to 850 step 8
  line x,0,x+50,50
  line x,50,x+50,0
next x
line 0,0,800,0
get image net_texture,0,0,800,50
delete bitmap 1
make object plain net,800,50
texture object net,net_texture
set object transparency net,1
make object cylinder net+1,50
scale object net+1,10,100,10
make mesh from object net_post,net+1
delete object net+1
add limb net,1,net_post
offset limb net,1,-400,0,0
color limb net,1,rgb(128,255,255)
add limb net,2,net_post
offset limb net,2,400,0,0
color limb net,2,rgb(128,255,255)
return
make_scoreboard:
make object plain score_comp,100,100
make object plain score_player,100,100
ink rgb(0,255,255),0
create bitmap score1,100,100
box 0,0,100,100
get image score1,0,0,100,100
create bitmap score2,100,100
box 0,0,100,100
get image score2,0,0,100,100
set current bitmap 0
texture object score_comp,score1
texture object score_player,score2
return
function sgn(x#)
  if x#<0 then value=-1
  if x#>0 then value=1
  if x#=0 then value=0
endfunction value

`   'Aargh - not another Pong Clone!' by Ric.

if check display mode(1024,768,32)=1 then set display mode 1024,768,32
hide mouse
sync on
sync rate 60
autocam off
hide light 0
color backdrop rgb(0,0,0)
set ambient light 80
make light 1
position light 1,100,100,20
set light range 1,100000
color light 1,rgb(255,220,180)

fog on
fog color 0
fog distance 1000

`create green texture
for x=0 to 100
   for y=0 to 100
      ink rgb(0,x+y,0),0
      dot x,y
   next y
next x
get image 103,0,0,100,100

cls

`create purple texture
for x=0 to 100
   for y=0 to 100
      ink rgb(x+y,0,x+y),0
      dot x,y
   next y
next x
get image 102,0,0,100,100

cls

`create blue texture
for x=0 to 100
   for y=0 to 100
      ink rgb(0,0,x+y),0
      dot x,y
   next y
next x
get image 101,0,0,100,100

`create star texture
for x=0 to 100
for y=0 to 100
d=rnd(20)
ink rgb(100+rnd(100),100+rnd(100),rnd(100)+100),0
if d=1 then dot x,y
next y
next x
get image 1,0,0,100,100

`create tile texture
cls
ink rgb(0,0,255),0
box 0,0,10,10
box 10,10,20,20
get image 2,0,0,20,20

set text font "sf automaton_mod"
set text size 25

`create starsphere
make object sphere 1000,-1000,50,50
texture object 1000,1
scale object texture 1000,5,5
xrotate object 1000,-90

`player paddle
make object sphere 1,20,20,20
scale object 1,100,400,100
ghost object on 1
texture object 1,102
set object emissive 1,rgb(200,200,200)
set object specular 1,rgb(250,250,250)
set object specular power 1,10
set object fog 1,0
set object collision on 1
set object collision to boxes 1


`reflection of player paddle
clone object 302,1 `top
scale object 302,100,400,100
fade object 302,90
clone object 303,1 `bottom
scale object 303,100,400,100
fade object 303,90

`computer paddle
make object sphere 2,20,20,20
scale object 2,100,400,100
ghost object on 2
texture object 2,103
set object emissive 2,rgb(200,200,200)
set object specular 2,rgb(250,250,250)
set object specular power 2,10
set object fog 2,0
set object collision on 2
set object collision to boxes 2

`reflection of computer paddle
clone object 304,2 `top
scale object 304,100,400,100
fade object 304,90
clone object 305,2 `bottom
scale object 305,100,400,100
fade object 305,90

`ball
make object sphere 3,20,40,40
texture object 3,101
set object specular 3,rgb(200,200,200)
set object specular power 3,15
set object emissive 3,rgb(150,150,100)
set object ambient 3,0
set object collision on 3
set object fog 3,0

`reflection of ball
clone object 300,3 `top reflection
fade object 300,50
clone object 301,3 `bottom reflection
fade object 301,50

`bottom wall
make object plain 4,500,800
xrotate object 4,90
set object collision on 4
texture object 4,2
scale object texture 4,5,5
set object transparency 4,1

`top wall
make object plain 5,500,800
xrotate object 5,90
set object collision on 5
texture object 5,2
scale object texture 5,5,5
set object transparency 5,1

`back wall
make object plain 6,500,100
texture object 6,101
scale object texture 6,2,10
set object texture 6,2,0
set object transparency 6,1
set object fog 6,0
ghost object on 6

`position walls
position object 4,0,-150,100
position object 5,0,150,100
position object 6,0,0,300

`restart point for new game (the goto command is not dead yet!)
newgame:

for object=300 to 305
hide object object
next object

`zoom in
paddlex#=0
position object 1,-paddlex#,0,0
position object 2,paddlex#,0,0
position object 3,0,0,0


`zrotate camera 0
camz#=-2000.0
position camera 0,0,0,camz#
while camz#<-500.0
inc camz#,5
position camera 0,0,camz#
sync
endwhile
position camera 0,0,0,-500

`set paddle positions

while paddlex#<180
inc paddlex#
position object 1,-paddlex#,0,0
position object 2,paddlex#,0,0
sync
endwhile



`do
`text screen width()/2-100,200,"Gravity on? (y/n)"
`if inkey$()="y" then gravity=1:exit
`if inkey$()="n" then gravity=0:exit
`sync
`loop

gravity=1

text screen width()/2-70,240,"GET READY!"
sync
wait 600

for object=300 to 305
show object object
next object

`set initial variables
level=1
pscore=0
cscore=0
pv#=10 `player paddle velocity
bvx#=10 `ball velocity
if gravity=1
cv#=3.5 `computer paddle velocity
g#=0.5
else
cv#=2
g#=0
endif

`restart point for new serve or new level
restart:
randomize timer()
wait 800
py#=-10+rnd(20) `player's initial y position
cy#=-10+rnd(20)           `computer's initial y position
bx#=0           `ball x
by#=0           `ball y
bvy#=1.5+rnd(10)/10          `ball direction (in degrees:- horizontal=0)
bvx#=abs(bvx#)
`main loop

do

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

`player input
remstart
if upkey()>0 and object collision (1,5)=0
   py#=py#+pv#
endif

if downkey()>0 and object collision (1,4)=0
   py#=py#-pv#
endif
remend


py#=py#-mousemovey()
if py#>110 then py#=110
if py#<-110 then py#=-110

`move player paddle
position object 1,-180,py#,100
position object 302,-180,-py#-300,100
position object 303,-180,-py#+300,100
`position object 401,-180,py#,100

`ball motion
bvy#=bvy#+g#
bx#=bx#+bvx#
by#=by#-bvy#

`collision with court
if by#>140
by#=by#-10
bvy#=bvy#*-1
endif

if by#<-140
by#=by#+10
bvy#=bvy#*-1
endif

`collision with player paddle
if object collision (3,1)=1
  bvx#=bvx#*-1 `reverse velocity
  bx#=-150 `prevent embedding
`measure offset between player paddle and ball and adjust direction
    po#=by#-py#
    bvy#=bvy#-po#*0.2
endif

`and same for computer paddle.....
if object collision (3,2)=1
  bvx#=bvx#*-1
  bx#=150
    co#=by#-cy#
    bvy#=bvy#-co#*0.2
endif

if bvy#>15.0 then bvy#=15.0
if bvy#<-15.0 then bvy#=-15.0

`new ball position
position object 3,bx#,by#,100
position object 300,bx#,-by#+300,100
position object 301,bx#,-by#-300,100

`computer paddle A.I.

`return to middle
if bvx#<0
  if cy#>2 then a#=-cv#
  if cy#<2 then a#=cv#
  if cy#<=2 and cy#>=-2 then a#=0
  cy#=cy#+a#
endif

`move towards ball
if bvx#>0
  if by#>cy# then a#=cv#
  if by#<cy# then a#=-cv#
  cy#=cy#+a#
endif

position object 2,180,cy#,100
position object 304,180,-cy#+300,100
position object 305,180,-cy#-300,100

`win or lose
if object position x(3) < -250
   cscore=cscore+1
   vb#=vb#*-1
   goto restart
endif

if object position x(3) > 250
  pscore = pscore +1
  goto restart
endif

`print score
text screen width()/2-20,screen height()/2-12,str$(pscore)+" : "+str$(cscore)

`goto next level, increase difficulty and reset scores
if pscore>2
   bv#=bv#+1
   pv#=pv#+0.3
   cv#=cv#+0.5
   level=level+1
   pscore=0
   cscore=0
   goto restart
endif

`display level
text screen width()/2-40,screen height()/2-100,"Level "+str$(level)


`game over text
if cscore>2
set text font "impact"
ink rgb(0,200,0),0
text screen width()/2-50,screen height()/2+200,"Game Over"
text screen width()/2-80,screen height()/2+250,"You reached level "+str$(level)
text screen width()/2-100,screen height()/2+280,"Press any key to restart"
sync
wait key
set text font "sf automaton_mod"
ink rgb(0,0,255),0
goto newgame
endif

if inkey$()="q" then goto restart

if level>0
  `scroll textures
  scroll object texture 1000,0,-0.014
  scroll object texture 4,0,0.08
  scroll object texture 5,0,0.08

  if clockwise=1 then zrotate camera camera angle z()+0.1
  if clockwise=0 then zrotate camera camera angle z()-0.1

  if camera angle z()>20.0 then clockwise=0
  if camera angle z()<-20.0 then clockwise=1

else

 `scroll textures
  scroll object texture 1000,0,-0.004
  scroll object texture 4,0,0.004
  scroll object texture 5,0,0.004

endif

sync
loop

sync on
fastsync
autocam off
hide mouse
color backdrop rgb(0,0,0)
position camera 0,0,-30


Dline(7,-7.5,0,-2,-7.5,-3,-2,rgb(0,255,0))
Dline(18,-7.5,-3,-2,-4.5,0,-2,rgb(0,255,0))

Dline(13,-3.5,-1.5,-2,-2.5,-1.5,-2,rgb(0,255,0))

Dline(2,-1.5,3,-2,-1.5,-3,-2,rgb(0,255,0))
Dline(9,-1.5,-3,-2,0.5,-3,-2,rgb(0,255,0))
Dline(15,0.5,-3,-2,1.5,-2,-2,rgb(0,255,0))
Dline(4,1.5,-2,-2,1.5,0,-2,rgb(0,255,0))
Dline(11,1.5,0,-2,-0.5,0,-2,rgb(0,255,0))
Dline(17,-0.5,0,-2,-1.5,-1,-2,rgb(0,255,0))

Dline(10,2.5,0,-2,5.5,0,-2,rgb(0,255,0))
Dline(3,5.5,0,-2,5.5,-3,-2,rgb(0,255,0))
Dline(12,5.5,-1,-2,3.5,-1,-2,rgb(0,255,0))
Dline(16,3.5,-1,-2,2.5,-2,-2,rgb(0,255,0))
Dline(5,2.5,-2,-2,2.5,-3,-2,rgb(0,255,0))
Dline(8,2.5,-3,-2,4.5,-3,-2,rgb(0,255,0))
Dline(14,4.5,-3,-2,5.5,-2,-2,rgb(0,255,0))

Dline(6,6.5,3,-2,6.5,-3,-2,rgb(0,255,0))

Dline(1,7.5,3,-2,7.5,-3,-2,rgb(0,255,0))

`1-7 |
`8-13 -
`14-18 /

lasttime=timer()
introtime#=0

for count=1 to 3
position object count,0,30,0
next count
for count=4 to 7
position object count,0,-30,0
next count
for count=8 to 10
position object count,-30,0,0
next count
for count=11 to 13
position object count,30,0,0
next count
for count=14 to 16
position object count,21.21,21.21,0
next count
for count=17 to 18
position object count,21.21,21.21,0 `20.5
next count

while introtime#<4
t=timer()
time#=(t-lasttime)/1000.0
lasttime=t
introtime#=introtime#+time#

if introtime#<0.5
  t#=introtime#*2
  for count=1 to 3
    position object count,0,30-(29.5*t#),0
  next count  
  for count=4 to 7
    position object count,0,-30+(29.5*t#),0
  next count
  for count=8 to 10
    position object count,30-(29.5*t#),0,0
  next count  
  for count=11 to 13
    position object count,-30+(29.5*t#),0,0
  next count  
  for count=14 to 16
    position object count,21.21-(20.86*t#),21.21-(20.86*t#),0
  next count  
  for count=17 to 18
    position object count,-21.21+(20.86*t#),-21.21+(20.86*t#),0
  next count 
else
  if introtime#<2.5
    t#=(introtime#-0.5)/2
    for count=1 to 3
      position object count,0,0.5-(t#),0
    next count  
    for count=4 to 7
      position object count,0,-0.5+(t#),0
    next count
    for count=8 to 10
      position object count,0.5-(t#),0,0
    next count  
    for count=11 to 13
      position object count,-0.5+(t#),0,0
    next count
    for count=14 to 16
      position object count,0.35-(0.7*t#),0.35-(0.7*t#),0
    next count  
    for count=17 to 18
      position object count,-0.35+(0.7*t#),-0.35+(0.7*t#),0
    next count
  else
    if introtime#<3
      t#=(introtime#-2.5)*2
      for count=1 to 3
        position object count,0,-0.5-(29.5*t#),0
      next count  
      for count=4 to 7
        position object count,0,0.5+(29.5*t#),0
      next count  
      for count=8 to 10
        position object count,-0.5-(29.5*t#),0,0
      next count  
      for count=11 to 13
        position object count,0.5+(29.5*t#),0,0
      next count  
      for count=14 to 16
        position object count,-0.35-(20.86*t#),-0.35-(20.86*t#),0
      next count  
      for count=17 to 18
        position object count,0.35+(20.86*t#),0.35+(20.86*t#),0
      next count 
    endif 
  endif
endif
sync
endwhile

for count=1 to 18
  delete object count
next count


global dim sparkobj(0)
global dim sparkx#(0)
global dim sparky#(0)
global dim sparkz#(0)
global dim sparkangx#(0)
global dim sparkangy#(0)
global dim sparkangz#(0)
global dim sparkmag#(0)

points_per_round=3

p1s=0
p2s=0

p1x#=0
p1y#=0
p1velx#=0
p1vely#=0

p2x#=0
p2y#=0
p2velx#=0
p2vely#=0

bx#=0
by#=0
bz#=15
bcx#=0
bcy#=0

bvelx#=0
bvely#=0
bvelz#=0
brad#=2

curvex#=0
curvey#=0
curving=0
curvelength#=0

powering=0
powerlength#=0

zonethreshhold#=10

scoretime#=-2.5
level=1


remstart
1-15 p1
16-30 p2
31-34 area
43-44 ball
50-58 roundscore
remend

ink rgb(90,255,90),rgb(0,0,0)
make object plain 43,1,1
make object plain 44,1,1
hide object 43
hide object 44


Dline(1,-4,4,0,4,4,0,rgb(0,255,0))
Dline(2,4,4,0,5,3,0,rgb(0,255,0))
Dline(3,5,3,0,5,-3,0,rgb(0,255,0))
Dline(4,5,-3,0,4,-4,0,rgb(0,255,0))
Dline(5,4,-4,0,-4,-4,0,rgb(0,255,0))
Dline(6,-4,-4,0,-5,-3,0,rgb(0,255,0))
Dline(7,-5,-3,0,-5,3,0,rgb(0,255,0))
Dline(8,-5,3,0,-4,4,0,rgb(0,255,0))

Dline(16,-4,4,0,4,4,0,rgb(0,255,0))
Dline(17,4,4,0,5,3,0,rgb(0,255,0))
Dline(18,5,3,0,5,-3,0,rgb(0,255,0))
Dline(19,5,-3,0,4,-4,0,rgb(0,255,0))
Dline(20,4,-4,0,-4,-4,0,rgb(0,255,0))
Dline(21,-4,-4,0,-5,-3,0,rgb(0,255,0))
Dline(22,-5,-3,0,-5,3,0,rgb(0,255,0))
Dline(23,-5,3,0,-4,4,0,rgb(0,255,0))

Dline(31,-17,12,0,-17,12,30,rgb(0,255,0))
Dline(32,17,12,0,17,12,30,rgb(0,255,0))
Dline(33,-17,-12,0,-17,-12,30,rgb(0,255,0))
Dline(34,17,-12,0,17,-12,30,rgb(0,255,0))

Dline(35,-17,12,0,17,12,0,rgb(0,255,0))
Dline(36,17,12,0,17,-12,0,rgb(0,255,0))
Dline(37,17,-12,0,-17,-12,0,rgb(0,255,0))
Dline(38,-17,-12,0,-17,12,0,rgb(0,255,0))

Dline(39,-17,12,30,17,12,30,rgb(0,255,0))
Dline(40,17,12,30,17,-12,30,rgb(0,255,0))
Dline(41,17,-12,30,-17,-12,30,rgb(0,255,0))
Dline(42,-17,-12,30,-17,12,30,rgb(0,255,0))

for count=0 to 1
offset=count*7
  Dline(50+offset,-2.5,5,0,3.5,5,0,rgb(0,255,0))
  Dline(51+offset,-3,0,0,3,0,0,rgb(0,255,0))
  Dline(52+offset,-3.5,-5,0,2.5,-5,0,rgb(0,255,0))
  Dline(53+offset,-3,0,0,-2.5,5,0,rgb(0,255,0))
  Dline(54+offset,3,0,0,3.5,5,0,rgb(0,255,0))
  Dline(55+offset,-3.5,-5,0,-3,0,0,rgb(0,255,0))
  Dline(56+offset,2.5,-5,0,3,0,0,rgb(0,255,0))
next count

for count=50 to 56
  position object count,-9,0,15
  scale object count,100,0.1,100
  hide object count
next count

for count=57 to 63
  position object count,9,0,15
  scale object count,100,0.1,100
  hide object count
next count

Dline(47,0,0,0,0,0,-1,rgb(0,255,0))
Dline(48,0,0,0,0,0,-1,rgb(0,0,255))
Dline(49,0,0,0,0,0,-1,rgb(255,0,0))
hide object 47
hide object 48
hide object 49

lasttime=timer()

do

ink rgb(90,255,90),rgb(0,0,0)
    lmb=0
    mmb=0
    rmb=0

    mv=mouseclick()
    if int(mv/8)=1
    mv=mv-8
    endif
   if int(mv/4)=1
    mv=mv-4
    mmb=1
   endif
   if int(mv/2)=1
    mv=mv-2
    rmb=1
    endif
   if mv=1
    lmb=1
    endif



t=timer()
time#=(t-lasttime)/1000.0
lasttime=t
if scoretime#>=0
  if (balltime#<1)
  balltime#=balltime#+time#
    if balltime#<0
      if balltime#<-0.2
        if balltime#<-0.4
          if balltime#<-1.6
            if balltime#<-1.8
              if balltime#>-2
                if balltime#-time#<-2
                  showdigits(50,oldp2s)
                  showdigits(57,oldp1s)
                endif
                for count=50 to 63
                  scale object count,100+(((0.2-(balltime#+2.0)))*500),0,100
                next count
              endif
            else
              for count=50 to 63
                scale object count,100,(balltime#+1.8)*500,100
              next count
            endif
          else
            if oldp1s=points_per_round 
              if balltime#-time#<-1.6 
                p1s=0
                p2s=0
              endif
              if int(-balltime#*10)-(int(int(-balltime#*10)/2)*2)=0
                if (int(-(balltime#-time#)*10)-(int(int(-(balltime#-time#)*10)/2)*2))<>0
                  for count=57 to 63
                    hide object count
                  next count  
                endif
              else
                if (int(-(balltime#-time#)*10)-(int(int(-(balltime#-time#)*10)/2)*2))=0
                  showdigits(57,points_per_round)
                endif
              endif
            else
            if balltime#-time#<-1.6
              for count=50 to 63
                scale object count,100,100,100
              next count
            endif
              if oldp2s=points_per_round
                if balltime#-time#<-1.6
                  p1s=0
                  p2s=0
                  
                endif
                if (int(-balltime#*10)-(int(int(-balltime#*10)/2)*2))=0
                  if (int(-(balltime#-time#)*10)-(int(int(-(balltime#-time#)*10)/2)*2))<>0
                    for count=50 to 56
                      hide object count
                    next count  
                  endif
                else
                  if (int(-(balltime#-time#)*10)-(int(int(-(balltime#-time#)*10)/2)*2))=0
                    showdigits(50,points_per_round)
                  endif
                endif
              endif 
            endif         
          endif
        else
          if balltime#-time#<0.4
            showdigits(57,oldp1s)
            showdigits(50,oldp2s)
          endif
          for count=50 to 63
            scale object count,100,(0.2-(balltime#+0.4))*500,100
          next count      
        endif
      else
        for count=50 to 63
          scale object count,100+(((balltime#+0.2))*500),0,100
        next count     
      endif
    else
      if balltime#-time#<0
        if oldp1s=points_per_round
          scoretime#=-2.5
          level=level+1
        endif
        if oldp2s=points_per_round
          scoretime#=-2.5
          if level>1 then level=level-1
        endif        
        for count=50 to 63
          hide object count
        next count 
        
      endif    
    endif
     if balltime#>1
          select rnd(1)
            case 0: bvelz#=20 : endcase
            case 1: bvelz#=-20 : endcase
          endselect
     endif
  endif
else
scoretime#=scoretime#+time#
  if scoretime#<0
      if scoretime#<-0.2
        if scoretime#<-0.4
          if scoretime#<-1.6
            if scoretime#<-1.8
              if scoretime#>-2
                if scoretime#-time#<-2
                  showdigits(50,0)
                  showdigits(57,0)
                  for count=50 to 56
                    position object count,-5,0,15
                  next count

                  for count=57 to 63
                    position object count,5,0,15
                  next count
                  
                endif
                for count=50 to 63
                  scale object count,100+(((0.2-(scoretime#+2.0)))*500),0,100
                next count
              endif
            else
              for count=50 to 63
                scale object count,100,(scoretime#+1.8)*500,100
              next count
            endif
          else
          i=(scoretime#+1.6)*((level*2.5)/1.2)
          if i>level then i=level
          `print i
          if i<10
            digita=0
          else
            digita=int(i/10)
          endif
          
          digitb=i-(int(i/10)*10)
          
          showdigits(50,digita)
          showdigits(57,digitb)
    
          endif
        else
          for count=50 to 63
            scale object count,100,(0.2-(scoretime#+0.4))*500,100
          next count      
        endif
      else
        for count=50 to 63
          scale object count,100+(((scoretime#+0.2))*500),0,100
        next count     
      endif
  else  
    for count=50 to 63
      hide object count      
    next count  
      for count=50 to 56
        position object count,-9,0,15
      next count
      for count=57 to 63
        position object count,9,0,15
      next count
  endif
endif
p1velx#=p1x#
p1vely#=p1y#
p2velx#=p2x#
p2vely#=p2y#


p1x#=p1x#+(mousemovex()/15.0)
if p1x#>12 then p1x#=12
if p1x#<-12 then p1x#=-12
p1y#=p1y#-(mousemovey()/15.0)
if p1y#>8 then p1y#=8
if p1y#<-8 then p1y#=-8

if bx#>p2x# 
  p2x#=p2x#+((6.0*time#)*level*0.75)
  if bx#<p2x# then p2x#=bx#
endif
if bx#<p2x# 
  p2x#=p2x#-((6.0*time#)*level*0.75)
  if bx#>p2x# then p2x#=bx#
endif
if by#>p2y#
  p2y#=p2y#+((6.0*time#)*level*0.75)
  if by#<p2y# then p2y#=by#
endif
if by#<p2y#
  p2y#=p2y#-((6.0*time#)*level*0.75)
  if by#>p2y# then p2y#=by#
endif

if p2x#>12 then p2x#=12
if p2x#<-12 then p2x#=-12
if p2y#>8 then p2y#=8
if p2y#<-8 then p2y#=-8

for count=1 to 8
position object count,p1x#,p1y#,0
next count

for count=16 to 23
position object count,p2x#,p2y#,30
next count

p1velx#=(p1x#-p1velx#)*(1.0/time#)
p1vely#=(p1y#-p1vely#)*(1.0/time#)
p2velx#=(p2x#-p2velx#)*(1.0/time#)
p2vely#=(p2y#-p2vely#)*(1.0/time#)

bvelx#=bvelx#+bcx#
bvely#=bvely#+bcy#
bx#=bx#+(bvelx#*time#)
by#=by#+(bvely#*time#)
bz#=bz#+(bvelz#*time#)

if powered=1
    bx#=bx#+(((bvelx#*2)*powerlength#)*time#)
    by#=by#+(((bvely#*2)*powerlength#)*time#)
    bz#=bz#+(((bvelz#*2)*powerlength#)*time#)
endif

if by#>12-brad#
    by#=(12-brad#)-(by#-(12-brad#))
    createsparks(20,bx#,12,bz#,0,360,0,0,360,0,1,20)
    bvely#=-bvely#
endif

if by#<(-12)+brad#
    by#=(brad#-12)+(by#-(brad#-12))
    createsparks(20,bx#,-12,bz#,0,360,0,0,360,0,1,20)
    bvely#=-bvely#
endif

if bx#>17-brad#
    bx#=(17-brad#)-(bx#-(17-brad#))
    createsparks(20,17,by#,bz#,0,360,0,0,360,0,1,20)
    bvelx#=-bvelx#
endif

if bx#<(-17)+brad#
    bx#=(brad#-17)+(bx#-(brad#-17))
    createsparks(20,-17,by#,bz#,0,360,0,0,360,0,1,20)
    bvelx#=-bvelx#
endif



if bz#<brad#
    if ((bx#<p1x#+5.0) AND (bx#>p1x#-5.0)) AND ((by#<p1y#+4.0) AND (by#>p1y#-4.0))

        powered=0
        bz#=brad#+(brad#-bz#)
        bvelz#=-bvelz#
        bvelx#=bvelx#+(p1velx#*0.4)
        bvely#=bvely#+(p1vely#*0.4)
        if (curving=0) AND (powering=0) then createsparks(70,bx#,by#,0,-90,90,0,0,360,0,1,20)
        if curving=1
 
            createsparks(70,bx#,by#,0,-90,90,0,0,360,0,2,20)
            record#= int(curvelength#*100)
            bcx#=-((p1velx#*0.05)*curvelength#)
            bcy#=-((p1vely#*0.05)*curvelength#)
            curved=1
        endif
        if powering=1

            createsparks(70,bx#,by#,0,-90,90,0,0,360,0,3,20)
            record#= int(powerlength#*100)
            powered=1
        endif


        curving=0
        powering=0
        curvex#=0
        curvey#=0
    else
          p2s=p2s+1
          oldp2s=p2s
          oldp1s=p1s
        createsparks(200,bx#,by#,bz#,0,360,0,0,360,0,1,30)
        bx#=0
        by#=0
        bz#=15
        bcx#=0
        bcy#=0
        curving=0
        powering=0
        curvex#=0
        curvey#=0
        bvelx#=0
        bvely#=0
        bvelz#=0
        balltime#=-3.5
    endif
endif

if bz#>30-brad#
 
    if ((bx#<p2x#+5.0) AND (bx#>p2x#-5.0)) AND ((by#<p2y#+4.0) AND (by#>p2y#-4.0))
        createsparks(70,bx#,by#,30,90,180,0,0,360,0,1,20)
        powered=0
        curved=0
        bz#=(30-brad#)-(bz#-(30-brad#))
        bvelz#=-bvelz#
        bvelx#=bvelx#+(p2velx#*0.4)
        bvely#=bvely#+(p2vely#*0.4)
        bcx#=0
        bcy#=0
    else
          p1s=p1s+1
          oldp2s=p2s
          oldp1s=p1s
        createsparks(200,bx#,by#,bz#,0,360,0,0,360,0,1,30)
        bx#=0
        by#=0
        bz#=15
        bcx#=0
        bcy#=0
        curving=0
        powering=0
        curvex#=0
        curvey#=0
        bvelx#=0
        bvely#=0
        bvelz#=0
        balltime#=-3.5
    endif
endif

zone=0
if (bz#-brad#<zonethreshhold#)  AND (bvelz#<0)
    zone=1
    if curving=0 then curvelength#=(bz#-brad#)/zonethreshhold#
    if powering=0 then powerlength#=(bz#-brad#)/zonethreshhold#
else
    curvelength#=0
endif

if curving=1
curvex#=curvex#+p1velx#
curvey#=curvey#+p1vely#
endif

if rmb=1
    if ((rightclick=0) AND (zone=1)) AND (powering=0)
        curving=1
        curvex#=0
        curvey#=0
    endif
    rightclick=1
else
    rightclick=0
endif

if lmb=1
    if ((leftclick=0) AND (zone=1)) AND (curving=0)
        powering=1
    endif
    leftclick=1
else
    leftclick=0
endif




if (balltime#>=0) AND (scoretime#>=0)
  if balltime#<1
    position object 43,bx#,by#,bz#
    position object 44,bx#,by#+brad#,bz#
    bsy=object screen y(44)
    ink rgb(balltime#*90,balltime#*255,balltime#*90),rgb(0,0,0)
    circle object screen x(43),object screen y(43),object screen y(43)-bsy
  else 
    position object 43,bx#,by#,bz#
    position object 44,bx#,by#+brad#,bz#
    bsy=object screen y(44)
    ink rgb(90,255,90),rgb(0,0,0)
    circle object screen x(43),object screen y(43),object screen y(43)-bsy
    endif  
endif
ink rgb(90,255,90),rgb(0,0,0)
position object 44,bx#+brad#,by#-brad#,bz#
bsx=object screen x(44)
bsh=object screen y(44)-bsy

position object 44,p1x#+4,p1y#+3,0
hudx=object screen x(44)
hudy=object screen y(44)
position object 44,p1x#+5,p1y#-3,0
hudw=object screen x(44)-hudx
hudh=object screen y(44)-hudy

position object 44,p1x#-4,p1y#+3,0
hudx2=object screen x(44)
hudy2=object screen y(44)
position object 44,p1x#-5,p1y#-3,0
hudw2=hudx2-object screen x(44)
hudh2=object screen y(44)-hudy2

updatesparks(time#,0.5)

sync

line (hudx+hudw)-2,hudy+((hudh/(30.0-(brad#*2)))*(bz#-brad#)),(hudx+hudw)-2,hudy+hudh
line (hudx+hudw)-2,hudy+((hudh/(30.0-(brad#*2)))*(bz#-brad#)),(hudx+hudw)-5,(hudy-3)+(((hudh+6)/(30.0-(brad#*2)))*(bz#-brad#))
line (hudx+hudw)-5,(hudy-3)+(((hudh+6)/(30.0-(brad#*2)))*(bz#-brad#)),(hudx+hudw)-5,hudy+hudh+3
line (hudx+hudw)-2,hudy+hudh,(hudx+hudw)-5,hudy+hudh+3

line (hudx2-hudw2)+2,hudy2+((hudh2/(30.0-(brad#*2)))*(bz#-brad#)),(hudx2-hudw2)+2,hudy2+hudh2
line (hudx2-hudw2)+2,hudy2+((hudh2/(30.0-(brad#*2)))*(bz#-brad#)),(hudx2-hudw2)+5,(hudy2-3)+(((hudh2+6)/(30.0-(brad#*2)))*(bz#-brad#))
line (hudx2-hudw2)+5,(hudy2-3)+(((hudh2+6)/(30.0-(brad#*2)))*(bz#-brad#)),(hudx2-hudw2)+5,hudy2+hudh2+3
line (hudx2-hudw2)+2,hudy2+hudh2,(hudx2-hudw2)+5,hudy2+hudh2+3

if zone=1
    y1=(hudy-5)+(((hudh+10)/(30.0-(brad#*2)))*(bz#-brad#))
    y2=((hudy)-(hudw-3))+(((hudh+((hudw-3)*2))/(30.0-(brad#*2)))*(bz#-brad#))
    y3=(hudy-5)+(((hudh+10)/(30.0-(brad#*2)))*((bz#+2.5)-brad#))
    y4=((hudy)-(hudw-3))+(((hudh+((hudw-3)*2))/(30.0-(brad#*2)))*((bz#+2.5)-brad#))

    y21=(hudy2-5)+(((hudh2+10)/(30.0-(brad#*2)))*(bz#-brad#))
    y22=((hudy2)-(hudw2-3))+(((hudh2+((hudw2-3)*2))/(30.0-(brad#*2)))*(bz#-brad#))
    y23=(hudy2-5)+(((hudh2+10)/(30.0-(brad#*2)))*((bz#+2.5)-brad#))
    y24=((hudy2)-(hudw2-3))+(((hudh2+((hudw2-3)*2))/(30.0-(brad#*2)))*((bz#+2.5)-brad#))

    if curving=1
        length#=zonethreshhold#-(zonethreshhold#*curvelength#)
        ink rgb(90,90,255),rgb(0,0,0)
    else
        length#=zonethreshhold#-(bz#-brad#)
    endif

    line (hudx+hudw)-7,(hudy-5)+(((hudh+10)/(zonethreshhold#))*(length#)),(hudx+hudw)-7,hudy+hudh+5
    line (hudx+hudw)-7,(hudy-5)+(((hudh+10)/(zonethreshhold#))*(length#)),(hudx+hudw)-10,(hudy-8)+(((hudh+16)/(zonethreshhold#))*(length#))
    line (hudx+hudw)-10,(hudy-8)+(((hudh+16)/(zonethreshhold#))*(length#)),(hudx+hudw)-10,hudy+hudh+8
    line (hudx+hudw)-7,hudy+hudh+5,(hudx+hudw)-10,hudy+hudh+8


    ink rgb(90,255,90),rgb(0,0,0)


    if powering=1
        length#=zonethreshhold#-(zonethreshhold#*powerlength#)
        ink rgb(255,90,90),rgb(0,0,0)
    else
        length#=zonethreshhold#-(bz#-brad#)
    endif
    line (hudx2-hudw2)+7,(hudy2-5)+(((hudh2+10)/(zonethreshhold#))*(length#)),(hudx2-hudw2)+7,hudy2+hudh2+5
    line (hudx2-hudw2)+7,(hudy2-5)+(((hudh2+10)/(zonethreshhold#))*(length#)),(hudx2-hudw2)+10,(hudy2-8)+(((hudh2+16)/(zonethreshhold#))*(length#))
    line (hudx2-hudw2)+10,(hudy2-8)+(((hudh2+16)/(zonethreshhold#))*(length#)),(hudx2-hudw2)+10,hudy2+hudh2+8
    line (hudx2-hudw2)+7,hudy2+hudh2+5,(hudx2-hudw2)+10,hudy2+hudh2+8

    ink rgb(90,255,90),rgb(0,0,0)
endif

loop






Function Dline(ret,x1#,y1#,z1#,x2#,y2#,z2#,color As DWord)
   if ret=0 then ret=findobj()
   Make Object Triangle ret,x1#,y1#,z1#,x2#,y2#,z2#,x2#,y2#,z2#+0.01
   Set Object WireFrame ret,1
   Color Object ret,color
   set object specular ret,rgb(255,255,255)
   set object specular power ret,100

EndFunction ret

function findobj()
   ret=120
   while object exist(ret)
   ret=ret+1
   endwhile
endfunction ret

function createsparks(num,x#,y#,z#,minrangex,maxrangex,deviancex,minrangez,maxrangez,deviancez,colour,maxmag#)
for count=1 to num
  angx=(rnd(maxrangex-minrangex)+minrangex)
  angz=(rnd(maxrangez-minrangez)+minrangez)
  mag#=rnd(int(maxmag#*1000.0))/1000.0

  array insert at bottom sparkobj()
  array insert at bottom sparkx#()
  array insert at bottom sparky#()
  array insert at bottom sparkz#()
  array insert at bottom sparkangx#()
  array insert at bottom sparkangy#()
  array insert at bottom sparkangz#()
  array insert at bottom sparkmag#()
  sparks=array count(sparkobj())
  obj=findobj()
  if colour=2
    clone object obj,48
  else
    if colour=3
        clone object obj,49
    else
        clone object obj,47
    endif
  endif

    show object obj
    position object obj,x#,y#,z#
    xrotate object obj,angx
    zrotate object obj,angz
    scale object obj,mag#*10.0,mag#*10.0,mag#*10.0

  sparkobj(sparks)=obj
  sparkx#(sparks)=x#
  sparky#(sparks)=y#
  sparkz#(sparks)=z#
  sparkangx#(sparks)=angx
  sparkangy#(sparks)=0
  sparkangz#(sparks)=angz
  sparkmag#(sparks)=mag#
next count
endfunction

function updatesparks(iterationtime#,decay#)
sparks=array count(sparkobj())
for count=1 to sparks
    move object sparkobj(count),sparkmag#(count)*iterationtime#
    scale object sparkobj(count),sparkmag#(count)*10.0,sparkmag#(count)*10.0,sparkmag#(count)*10.0
    if sparkmag#(count)<7
      delete object sparkobj(count)
      array delete element sparkobj(),count
      array delete element sparkx#(),count
      array delete element sparky#(),count
      array delete element sparkz#(),count
      array delete element sparkangx#(),count
      array delete element sparkangy#(),count
      array delete element sparkangz#(),count
      array delete element sparkmag#(),count
      count=count-1
      sparks=sparks-1
    else
      if sparkmag#(count)<12
          set alpha mapping on sparkobj(count),(sparkmag#(count)-7)*20 
      endif
      sparkmag#(count)=sparkmag#(count)-(sparkmag#(count)*decay#*iterationtime#)
    endif

next count
endfunction

function showdigits(startobj,number)
if number<10
  select number
    case 0 : restore 0: endcase
    case 1 : restore 1: endcase
    case 2 : restore 2: endcase
    case 3 : restore 3: endcase
    case 4 : restore 4: endcase
    case 5 : restore 5: endcase
    case 6 : restore 6: endcase
    case 7 : restore 7: endcase
    case 8 : restore 8: endcase
    case 9 : restore 9: endcase
  endselect  
    for obj=startobj to startobj+6
      read temp
      if temp=1 
        show object obj
      else
        hide object obj
      endif
    next obj
endif
endfunction



0:
data 1,0,1,1,1,1,1
1:
data 0,0,0,1,0,1,0
2: 
data 1,1,1,0,1,1,0
3:
data 1,1,1,0,1,0,1
4:
data 0,1,0,1,1,0,1
5:
data 1,1,1,1,0,0,1
6:
data 1,1,1,1,0,1,1
7:
data 1,0,0,0,1,0,1
8:
data 1,1,1,1,1,1,1
9:
data 1,1,0,1,1,0,1

`[An Official Pong Ripoff]
`[By: Foe7 {FoeVII}]

autocam off : hide mouse `basic setup
sync on : sync rate 60

type paddle

   obj as integer
   x as float
   y as float
   z as float
   speed as float
   score as integer

endtype

type ball

   obj as integer
   speed as float
   x as float
   z as float
   yang as float
   collision as boolean
   lastHit

   transition as integer

endtype

type powerup

   obj as integer
   current as integer
   appear as integer
   dissappear as integer
   isthere as integer
   x as float
   y as float
   z as float

endtype

dim paddle(1) as paddle
dim ball(0) as ball
dim powerup(0) as powerup

global currVersion as integer `the current kind of pong being played
currVersion = 1 `basic pong (2)=brick,(3)=wheel

setup(1)

do

manageUser()
manageComp()
managePowerUps()
manageBall()
manageDisplay()
if currVersion = 2 then manageBricks()
if currVersion = 3 then manageWheels()

if ball(0).transition > 0
   transition(ball(0).transition)
endif

sync : loop

function clamp(a#,b#,c#)

   if c# < a# then c# = a#
   if c# > b# then c# = b#

endfunction c#

function transition(t)

   v = currVersion
   true as boolean
   true = 0

   sx = screen width()/2
   sy = screen height()/2
   box sx-100,sy-50,sx+100,sy+50,0,0,0,0
   center text sx,sy,"TRANSITION!!!"

   if v = 1

      `if t = 2

         delete object 2
         delete object 3
         delete object 4
         sync
         wait 500

         repeat
            xa = object angle x(1)
            ya = object angle y(1)
            za = object angle z(1)

            rotate object 1,xa+1,ya+1,za+1
            sync

            if object angle x(1) = 360 and object angle y(1) = 360 and object angle z(1) = 360 then true = 1

         until true

         dumpObjects()
         setup(t)
         delayBall(750)
         currVersion = t
         exitfunction

      `endif

   endif

   if v = 2

      `if t = 1

         delete object 2
         delete object 3
         delete object 4

         for b = 200 to 219
            if object exist (b) then delete object b
         next b

         sync
         wait 500

         repeat
            xa = object angle x(1)
            ya = object angle y(1)
            za = object angle z(1)

            rotate object 1,xa+1,ya+1,za+1
            sync

            if object angle x(1) = 360 and object angle y(1) = 360 and object angle z(1) = 360 then true = 1

         until true

         dumpObjects()
         setup(t)
         delayBall(750)
         currVersion = t
         exitfunction

      `endif

   endif

   if v = 3

      `if t = 1

         delete object 2
         delete object 3
         delete object 4

         for b = 300 to 310
            if object exist (b) then delete object b
         next b

         sync
         wait 500

         repeat
            xa = object angle x(1)
            ya = object angle y(1)
            za = object angle z(1)

            rotate object 1,xa+1,ya+1,za+1
            sync

            if object angle x(1) = 360 and object angle y(1) = 360 and object angle z(1) = 360 then true = 1

         until true

         dumpObjects()
         setup(t)
         delayBall(750)
         currVersion = t
         exitfunction

      `endif

   endif

endfunction

function createBoard() `makes the playing board

   make object box 1,50,0.5,100 `board
   position object 1,0,0-object size y(1)/2,0 `place it so the top is at y-coordinate 0

   make object box 10,4,10,100
   make mesh from object 1,10 `so we can turn it into a limb
   add limb 1,1,1
   offset limb 1,1,27,0,0
   add limb 1,2,1
   offset limb 1,2,-27,0,0
   delete object 10
   delete mesh 1

   color object 1,0
   color limb 1,1,rgb(155,155,55)
   color limb 1,2,rgb(155,155,55)

   make object sphere 15,-5000

endfunction

function setupCamera()

   position camera 0,100,-100
   point camera 0,0,0
   position mouse screen width()/2,screen height()/2 `for convience, set it at middle of screen

endfunction

function createUser() `make the user paddle and such

   make object box 2,10,4,2 `player paddle
   color object 2,rgb(255,55,55)
   paddle(0).obj = 2

endfunction

function createComp()

   clone object 3,2 `computer paddle
   color object 3,rgb(55,255,55)
   paddle(1).obj = 3

endfunction

function createBall() `creates the ball to be hit

   make object sphere 4,5.5
   color object 4,rgb(55,55,255)
   ball(0).obj = 4
   ball(0).transition = 0
   resetBall()

endfunction

function createSpecials()

   make object cube 100,5 `this will be the collision-object
   color object 100,rgb(155,155,155)
   ghost object on 100
   hide object 100
   powerup(0).obj = 100
   powerup(0).current = 0
   powerup(0).appear = timer() + 20000
   powerup(0).dissappear = timer() + 25000
   powerup(0).isthere = 0
   powerup(0).y = 2.5

   make object box 101,3.5,3.5,1 `this is to go to curveball
   `texture it
   color object 101,rgb(55,155,55)
   hide object 101

   make object box 102,3.5,3.5,1 `this will be the powerup to go to brick-ball (lol)
   `texture it
   color object 102,rgb(155,55,55)
   hide object 102

   make object box 103,3.5,3.5,1 `this will be the powerup to go to brick-ball (lol)
   `texture it
   color object 103,rgb(55,55,155)
   hide object 103

endfunction

function createBricks()

   for b = 200 to 219

      make object box b,5,2,2
      placeBrick(b)

   next b

endfunction

function createWheels(n)

   make object box 300,2,5,2

   make object box 301,4,2,2
   make mesh from object 1,301
   delete object 301
   add limb 300,1,1 : offset limb 300,1,2,-1.5,0
   add limb 300,2,1 : offset limb 300,2,-2,-1.5,0
   delete mesh 1

   make object box 301,2,2,4
   make mesh from object 1,301
   delete object 301
   add limb 300,3,1 : offset limb 300,3,0,-1.5,2
   add limb 300,4,1 : offset limb 300,4,0,-1.5,-2
   delete mesh 1

   placeWheel(300)

   for w = 1 to n

      clone object 300+w,300
      s# = (rnd(500)/5)+40
      s# = clamp(60,135,s#)
      scale object 300+w,s#,s#,s#

      placeWheel(300+w)

   next w

endfunction

function manageUser() `take care of user input and actions

   o = paddle(0).obj
   x# = object position x(2)
   y# = object position y(2)
   z# = object position z(2)
   ox# = x#
   inc x#,mousemovex()/2 `mouse sensitivity
   x# = clamp(-20,20,x#) `clamp the value between -20 and 20
   paddle(0).speed = x#-ox# `set it's speed/direction for future reference

   position object o,x#,y#,z#
   paddle(0).x = x#

endfunction

function manageComp() `HORRIBLE AI CODE...needs serious help

   o = paddle(1).obj
   m# = abs(paddle(0).speed) `this is just so there is some relation between the speed of the player and that of the computer
   if m# = 0 then m# = 1 `if the player doesn't move, then i'll let the computer move 1
   m# = m#/2`Computer Difficulty (m#/1 = definite loss)

   x# = object position x(o)
   y# = object position y(o)
   z# = object position z(o)
   ox# = x#

      if ball(0).x > ox#
         x# = ox# + m#
      else
         if ball(0).x < ox#
            x# = ox# - m#
         endif
      endif


   x# = clamp(-20,20,x#)
   position object o,x#,y#,z#
   paddle(1).x = x#
   paddle(1).speed = x#-ox#

endfunction

function manageBall()

   o = ball(0).obj `just a reference to the object number
   m# = ball(0).speed
   ox# = object position x(o) `the previous x
   oz# = object position z(o) `the previous z
   y# = object position y(o) `just a reference to the y position
   yan# = ball(0).yang `the object angle

   nx# = ox#+(m#*cos(yan#)) `uses trig to find new position
   nz# = oz#+(m#*sin(yan#))

   nnx# = clamp(-23.5,23.5,nx#) `this is to check for collision with walls
   if nnx# <> nx# `collision occured (needed to clamp)

      yan# = 180-yan#`yan# - 180
      inc m#,0.1
      nx# = nnx#
   endif
   position object o,nx#,y#,nz#
   ball(0).x = nx#
   ball(0).z = nz#

   nnz# = clamp(-48.5,48.5,nz#) `this is to check if a score
   if nnz# <> nz# `a score

      if nz# < 0 `computer scored

         inc paddle(1).score

      else

         inc paddle(0).score

      endif
      resetBall()
      delayBall(500)
      exitfunction

   else

      `this checks for collision between ball and paddle
      if nz# < 0 `this will set the obejct to check collision with
         col = 0
      else
         col = 1
      endif

      if object collision (o,paddle(col).obj) = 1 and ball(0).collision = 0

         ball(0).collision = 1
         yan# = yan# - 180
         inc m#,0.2
         ball(0).lastHit = col `0 = player, 1 = computer

         if nx# < object position x(paddle(col).obj) `this is to give it an extra bounce
            yan# = yan#-10
         else
            if nx# > object position x(paddle(col).obj)
               yan# = yan#+10
            endif
         endif

         if paddle(col).speed > 0
            inc yan#,4
         else
            if paddle(col).speed < 0
               inc yan#,-4
            endif
         endif

      else

         if object collision (o,paddle(col).obj) = 0 then ball(0).collision = 0

      endif

   endif

   ball(0).yang = wrapvalue(yan#)
   m# = clamp(0.9,2.5,m#)
   ball(0).speed = m#

endfunction

function manageBricks()

   for b = 200 to 219

      if object collision (ball(0).obj,b) = 1

         sx = object screen x(b)
         sy = object screen y(b)

         red = rgbr(point(sx,sy))
         green = rgbg(point(sx,sy))
         blue = rgbb(point(sx,sy))

         s = red+green+blue

         s = s/150
         if s = 0 then s = 1

         `inc paddle(ball(0).lastHit).score,s

         placeBrick(b)

         `ball(0).yang = 180-ball(0).yang
         ball(0).yang = ball(0).yang-180-(rnd(2)-1)
         ball(0).speed = ball(0).speed + 0.1
         exitfunction

      endif

   next b

endfunction

function manageWheels()

   for w = 300 to 310

      if object exist(w)

         if object collision (ball(0).obj,w) = 1

            ball(0).yang = ball(0).yang-180-(rnd(2)-1)
            ball(0).speed = ball(0).speed + 0.4

         endif

         yrotate object w,object angle y(w)+1

      endif

   next w

endfunction

function manageDisplay()

   text 80,100,str$(paddle(1).score)
   text 80,140,str$(paddle(0).score)

   if len(str$(paddle(0).score)) > len(str$(paddle(1).score))
      temp$ = str$(paddle(0).score)
   else
      temp$ = str$(paddle(1).score)
   endif

   s$ = ""
   for i = 1 to len(temp$)
      s$ = s$ + "-"
   next i

   text 80,120,s$

endfunction

function managePowerUps()

   if powerup(0).current = -1

      a = rnd(25) + 15
      d = a + rnd(20) + 10
      d = d * 1000
      a = a * 1000

      powerup(0).current = 0
      powerup(0).appear = a+timer()
      powerup(0).dissappear = d + timer()
      exitfunction

   endif

   if powerup(0).current = 0

      `print  "waiting..."

      if timer() >= powerup(0).appear

         repeat
            c = rnd(2)+1
         until c <> currVersion
         powerup(0).current = c
         powerup(0).isthere = 1

         `repeat
            x = rnd(40)-20
            z = rnd(80)-40
            powerup(0).x = x
            powerup(0).z = z

            o = powerup(0).obj
            position object o,x,powerup(0).y+0.1,z
            show object o
         `until object collision(o,0) = 0
            position object 100+c,x,powerup(0).y+0.1,z
            show object 100+c

      endif
      exitfunction

   endif

   if powerup(0).isthere = 1

     ` print "it's there"

      c = powerup(0).current + 100
      xa# = object angle x(c)
      ya# = object angle y(c)
      za# = object angle z(c)

      rotate object c,xa#+1,ya#-1,za#+1

      if timer() >= powerup(0).dissappear
         powerup(0).current = -1
         powerup(0).isthere = 0
         hide object powerup(0).obj
         hide object c
         exitfunction
      endif

      if object collision (powerup(0).obj,ball(0).obj) = 1
         powerup(0).current = -1
         powerup(0).isthere = 0
         hide object powerup(0).obj
         hide object c
         ball(0).transition = c-100
         exitfunction
      endif

   endif

endfunction

function placeBrick(o)

   x = rnd(10)+10
   x = x * ((rnd(1)*2)-1)
   position object o,x,1,rnd(60)-30

   for b = 200 to 219

      if b <> o
         if object exist(b)
            if object collision(o,b)
               placeBrick(o)
            endif
         endif
      endif
   next b

   color object o,rgb(rnd(254)+1,rnd(254)+1,rnd(254)+1)

endfunction

function placeWheel(o)

   x = rnd(10)+10
   x = x * ((rnd(1)*2)-1)
   z = rnd(20)+10
   z = z * ((rnd(1)*2)-1)
   position object o,x,object size y(o)/2+0.5,rnd(60)-30

   `for b = 300 to 310

      `if b <> o
         `if object exist(o)
            if object collision(o,0) > 0
               placeBrick(o)
            endif
         `endif
      `endif
   `next b

   color object o,rgb(rnd(254)+1,rnd(254)+1,rnd(254)+1)

endfunction

function resetBall() `positions ball

   position object ball(0).obj,0,object size y(4)/2,0 `puts it at ground level
   ball(0).speed = 1
   ball(0).x = 0
   ball(0).z = 0
   ball(0).yang = -90

endfunction

function delayBall(t)

   t = timer() + t
   repeat
      manageUser()
      manageComp()
      sync
   until timer() > t
   sync

endfunction

function resetPaddles()

   position object 2,0,object size y(2)/2,-49
   paddle(0).x = 0
   paddle(0).z = -49
   paddle(0).y = object size y(2)/2

   position object 3,object position x(2),object position y(2),object position z(2)*-1 `so you only need to change one set of values if you change size
   paddle(1).x = 0
   paddle(1).z = 49
   paddle(1).y = object size y(3)/2

endfunction

function dumpObjects() `just to clean everything up

   if object exist(1) then delete object 1
   if object exist(2) then delete object 2
   if object exist(3) then delete object 3
   if object exist(4) then delete object 4
   `if object exist(10) then delete object 10
   if object exist(15) then delete object 15
   if object exist(100) then delete object 100
   if object exist(101) then delete object 101
   if object exist(102) then delete object 102
   if object exist(103) then delete object 103

   for b = 200 to 219

      if object exist(b) then delete object b

   next b

   for b = 300 to 310

      if object exist(b) then delete object b

   next b

endfunction

function resetGame() `as in, when you start over

   dumpObjects()
   setup(1)

endfunction

function setup(t) `the start

   createBoard()
   setupCamera()
   createUser()
   createComp()
   resetPaddles()
   createBall()
   createSpecials()
   if t = 2 then createBricks()
   if t = 3 then createWheels(rnd(9))

endfunction

remstart

List of Information:

Object 1 - the board on bottom
Object 2 - Player's paddle
Object 3 - Computer's paddle
Object 4 - The Ball
***
Object 15 - Background
***
Object 100 - Collision cube for powerups
Object 101 - A powerup
Object 102 - Another powerup
Object 103 - Another one
***
200-219 - bricks

remend

ric
Way cool graphics and arcade style presentation

code_dragon
Very nice twist on the game to combine pong with problem solving.
Lots of potential for creating a very engaging game for one or two players.