Sorry your browser is not supported!

ceiling[][]=={
{-1,-1,-1,-1,-1,-1,-1,-1,-1},
{-1,13,13,13,13,13,13,15,-1},
{-1,160,160,160,160,160,261,313,-1},
{-1,18,16,10,16,10,60,313,-1},
{-1,10,14,12,14,12,60,313,-1},
{-1,27,18,361,160,160,161,313,-1},
{-1,10,18,61,160,160,261,313,-1},
{-1,12,18,18,18,18,60,313,-1},
{-1,18,16,10,16,10,60,313,-1},
{-1,18,14,12,14,12,60,313,-1},
{-1,160,160,160,160,160,161,313,-1},
{-1,-1,-1,-1,-1,-1,-1,-1,-1}
};

////////////////////////////////////////////////////////////////////////////////
// Floor Raycaster ! ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

function floorCaster()
for t=0 to Max_Floor
setspriteposition(_floor [t],-1000,-1000)
next t
LeftAngle# = player.rot - 30
RightAngle# = player.rot + 30
move# = 10.0
LeftX# = player.x + ( cos(LeftAngle#) * move#)
LeftY# = player.y + ( sin(LeftAngle#) * move#)
RightX# = player.x + ( cos(RightAngle#) * move#)
RightY# = player.y + ( sin(RightAngle#) * move#)
centerX# = player.x + ( cos(player.rot) * move#)
centerY# = player.y + ( sin(player.rot) * move#)

setspriteposition(Ray [0].Dot,LeftX#*miniMapScale,LeftY#*miniMapScale)
setspriteposition(Ray [1].Dot,RightX#*miniMapScale,RightY#*miniMapScale)
setspriteposition(Ray [3].Dot,centerX#*miniMapScale,centerY#*miniMapScale)
FloorY = 240+( (64 / ( Distance ( player.x*32 , player.y*32 , centerX#*32 , centerY#*32 ) *cos( 0 )))*300 )
depth=10001-( (64 / ( Distance ( player.x*32 , player.y*32 , centerX#*32 , centerY#*32 ) *cos( 0 )))*300 )
Fade=( (64 / ( Distance ( player.x*32 , player.y*32 , centerX#*32 , centerY#*32 ) *cos( 0 )))*300 )/2
if Fade>255 then Fade=255
//FloorY = 300
FloorX=5
Floor_count=0
for t=0 to 70
  StartAngle# = player.rot - 30
  rayspd#=0.0
  if Floor_count<Max_Floor and FloorY<480
  for i = 1 to FloornumRays
     if Floor_count<Max_Floor
     cosAng#=cos(StartAngle#)
     sinAng#=Sin(StartAngle#)
     X# = player.x + ( cosAng# * 20.0)
     Y# = player.y + ( sinAng# * 20.0)
     if RayCheck2(player.x,player.y,X#,Y#,LeftX#,LeftY#,RightX#,RightY#)=1
     setspriteposition(_floor [Floor_count],FloorX,FloorY)

     setspriteframe(_floor [Floor_count], getGrid(Intersection.X*32,Intersection.Y*32))
     setspritedepth(_floor [Floor_count],depth)

     //SetSpriteColor ( _floor [Floor_count] , Fade+60 , Fade+60 , Fade+60 , 255 )
     inc FloorX,_FloorSize
     endif
     inc Floor_count

     endif
     StartAngle# = StartAngle# + FloorRayspeed
     rayspd# = rayspd# + FloorRayspeed

   next i
endif
inc FloorY,_FloorHeight
FloorX=5
move# = move#-0.1
LeftX# = player.x + ( cos(LeftAngle#) * move#)
LeftY# = player.y + ( sin(LeftAngle#) * move#)
RightX# = player.x + ( cos(RightAngle#) * move#)
RightY# = player.y + ( sin(RightAngle#) * move#)
centerX# = player.x + ( cos(player.rot) * move#)
centerY# = player.y + ( sin(player.rot) * move#)
depth=10001-( (64 / ( Distance ( player.x*32 , player.y*32 , centerX#*32 , centerY#*32 ) *cos( 0 )))*300 )
Fade=( (64 / ( Distance ( player.x*32 , player.y*32 , centerX#*32 , centerY#*32 ) *cos( 0 )))*300 )/2
if Fade>255 then Fade=255
next t
endfunction

// used to get pixel on floor
function getGrid(x,y)
  // must be 1 pixel above the tile size
  Tile_size=33
  ``converts it to an grid grid nr
  X1=x/Tile_size
  Y1=y/Tile_size
  ``converts it to an world position
  X2=(X1*Tile_size)-Tile_size
  Y2=(Y1*Tile_size)-Tile_size
  ``here do we get an pixel cord inside that tile
  X3=((x-X2)-Tile_size)//+1
  Y3=((y-Y2)-Tile_size)//+1
result=X3+(Y3*Tile_size)+1
ENDFUNCTION result

function Get_Pixel(x,y)
    // must be 1 pixel above the tile size
    Tile_size=65
    // converts it to an grid grid nr
    X1=x/Tile_size
    Y1=y/Tile_size
    // converts it to an world position
    X2=(X1*Tile_size)-Tile_size
    Y2=(Y1*Tile_size)-Tile_size
    // here do we get an pixel cord inside that tile
    X3=((x-X2)-Tile_size)//+1
    Y3=((y-Y2)-Tile_size)//+1
    result=X3+(Y3*Tile_size)//+1
ENDFUNCTION result

////////////////////////////////////////////////////////////////////////////////
// Floor Ceiling Raycaster ! ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Setup_Floor:

   global IMG_Floor
   IMG_Floor = LoadImage ( "floor2.png" )

   // Number of rays we use
   #Constant FloornumRays 80.0
   // 60 is the field of view
   temp# = 60.0/FloornumRays
   #Constant FloorRayspeed temp#
   #Constant Max_Floor 8700
   #Constant _FloorSize 4
   #Constant _FloorHeight 1

type sFloor
    Old_Y_Floor as integer
    Old_Height as integer

 endtype

global dim Floor_ [FloornumRays] as sFloor

   global dim _floor [Max_Floor]
   //global dim Used_floor [500]
   global Floor_count=0
   for t = 0 to Max_Floor
       if t = 0
          id = CreateSprite ( IMG_Floor )
          SetSpriteSize ( id , _FloorSize , _FloorHeight )
          SetSpriteAnimation ( id , 1 , 1 , 64*64 )
          SetSpritePosition ( id , -1000 , -1000 )
          SetSpriteTransparency( id , 0 )
          setspritedepth( id , 10000)
       else
          id = clonesprite( _floor[0] )
       endif
       _floor[ t ] = id
   next t

return

function RENDER_Floor_Ceiling( LowRes , MinPixel , Floor_Step# , View_Depth)
    OriginX# = player.x*WorldScale
    OriginY# = player.y*WorldScale

    LeftAngle# = player.rot - 30.1
    RightAngle# = player.rot + 30.1
    move# = 1.48
    skipNext=0
    FloorY = 0
    RoofY =0
    OldFloorY = 0
    OldRoofY = 0
    FloorX=0
    Floor_count = 0

    for t=0 to View_Depth
        if Floor_count=>Max_Floor then exit
        StartAngle# = player.rot - 30
        rayspd#=0.0
        if skipNext=0
        LeftX# = player.x + ( cos(LeftAngle#) * move#)
        LeftY# = player.y + ( sin(LeftAngle#) * move#)
        RightX# = player.x + ( cos(RightAngle#) * move#)
        RightY# = player.y + ( sin(RightAngle#) * move#)
        DotX#=LeftX#
        DotY#=LeftY#
        tx#=LeftX#-RightX#
        ty#=LeftY#-RightY#
        DotSpeed#=(sqrt ( ( tx# * tx# ) + ( ty# * ty# ) ))/FloornumRays
        DotAng#=atanfull(RightX#-LeftX#,RightY#-LeftY#)-90
        DotMove#=0.0
        for i = 1 to FloornumRays

            if Floor_count<Max_Floor
               //cosAng#=cos(StartAngle#)
               //sinAng#=Sin(StartAngle#)
               X# = DotX# + ( cos(DotAng#) * DotMove#)
               Y# = DotY# + ( sin(DotAng#) * DotMove#)
                  X = DotX# + ( cos(DotAng#) * DotMove#)
                  Y = DotY# + ( sin(DotAng#) * DotMove#)
                  //if LineCast(player.x,player.y,X#,Y#,LeftX#,LeftY#,RightX#,RightY#)=1
                     dist=( (WorldScale / ( Distance ( OriginX# , OriginY# , X#*WorldScale , Y#*WorldScale ) *cos( 30-rayspd# )))*300 )
                     FloorY = 120+((dist/2))
                     RoofY = 120-(dist/2)
                     fdist=dist
                     rdist=dist
                     if map [X,Y].Height>0
                        StoreFloorY=FloorY
                        FloorY=FloorY-((dist/10)*map [X,Y].Height)
                     fdist=fdist+32
                     endif

                     //if FloorY>240 then exit
                     // If a floor pixel already here skip drawing it
                     //if OldFloorY = FloorY then exit
                     // This stretches the sprites to cover any gapps

                     if Floor_ [i].Old_Height = map [X,Y].Height then temp = Floor_ [i].Old_Y_Floor - FloorY

                     temp2=RoofY - OldRoofY
                     Fade=dist-30
                     if Fade<1 then Fade=1
                     if Fade>255 then Fade=255
                     // If size under minimum pixel size? Skip drawing it.
                     //if temp < MinPixel and t > 0 then exit
                     Initiate_Floor_Pixel( _floor [Floor_count] , temp , X# , Y# ,FloorX , FloorY , 32 , 10031-fdist , Fade ,255 )
                     Initiate_Floor_Pixel( _floor [Floor_count]+1 , temp2 ,X# , Y# , FloorX , RoofY-temp2 , 32 , 10031-rdist , Fade , 255 )
                     inc FloorX,_FloorSize
                     // restore the floor cordinate if it whas changed
                     if map [X,Y].Height>0 then FloorY=StoreFloorY
                  //endif
                  inc Floor_count,2
               endif
               DotMove#=DotMove#+DotSpeed#
               //StartAngle# = StartAngle# + FloorRayspeed
               rayspd# = rayspd# + FloorRayspeed
           Floor_ [i].Old_Height=map [X,Y].Height
           Floor_ [i].Old_Y_Floor = FloorY
           next i
           endif
           FloorX=0
           move# = move#+Floor_Step#
           inc skipNext
           if skipNext => LowRes then skipNext=0
           OldFloorY = FloorY
           OldRoofY = RoofY
    next t
    //print("              "+str(Floor_count))
    // Reset unused floor pixels
    //for t=Floor_count to Max_Floor
        //setspriteposition(_floor [t],-1000,-1000)
    //next t

endfunction




function Initiate_Floor_Pixel( id , Size ,x#,y#, X , Y , Texture ,depth , fade , alpha )
    SetSpriteSize ( id , _FloorSize , _FloorHeight + Size )
    setspriteposition( id , X , Y )
    setspriteframe( id , Get_Pixel(x#*Texture,y#*Texture))
    setspritedepth( id , depth )
    SetSpriteColor ( id , fade , fade , fade , alpha )
endfunction
////////////////////////////////
// used to get pixel on floor //
////////////////////////////////
function Get_Pixel(x,y)
    // must be 1 pixel above the tile size
    Tile_size=33
    // converts it to an grid grid nr
    X1=x/Tile_size
    Y1=y/Tile_size
    // converts it to an world position
    X2=(X1*Tile_size)-Tile_size
    Y2=(Y1*Tile_size)-Tile_size
    // here do we get an pixel cord inside that tile
    X3=((x-X2)-Tile_size)//+1
    Y3=((y-Y2)-Tile_size)//+1
    result=X3+(Y3*Tile_size)//+(Tile_size*Tile_size)
ENDFUNCTION result

////////////////////////////////
// used to get pixel on floor //
////////////////////////////////
function Get_Pixel_Centered( x as integer , y as integer , Scale as integer )
    // converts it to an grid grid nr
    X1 = (x+1) / (Scale)
    Y1 = (y+1) / (Scale)
    // converts it to an world position
    X2 = ( X1 * ( Scale ) )
    Y2 = ( Y1 * ( Scale ) )
    // here do we get an pixel cord inside that tile
    X3 =  ( x - X2 ) 
    Y3 =  ( y - Y2 ) 
    // Calculate it to an sprite frame
    if X3 < Y3 then result = ( X3 + ( Y3 * ( Scale + 1 ) ) ) - ( Scale + 1 )
    if X3 > Y3 then result = ( Y3 + ( X3 * ( Scale + 1 ) ) ) - ( Scale + 1 )
ENDFUNCTION result

function Get_Pixel_Grid( x as integer , y as integer , Scale as integer )
    // converts it to an grid grid nr
    x=x+(Scale/2)
    y=y+(Scale/2)
    X1=x/Scale
    Y1=y/Scale
    // converts it to an world position
    X2=(X1*(Scale))-(Scale/2)
    Y2=(Y1*(Scale))-(Scale/2)

    // here do we get an pixel cord inside that tile
    X3=( (x-X2) - (Scale/2) )
    Y3=( (y-Y2) - (Scale/2) )

    // Calculate it to an sprite frame
    if X3 < Y3 then result = ( X3 + ( Y3 * ( Scale + 1 ) ) ) - ( Scale + 1 )
    if X3 > Y3 then result = ( Y3 + ( X3 * ( Scale + 1 ) ) ) - ( Scale + 1 )
ENDFUNCTION result