Wip : Agk raycast engine ( Something like wolfenstein )

Author

Message

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 31st Oct 2011 01:07 Edited at: 2nd May 2012 01:07

Link

-------------------------------------------------------------------
Open source!
-------------------------------------------------------------------
Latest videos!

part 2.

Whas bored today and started on an side project to boinkadroid

I dont know if it will end upp to something working?

But this is my progress so far!

Its completely new compared to my raycast engine in dbp as now have i planned to make it easier to do floors and ceilings in the future!
Experimenting with floor heights!

Floor and ceiling in lowres.

With floor textures.

Now supports 3d sprites! ( 20 at the same time )

Now supports multi textures.(files will be added later this week.)

Here comes the source code to be embaressed about

Enjoy and let me know if you improve it

I want this to be an open source project for any agk user to have for there games.
With this do i mean i want your improvements not your games

First of all so is this an basic starter kit that is planned to grow.

And to be clear about it you are free to use it anyway you want.
But please give me some credit

You can download the zip file or cut and paste this!

-------------------------------------------------------------------
Jerico2day is storing and tracking all files here!
-------------------------------------------------------------------

http://darkbit.devstorm.co.uk/redmine/projects/raycast-pseudo3d

svn access
http://darkbit.devstorm.co.uk/redmine/svn/raycast-pseudo3d

-------------------------------------------------------------------
My updates.
-------------------------------------------------------------------

Latest files
0.3c
https://forumfiles.thegamecreators.com/download/2343575

Bugg fix 0.3b.
https://forumfiles.thegamecreators.com/download/2338234

0.3A (12-04-16) (is a typo on the zip file as this is 0.3A )
https://forumfiles.thegamecreators.com/download/2338142

0.2d
https://forumfiles.thegamecreators.com/download/2280270

0.2c
https://forumfiles.thegamecreators.com/download/2279187

Old files
0.2b
https://forumfiles.thegamecreators.com/download/2278887
0.2
https://forumfiles.thegamecreators.com/download/2278836

remstart
////////////////////////////////////////////////////////////////////////////////
// Raycast engine for AGK //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////// Open source ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
      By
Cliff Mellangård
    Sweden

Forum id
Cliff Mellangard 3DEGS
////////////////////////////////////////////////////////////////////////////////
Link to usefull sites. /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
http://www.permadi.com/tutorial/raycast/index.html

http://dev.opera.com/articles/view/creating-pseudo-3d-games-with-html-5-can-1/
////////////////////////////////////////////////////////////////////////////////
remend

global AngDummy
AngDummy = CreateSprite ( 0 )

SetSyncRate ( 0, 1 )
SetVirtualResolution ( GetDeviceWidth(), GetDeviceHeight() )
//setsorttextures(0)
global IMG
IMG = LoadImage ( "128x128.png" )

global IMG_Back
IMG_Back = LoadImage ( "Back.png" )

// number of map blocks in x-direction
#constant mapWidth 32
// number of map blocks in y-direction
#constant mapHeight 24

// how many pixels to draw a map block
#constant miniMapScale 4

// The same as minimap scale and is only used to get the right texture column for the screen column
#constant TextureScale 128

global dim map [mapWidth,mapHeight] as integer

Random_Map ()

// Number of rays we use
#Constant numRays 210
// this is 60/numrays
#Constant rayspeed 0.2857142
#Constant PI 3.1415926535
// not used yet
#Constant View_Distance 1.0
// screen width divided by numrays
#constant Column_Width 3
// Create our rays //////////////////
type sRay
	x as float
    y as float
    Angle as float
    Dot as integer
endtype

global dim Ray[numRays] as sRay

for t=0 to numRays
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , Column_Width , 2 )
      SetSpritePosition ( i, -100, -100 )
      SetSpriteColor ( i, 0 , 0 , 0 , 255 )
      Ray [t].Dot=i
next t

i = CreateSprite ( IMG_Back )
SetSpritePosition ( i , 5 , 0 )
SetSpriteSize ( i , Column_Width*numRays , 480 )

/////////////////////////////////////////////
// Create our screen columns ////////////////
/////////////////////////////////////////////
type sColumn
	ID as integer
	IMG as integer
    Height as integer
endtype

global dim Columns [numRays] as sColumn

for t=1 to numRays
      if t=1
      i = CreateSprite ( IMG )
      SetSpriteSize ( i , Column_Width , 120 )
      //SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      /////////////////////
      // NEW //////////////
      /////////////////////
      SetSpriteAnimation ( i, 1, TextureScale, TextureScale*4 )
      /////////////////////
      /////////////////////
      else
        i = clonesprite(Columns [1].ID)
        SetSpritePosition ( i, 260+(t*Column_Width), 180 )
      endif
      Columns [t].ID=i
next t

global dim Block [mapWidth*mapHeight]

for t=1 to (mapWidth*mapHeight)
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , miniMapScale , miniMapScale )
      SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      Block[t]=i
next t
/////////////////////////////////////////
// Create our player ////////////////////
////////////////////////////////////////
type sPlayer
	ID as integer
    x as float
    y as float
    dir as integer
    rot as float
    speed as integer
    moveSpeed as float
    rotSpeed as float
endtype

global Player as sPlayer
// current x, y position of the player
Player.x = 16 : Player.y = 10
// the direction that the player is turning, either -1 for left or 1 for right.
Player.dir = 0
// the current angle of rotation
Player.rot = 0
// is the playing moving forward (speed = 1) or backwards (speed = -1).
Player.speed = 0
// how far (in map units) does the player move each step/update( its this number * frame time )
Player.moveSpeed = 2.0
// old ////// ( Number math.PI ) how much does the player rotate each step/update (in radians)
Player.rotSpeed = 120.0

i = CreateSprite ( 0 )
SetSpriteSize ( i , miniMapScale , miniMapScale )
SetSpriteColor ( i, 0 , 0 , 0 , 255 )
SetSpritePosition ( i, Player.x*miniMapScale, Player.y*miniMapScale )
Player.ID = i

Draw_MiniMap ()
global GFT#
do
   GFT# = GetFrameTime()
   Check_keys ()
   Move_Player ()
   Raycast()
   if GetRawKeyPressed( 9 )
     Random_Map ()
     Draw_MiniMap ()
   endif
   //if GetRawKeyPressed( 32 ) then inc dt
   //if dt>1 then dt=0
   print("                                "+str(dt)+" "+str( Screenfps() ) )
   Sync()
loop

function Random_Map ()
for x = 0 to mapWidth-1
    for y = 0 to mapHeight-1
    map [ x , y ]=0
    if Random(0,10)=1
        map [ x , y ]=Random(1,4)
        map [ x+1 , y ]=Random(1,4)
    if x-1>0 then map [ x-1 , y ]=Random(1,4)
    if x+2<mapWidth then map [ x+2 , y ]=Random(1,4)
    endif
    if Random(0,10)=1
        if y-1>0 then map [ x , y-1 ]=Random(1,4)
        map [ x , y+1 ]=Random(1,4)
    if y+2<mapHeight then map [ x , y+2 ]=Random(1,4)
    map [ x , y ]=Random(1,4)
    endif
    if x=0 or x=mapWidth-1 then map [ x , y ]=Random(1,4)
    if y=0 or y=mapHeight-1 then map [ x , y ]=Random(1,4)
    next y
next x

endfunction

function Check_keys ()
   Player.speed = 0
   if GetRawKeystate( 38 ) then Player.speed = 1
   if GetRawKeystate( 40 ) then Player.speed = -1
   Player.dir = 0
   if GetRawKeystate( 39 ) then Player.dir = 1
   if GetRawKeystate( 37 ) then Player.dir = -1
endfunction

function Move_Player ()
    // player will move this far along the current direction vector
    moveStep# = player.speed * (player.moveSpeed*GFT#)
    // add rotation if player is rotating (player.dir != 0)
    player.rot = player.rot+(player.dir * (player.rotSpeed*GFT#))
    // calculate new player position with simple trigonometry
    newX# = player.x + (cos(player.rot) * moveStep#)
    newY# = player.y + (Sin(player.rot) * moveStep#)
    // Basic wall collision
    newX=newX#
    newY=newY#
    //if map [newX,newY]>0 then ExitFunction
    // set new position
    player.x = newX#
    player.y = newY#

SetSpritePosition ( Player.ID, Player.x*miniMapScale, Player.y*miniMapScale )
    setspriteangle (Player.ID,player.rot)
//print("                          "+str(WrapAngle(player.rot)))
endfunction

function Raycast()
  PLx# = player.x*32
  PLy# = player.y*32
  StartAngle#=WrapAngle(player.rot-30)
  rayspd#=0.0

for i = 1 to numRays
    //setspriteangle (DotRay [i],StartAngle#)
    cosAng#=cos(StartAngle#)
    sinAng#=Sin(StartAngle#)
    move#=0.0
    /////////////////////
    // NEW //////////////
    /////////////////////
    wall_ID=0
    /////////////////////
    /////////////////////
    target=0
    while target=0
       move# = move#+0.025
       newX = player.x + ( cosAng# * move#)
       newY = player.y + ( sinAng# * move#)
       target=1
       /////////////////////
       // NEW //////////////
       /////////////////////
       wall_ID=map [newX,newY]
       /////////////////////
       /////////////////////
       select ( map [newX,newY] )
         case 0:
           target = 0
         endcase
       endselect

endwhile

// Backtrack to make it smooth
     target=0
     while target=0
        move#=move#-0.01
        newX = player.x + ( cosAng# * move#)
        newY = player.y + ( sinAng# * move#)
        if newX<0 then newX=0
        if newY<0 then newY=0
        select ( map [newX,newY] )
            case 0:
              target=1
              newX# = (player.x + ( cosAng# * move#))
              newY# = (player.y + ( sinAng# * move#))
              Ray[i].x =  newX#*32
              Ray[i].y =  newY#*32
            endcase
         endselect

endwhile
      // (newx#-y#)+3 to be displayed right on the minimap,screws up raycast

TextureX#=newX#*TextureScale
      TextureY#=newY#*TextureScale
      TextureX#=TextureX#-(newX*TextureScale)
      TextureY#=TextureY#-(newY*TextureScale)
      // convert it to an integer
      TextureX=TextureX#+(TextureScale/2)
      TextureY=TextureY#+(TextureScale/2)

//hitting top or bottom
      GetTexture( i , TextureY , TextureX )
      //hitting left or right
      GetTexture( i , TextureX , TextureY )
      /////////////////////
      // NEW //////////////
      /////////////////////
      if wall_ID=2 then Columns [i].IMG=Columns [i].IMG+128
      if wall_ID=3 then Columns [i].IMG=Columns [i].IMG+256
      if wall_ID=4 then Columns [i].IMG=Columns [i].IMG+384
      /////////////////////
      /////////////////////
      /////////////////////
      Remstart
      64 is the size of the wall blocks.
      277 the viewing plane .
      distance = (( 64 / Actual distance *cos( angle in the fov ))) * 277)
      remend

Columns [i].Height = ( (64 / ( Distance ( PLx# , PLy# , Ray[i].x , Ray[i].y ) *cos( WrapAngle(30-rayspd#) )))*300 )
      fade=Columns [i].Height/2
      if fade>255 then fade=255
      SetSpriteColor ( Columns [i].ID , fade , fade , fade , 255 )
      SetSpriteFrame(Columns [i].ID , Columns [i].IMG )
      setspritesize(Columns [i].ID ,Column_Width, Columns [i].Height )
      SetSpritePosition ( Columns [i].ID , 2+(i*Column_Width), 240-( Columns [i].Height/2 ) )

StartAngle#=WrapAngle(StartAngle#+rayspeed)
      rayspd#=rayspd#+rayspeed
   next i

endfunction

// used to get pixel on floor
function getGrid(x,y)
  Tile_size=64
  ``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)
ENDFUNCTION result

function GetTexture( Column , Source , Target )
    select ( Source )

case 0:
         Columns [Column].IMG = Target
      endcase

case 1:
         Columns [Column].IMG = Target
      endcase

case 127:
         Columns [Column].IMG = Target
      endcase

case TextureScale:
         Columns [Column].IMG = Target
      endcase

endselect
endfunction

function Distance (x#,y#,x2#,y2#)
    distX# = x# - x2#
    distY# = y# - y2#
    dist# = sqrt ( ( distX# * distX# ) + ( distY# * distY# ) )
endfunction dist#

function WrapAngle(ang#)
    setspriteangle(AngDummy,ang#)
    result#=getspriteangle(AngDummy)
endfunction result#

/////////////////////////////////////////////////////////////////////
function Draw_MiniMap ()
   rect=1
   for y = 0 to mapHeight-1
      for x = 0 to mapWidth-1
         if map [ x , y ] >= 1 and map [ x , y ] <= 4
            if map [ x , y ] = 1 then SetSpriteColor ( Block[rect], 155 , 155 , 155 , 255 )
            if map [ x , y ] = 2 then SetSpriteColor ( Block[rect], 55 , 155 , 155 , 255 )
            if map [ x , y ] = 3 then SetSpriteColor ( Block[rect], 155 , 55 , 155 , 255 )
            if map [ x , y ] = 4 then SetSpriteColor ( Block[rect], 155 , 155 , 55 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         else
            SetSpriteColor ( Block[rect], 255 , 255 , 255 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         endif
      next x
   next y
endfunction

+ Code Snippet

remstart
////////////////////////////////////////////////////////////////////////////////
// Raycast engine for AGK //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////// Open source ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
      By
Cliff Mellangård
    Sweden

   Forum id
Cliff Mellangard 3DEGS
////////////////////////////////////////////////////////////////////////////////
Link to usefull sites. /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
http://www.permadi.com/tutorial/raycast/index.html

http://dev.opera.com/articles/view/creating-pseudo-3d-games-with-html-5-can-1/
////////////////////////////////////////////////////////////////////////////////
remend


global AngDummy
AngDummy = CreateSprite ( 0 )

SetSyncRate ( 0, 1 )
SetVirtualResolution ( GetDeviceWidth(), GetDeviceHeight() )
//setsorttextures(0)
global IMG
IMG = LoadImage ( "128x128.png" )

global IMG_Back
IMG_Back = LoadImage ( "Back.png" )

// number of map blocks in x-direction
#constant mapWidth 32
// number of map blocks in y-direction
#constant mapHeight 24

// how many pixels to draw a map block
#constant miniMapScale 4

// The same as minimap scale and is only used to get the right texture column for the screen column
#constant TextureScale 128

global dim map [mapWidth,mapHeight] as integer

Random_Map ()

// Number of rays we use
#Constant numRays 210
// this is 60/numrays
#Constant rayspeed 0.2857142
#Constant PI 3.1415926535
// not used yet
#Constant View_Distance 1.0
// screen width divided by numrays
#constant Column_Width 3
// Create our rays //////////////////
type sRay
	x as float
    y as float
    Angle as float
    Dot as integer
endtype

global dim Ray[numRays] as sRay

for t=0 to numRays
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , Column_Width , 2 )
      SetSpritePosition ( i, -100, -100 )
      SetSpriteColor ( i, 0 , 0 , 0 , 255 )
      Ray [t].Dot=i
next t

i = CreateSprite ( IMG_Back )
SetSpritePosition ( i , 5 , 0 )
SetSpriteSize ( i , Column_Width*numRays , 480 )

/////////////////////////////////////////////
// Create our screen columns ////////////////
/////////////////////////////////////////////
type sColumn
	ID as integer
	IMG as integer
    Height as integer
endtype

global dim Columns [numRays] as sColumn

for t=1 to numRays
      if t=1
      i = CreateSprite ( IMG )
      SetSpriteSize ( i , Column_Width , 120 )
      //SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      /////////////////////
      // NEW //////////////
      /////////////////////
      SetSpriteAnimation ( i, 1, TextureScale, TextureScale*4 )
      /////////////////////
      /////////////////////
      else
        i = clonesprite(Columns [1].ID)
        SetSpritePosition ( i, 260+(t*Column_Width), 180 )
      endif
      Columns [t].ID=i
next t

global dim Block [mapWidth*mapHeight]

for t=1 to (mapWidth*mapHeight)
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , miniMapScale , miniMapScale )
      SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      Block[t]=i
next t
/////////////////////////////////////////
// Create our player ////////////////////
////////////////////////////////////////
type sPlayer
	ID as integer
    x as float
    y as float
    dir as integer
    rot as float
    speed as integer
    moveSpeed as float
    rotSpeed as float
endtype

global Player as sPlayer
// current x, y position of the player
Player.x = 16 : Player.y = 10
// the direction that the player is turning, either -1 for left or 1 for right.
Player.dir = 0
// the current angle of rotation
Player.rot = 0
// is the playing moving forward (speed = 1) or backwards (speed = -1).
Player.speed = 0
// how far (in map units) does the player move each step/update( its this number * frame time )
Player.moveSpeed = 2.0
// old ////// ( Number math.PI ) how much does the player rotate each step/update (in radians)
Player.rotSpeed = 120.0

i = CreateSprite ( 0 )
SetSpriteSize ( i , miniMapScale , miniMapScale )
SetSpriteColor ( i, 0 , 0 , 0 , 255 )
SetSpritePosition ( i, Player.x*miniMapScale, Player.y*miniMapScale )
Player.ID = i

Draw_MiniMap ()
global GFT#
do
   GFT# = GetFrameTime()
   Check_keys ()
   Move_Player ()
   Raycast()
   if GetRawKeyPressed( 9 )
     Random_Map ()
     Draw_MiniMap ()
   endif
   //if GetRawKeyPressed( 32 ) then inc dt
   //if dt>1 then dt=0
   print("                                "+str(dt)+" "+str( Screenfps() ) )
   Sync()
loop

function Random_Map ()
for x = 0 to mapWidth-1
    for y = 0 to mapHeight-1
    map [ x , y ]=0
    if Random(0,10)=1
        map [ x , y ]=Random(1,4)
        map [ x+1 , y ]=Random(1,4)
    if x-1>0 then map [ x-1 , y ]=Random(1,4)
    if x+2<mapWidth then map [ x+2 , y ]=Random(1,4)
    endif
    if Random(0,10)=1
        if y-1>0 then map [ x , y-1 ]=Random(1,4)
        map [ x , y+1 ]=Random(1,4)
    if y+2<mapHeight then map [ x , y+2 ]=Random(1,4)
    map [ x , y ]=Random(1,4)
    endif
    if x=0 or x=mapWidth-1 then map [ x , y ]=Random(1,4)
    if y=0 or y=mapHeight-1 then map [ x , y ]=Random(1,4)
    next y
next x

endfunction

function Check_keys ()
   Player.speed = 0
   if GetRawKeystate( 38 ) then Player.speed = 1
   if GetRawKeystate( 40 ) then Player.speed = -1
   Player.dir = 0
   if GetRawKeystate( 39 ) then Player.dir = 1
   if GetRawKeystate( 37 ) then Player.dir = -1
endfunction

function Move_Player ()
    // player will move this far along the current direction vector
    moveStep# = player.speed * (player.moveSpeed*GFT#)
    // add rotation if player is rotating (player.dir != 0)
    player.rot = player.rot+(player.dir * (player.rotSpeed*GFT#))
    // calculate new player position with simple trigonometry
    newX# = player.x + (cos(player.rot) * moveStep#)
    newY# = player.y + (Sin(player.rot) * moveStep#)
    // Basic wall collision
    newX=newX#
    newY=newY#
    //if map [newX,newY]>0 then ExitFunction
    // set new position
    player.x = newX#
    player.y = newY#

    SetSpritePosition ( Player.ID, Player.x*miniMapScale, Player.y*miniMapScale )
    setspriteangle (Player.ID,player.rot)
//print("                          "+str(WrapAngle(player.rot)))
endfunction


function Raycast()
  PLx# = player.x*32
  PLy# = player.y*32
  StartAngle#=WrapAngle(player.rot-30)
  rayspd#=0.0

  for i = 1 to numRays
    //setspriteangle (DotRay [i],StartAngle#)
    cosAng#=cos(StartAngle#)
    sinAng#=Sin(StartAngle#)
    move#=0.0
    /////////////////////
    // NEW //////////////
    /////////////////////
    wall_ID=0
    /////////////////////
    /////////////////////
    target=0
    while target=0
       move# = move#+0.025
       newX = player.x + ( cosAng# * move#)
       newY = player.y + ( sinAng# * move#)
       target=1
       /////////////////////
       // NEW //////////////
       /////////////////////
       wall_ID=map [newX,newY]
       /////////////////////
       /////////////////////
       select ( map [newX,newY] )
         case 0:
           target = 0
         endcase
       endselect

     endwhile

     // Backtrack to make it smooth
     target=0
     while target=0
        move#=move#-0.01
        newX = player.x + ( cosAng# * move#)
        newY = player.y + ( sinAng# * move#)
        if newX<0 then newX=0
        if newY<0 then newY=0
        select ( map [newX,newY] )
            case 0:
              target=1
              newX# = (player.x + ( cosAng# * move#))
              newY# = (player.y + ( sinAng# * move#))
              Ray[i].x =  newX#*32
              Ray[i].y =  newY#*32
            endcase
         endselect

      endwhile
      // (newx#-y#)+3 to be displayed right on the minimap,screws up raycast

      TextureX#=newX#*TextureScale
      TextureY#=newY#*TextureScale
      TextureX#=TextureX#-(newX*TextureScale)
      TextureY#=TextureY#-(newY*TextureScale)
      // convert it to an integer
      TextureX=TextureX#+(TextureScale/2)
      TextureY=TextureY#+(TextureScale/2)

      //hitting top or bottom
      GetTexture( i , TextureY , TextureX )
      //hitting left or right
      GetTexture( i , TextureX , TextureY )
      /////////////////////
      // NEW //////////////
      /////////////////////
      if wall_ID=2 then Columns [i].IMG=Columns [i].IMG+128
      if wall_ID=3 then Columns [i].IMG=Columns [i].IMG+256
      if wall_ID=4 then Columns [i].IMG=Columns [i].IMG+384
      /////////////////////
      /////////////////////
      /////////////////////
      Remstart
      64 is the size of the wall blocks.
      277 the viewing plane .
      distance = (( 64 / Actual distance *cos( angle in the fov ))) * 277)
      remend

      Columns [i].Height = ( (64 / ( Distance ( PLx# , PLy# , Ray[i].x , Ray[i].y ) *cos( WrapAngle(30-rayspd#) )))*300 )
      fade=Columns [i].Height/2
      if fade>255 then fade=255
      SetSpriteColor ( Columns [i].ID , fade , fade , fade , 255 )
      SetSpriteFrame(Columns [i].ID , Columns [i].IMG )
      setspritesize(Columns [i].ID ,Column_Width, Columns [i].Height )
      SetSpritePosition ( Columns [i].ID , 2+(i*Column_Width), 240-( Columns [i].Height/2 ) )

      StartAngle#=WrapAngle(StartAngle#+rayspeed)
      rayspd#=rayspd#+rayspeed
   next i

endfunction

// used to get pixel on floor
function getGrid(x,y)
  Tile_size=64
  ``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)
ENDFUNCTION result

function GetTexture( Column , Source , Target )
    select ( Source )

      case 0:
         Columns [Column].IMG = Target
      endcase

      case 1:
         Columns [Column].IMG = Target
      endcase

      case 127:
         Columns [Column].IMG = Target
      endcase

      case TextureScale:
         Columns [Column].IMG = Target
      endcase

    endselect
endfunction

function Distance (x#,y#,x2#,y2#)
    distX# = x# - x2#
    distY# = y# - y2#
    dist# = sqrt ( ( distX# * distX# ) + ( distY# * distY# ) )
endfunction dist#

function WrapAngle(ang#)
    setspriteangle(AngDummy,ang#)
    result#=getspriteangle(AngDummy)
endfunction result#

/////////////////////////////////////////////////////////////////////
function Draw_MiniMap ()
   rect=1
   for y = 0 to mapHeight-1
      for x = 0 to mapWidth-1
         if map [ x , y ] >= 1 and map [ x , y ] <= 4
            if map [ x , y ] = 1 then SetSpriteColor ( Block[rect], 155 , 155 , 155 , 255 )
            if map [ x , y ] = 2 then SetSpriteColor ( Block[rect], 55 , 155 , 155 , 255 )
            if map [ x , y ] = 3 then SetSpriteColor ( Block[rect], 155 , 55 , 155 , 255 )
            if map [ x , y ] = 4 then SetSpriteColor ( Block[rect], 155 , 155 , 55 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         else
            SetSpriteColor ( Block[rect], 255 , 255 , 255 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         endif
      next x
   next y
endfunction

Old code.........

remstart
////////////////////////////////////////////////////////////////////////////////
// Raycast engine for AGK //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////// Open source ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
      By
Cliff Mellangård
    Sweden

Forum id
Cliff Mellangard 3DEGS
////////////////////////////////////////////////////////////////////////////////
Link to usefull sites. /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
http://www.permadi.com/tutorial/raycast/index.html

http://dev.opera.com/articles/view/creating-pseudo-3d-games-with-html-5-can-1/
////////////////////////////////////////////////////////////////////////////////
remend

global AngDummy
AngDummy = CreateSprite ( 0 )

SetSyncRate ( 0, 1 )
SetVirtualResolution ( GetDeviceWidth(), GetDeviceHeight() )
//setsorttextures(0)
global IMG
IMG = LoadImage ( "128x128.png" )

global IMG_Back
IMG_Back = LoadImage ( "Back.png" )

// number of map blocks in x-direction
#constant mapWidth 32
// number of map blocks in y-direction
#constant mapHeight 24

// how many pixels to draw a map block
#constant miniMapScale 4

// The same as minimap scale and is only used to get the right texture column for the screen column
#constant TextureScale 128

global dim map [mapWidth,mapHeight] as integer

Random_Map ()

// Number of rays we use
#Constant numRays 210
// this is 60/numrays
#Constant rayspeed 0.2857142
#Constant PI 3.1415926535
// not used yet
#Constant View_Distance 1.0
// screen width divided by numrays
#constant Column_Width 3
// Create our rays //////////////////
type sRay
	x as float
    y as float
    Angle as float
    Dot as integer
endtype

global dim Ray[numRays] as sRay

for t=0 to numRays
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , Column_Width , 2 )
      SetSpritePosition ( i, -100, -100 )
      SetSpriteColor ( i, 0 , 0 , 0 , 255 )
      Ray [t].Dot=i
next t

i = CreateSprite ( IMG_Back )
SetSpritePosition ( i , 5 , 0 )
SetSpriteSize ( i , Column_Width*numRays , 480 )

/////////////////////////////////////////////
// Create our screen columns ////////////////
/////////////////////////////////////////////
type sColumn
	ID as integer
	IMG as integer
    Height as integer
endtype

global dim Columns [numRays] as sColumn

for t=1 to numRays
      if t=1
      i = CreateSprite ( IMG )
      SetSpriteSize ( i , Column_Width , 120 )
      //SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      SetSpriteAnimation ( i, 1, TextureScale, TextureScale )
      else
        i = clonesprite(Columns [1].ID)
        SetSpritePosition ( i, 260+(t*Column_Width), 180 )
      endif
      Columns [t].ID=i
next t

global dim Block [mapWidth*mapHeight]

for t=1 to (mapWidth*mapHeight)
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , miniMapScale , miniMapScale )
      SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      Block[t]=i
next t
/////////////////////////////////////////
// Create our player ////////////////////
////////////////////////////////////////
type sPlayer
	ID as integer
    x as float
    y as float
    dir as integer
    rot as float
    speed as integer
    moveSpeed as float
    rotSpeed as float
endtype

global Player as sPlayer
// current x, y position of the player
Player.x = 16 : Player.y = 10
// the direction that the player is turning, either -1 for left or 1 for right.
Player.dir = 0
// the current angle of rotation
Player.rot = 0
// is the playing moving forward (speed = 1) or backwards (speed = -1).
Player.speed = 0
// how far (in map units) does the player move each step/update( its this number * frame time )
Player.moveSpeed = 2.0
// old ////// ( Number math.PI ) how much does the player rotate each step/update (in radians)
Player.rotSpeed = 120.0

i = CreateSprite ( 0 )
SetSpriteSize ( i , miniMapScale , miniMapScale )
SetSpriteColor ( i, 0 , 0 , 0 , 255 )
SetSpritePosition ( i, Player.x*miniMapScale, Player.y*miniMapScale )
Player.ID = i

Draw_MiniMap ()
global GFT#
do
   GFT# = GetFrameTime()
   Check_keys ()
   Move_Player ()
   Raycast()
   if GetRawKeyPressed( 9 )
     Random_Map ()
     Draw_MiniMap ()
   endif
   if GetRawKeyPressed( 32 ) then inc floor_on
   print("                                "+str( Screenfps() ) )
   Sync()
loop

function Random_Map ()
for x = 0 to mapWidth-1
    for y = 0 to mapHeight-1
    map [ x , y ]=0
    if Random(0,10)=1
        map [ x , y ]=1
        map [ x+1 , y ]=1
    if x-1>0 then map [ x-1 , y ]=1
    if x+2<mapWidth then map [ x+2 , y ]=1
    endif
    if Random(0,10)=1
        if y-1>0 then map [ x , y-1 ]=1
        map [ x , y+1 ]=1
    if y+2<mapHeight then map [ x , y+2 ]=1
    map [ x , y ]=1
    endif
    if x=0 or x=mapWidth-1 then map [ x , y ]=1
    if y=0 or y=mapHeight-1 then map [ x , y ]=1
    next y
next x

endfunction

function Check_keys ()
   Player.speed = 0
   if GetRawKeystate( 38 ) then Player.speed = 1
   if GetRawKeystate( 40 ) then Player.speed = -1
   Player.dir = 0
   if GetRawKeystate( 39 ) then Player.dir = 1
   if GetRawKeystate( 37 ) then Player.dir = -1
endfunction

function Move_Player ()
    // player will move this far along the current direction vector
    moveStep# = player.speed * (player.moveSpeed*GFT#)
    // add rotation if player is rotating (player.dir != 0)
    player.rot = player.rot+(player.dir * (player.rotSpeed*GFT#))
    // calculate new player position with simple trigonometry
    newX# = player.x + (cos(player.rot) * moveStep#)
    newY# = player.y + (Sin(player.rot) * moveStep#)
    // Basic wall collision
    newX=newX#
    newY=newY#
    //if map [newX,newY]>0 then ExitFunction
    // set new position
    player.x = newX#
    player.y = newY#

SetSpritePosition ( Player.ID, Player.x*miniMapScale, Player.y*miniMapScale )
    setspriteangle (Player.ID,player.rot)
//print("                          "+str(WrapAngle(player.rot)))
endfunction

function Raycast()
  PLx# = player.x*32
  PLy# = player.y*32
  StartAngle#=WrapAngle(player.rot-30)
  rayspd#=0.0

for i = 1 to numRays
    //setspriteangle (DotRay [i],StartAngle#)
    cosAng#=cos(StartAngle#)
    sinAng#=Sin(StartAngle#)
    move#=0.0

target=0
    while target=0
       move# = move#+0.025
       newX = player.x + ( cosAng# * move#)
       newY = player.y + ( sinAng# * move#)
       target=1

select ( map [newX,newY] )
         case 0:
           target = 0
         endcase
       endselect

endwhile

// Backtrack to make it smooth
     target=0
     while target=0
        move#=move#-0.01
        newX = player.x + ( cosAng# * move#)
        newY = player.y + ( sinAng# * move#)
        if newX<0 then newX=0
        if newY<0 then newY=0
        select ( map [newX,newY] )
            case 0:
              target=1
              newX# = (player.x + ( cosAng# * move#))
              newY# = (player.y + ( sinAng# * move#))
              Ray[i].x =  newX#*32
              Ray[i].y =  newY#*32
            endcase
         endselect

endwhile
      // (newx#-y#)+3 to be displayed right on the minimap,screws up raycast

TextureX#=newX#*TextureScale
      TextureY#=newY#*TextureScale
      TextureX#=TextureX#-(newX*TextureScale)
      TextureY#=TextureY#-(newY*TextureScale)
      // convert it to an integer
      TextureX=TextureX#+(TextureScale/2)
      TextureY=TextureY#+(TextureScale/2)

//hitting top or bottom
      GetTexture( i , TextureY , TextureX )
      //hitting left or right
      GetTexture( i , TextureX , TextureY )

Remstart
      64 is the size of the wall blocks.
      277 the viewing plane .
      distance = (( 64 / Actual distance *cos( angle in the fov ))) * 277)
      remend

Columns [i].Height = ( (64 / ( Distance ( PLx# , PLy# , Ray[i].x , Ray[i].y ) *cos( WrapAngle(30-rayspd#) )))*300 )

fade=Columns [i].Height/2
      if fade>255 then fade=255
      SetSpriteColor ( Columns [i].ID , fade , fade , fade , 255 )
      SetSpriteFrame(Columns [i].ID , Columns [i].IMG )
      setspritesize(Columns [i].ID ,Column_Width, Columns [i].Height )
      SetSpritePosition ( Columns [i].ID , 2+(i*Column_Width), 240-( Columns [i].Height/2 ) )

StartAngle#=WrapAngle(StartAngle#+rayspeed)
      rayspd#=rayspd#+rayspeed
   next i

endfunction

// used to get pixel on floor
function getGrid(x,y)
  Tile_size=64
  ``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)
ENDFUNCTION result

function GetTexture( Column , Source , Target )
    select ( Source )

case 0:
         Columns [Column].IMG = Target
      endcase

case 1:
         Columns [Column].IMG = Target
      endcase

case 127:
         Columns [Column].IMG = Target
      endcase

case TextureScale:
         Columns [Column].IMG = Target
      endcase

endselect
endfunction

function Distance (x#,y#,x2#,y2#)
    distX# = x# - x2#
    distY# = y# - y2#
    dist# = sqrt ( ( distX# * distX# ) + ( distY# * distY# ) )
endfunction dist#

function WrapAngle(ang#)
    setspriteangle(AngDummy,ang#)
    result#=getspriteangle(AngDummy)
endfunction result#

/////////////////////////////////////////////////////////////////////
function Draw_MiniMap ()
   rect=1
   for y = 0 to mapHeight-1
      for x = 0 to mapWidth-1
         if map [ x , y ] = 1
            SetSpriteColor ( Block[rect], 155 , 155 , 155 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         else
            SetSpriteColor ( Block[rect], 255 , 255 , 255 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         endif
      next x
   next y
endfunction

+ Code Snippet

remstart
////////////////////////////////////////////////////////////////////////////////
// Raycast engine for AGK //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////// Open source ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
      By
Cliff Mellangård
    Sweden

   Forum id
Cliff Mellangard 3DEGS
////////////////////////////////////////////////////////////////////////////////
Link to usefull sites. /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
http://www.permadi.com/tutorial/raycast/index.html

http://dev.opera.com/articles/view/creating-pseudo-3d-games-with-html-5-can-1/
////////////////////////////////////////////////////////////////////////////////
remend


global AngDummy
AngDummy = CreateSprite ( 0 )

SetSyncRate ( 0, 1 )
SetVirtualResolution ( GetDeviceWidth(), GetDeviceHeight() )
//setsorttextures(0)
global IMG
IMG = LoadImage ( "128x128.png" )

global IMG_Back
IMG_Back = LoadImage ( "Back.png" )

// number of map blocks in x-direction
#constant mapWidth 32
// number of map blocks in y-direction
#constant mapHeight 24

// how many pixels to draw a map block
#constant miniMapScale 4

// The same as minimap scale and is only used to get the right texture column for the screen column
#constant TextureScale 128

global dim map [mapWidth,mapHeight] as integer

Random_Map ()

// Number of rays we use
#Constant numRays 210
// this is 60/numrays
#Constant rayspeed 0.2857142
#Constant PI 3.1415926535
// not used yet
#Constant View_Distance 1.0
// screen width divided by numrays
#constant Column_Width 3
// Create our rays //////////////////
type sRay
	x as float
    y as float
    Angle as float
    Dot as integer
endtype

global dim Ray[numRays] as sRay

for t=0 to numRays
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , Column_Width , 2 )
      SetSpritePosition ( i, -100, -100 )
      SetSpriteColor ( i, 0 , 0 , 0 , 255 )
      Ray [t].Dot=i
next t

i = CreateSprite ( IMG_Back )
SetSpritePosition ( i , 5 , 0 )
SetSpriteSize ( i , Column_Width*numRays , 480 )

/////////////////////////////////////////////
// Create our screen columns ////////////////
/////////////////////////////////////////////
type sColumn
	ID as integer
	IMG as integer
    Height as integer
endtype

global dim Columns [numRays] as sColumn

for t=1 to numRays
      if t=1
      i = CreateSprite ( IMG )
      SetSpriteSize ( i , Column_Width , 120 )
      //SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      SetSpriteAnimation ( i, 1, TextureScale, TextureScale )
      else
        i = clonesprite(Columns [1].ID)
        SetSpritePosition ( i, 260+(t*Column_Width), 180 )
      endif
      Columns [t].ID=i
next t

global dim Block [mapWidth*mapHeight]

for t=1 to (mapWidth*mapHeight)
      i = CreateSprite ( 0 )
      SetSpriteSize ( i , miniMapScale , miniMapScale )
      SetSpriteColor ( i, 255 , 255 , 255 , 255 )
      Block[t]=i
next t
/////////////////////////////////////////
// Create our player ////////////////////
////////////////////////////////////////
type sPlayer
	ID as integer
    x as float
    y as float
    dir as integer
    rot as float
    speed as integer
    moveSpeed as float
    rotSpeed as float
endtype

global Player as sPlayer
// current x, y position of the player
Player.x = 16 : Player.y = 10
// the direction that the player is turning, either -1 for left or 1 for right.
Player.dir = 0
// the current angle of rotation
Player.rot = 0
// is the playing moving forward (speed = 1) or backwards (speed = -1).
Player.speed = 0
// how far (in map units) does the player move each step/update( its this number * frame time )
Player.moveSpeed = 2.0
// old ////// ( Number math.PI ) how much does the player rotate each step/update (in radians)
Player.rotSpeed = 120.0

i = CreateSprite ( 0 )
SetSpriteSize ( i , miniMapScale , miniMapScale )
SetSpriteColor ( i, 0 , 0 , 0 , 255 )
SetSpritePosition ( i, Player.x*miniMapScale, Player.y*miniMapScale )
Player.ID = i


Draw_MiniMap ()
global GFT#
do
   GFT# = GetFrameTime()
   Check_keys ()
   Move_Player ()
   Raycast()
   if GetRawKeyPressed( 9 )
     Random_Map ()
     Draw_MiniMap ()
   endif
   if GetRawKeyPressed( 32 ) then inc floor_on
   print("                                "+str( Screenfps() ) )
   Sync()
loop

function Random_Map ()
for x = 0 to mapWidth-1
    for y = 0 to mapHeight-1
    map [ x , y ]=0
    if Random(0,10)=1
        map [ x , y ]=1
        map [ x+1 , y ]=1
    if x-1>0 then map [ x-1 , y ]=1
    if x+2<mapWidth then map [ x+2 , y ]=1
    endif
    if Random(0,10)=1
        if y-1>0 then map [ x , y-1 ]=1
        map [ x , y+1 ]=1
    if y+2<mapHeight then map [ x , y+2 ]=1
    map [ x , y ]=1
    endif
    if x=0 or x=mapWidth-1 then map [ x , y ]=1
    if y=0 or y=mapHeight-1 then map [ x , y ]=1
    next y
next x

endfunction

function Check_keys ()
   Player.speed = 0
   if GetRawKeystate( 38 ) then Player.speed = 1
   if GetRawKeystate( 40 ) then Player.speed = -1
   Player.dir = 0
   if GetRawKeystate( 39 ) then Player.dir = 1
   if GetRawKeystate( 37 ) then Player.dir = -1
endfunction

function Move_Player ()
    // player will move this far along the current direction vector
    moveStep# = player.speed * (player.moveSpeed*GFT#)
    // add rotation if player is rotating (player.dir != 0)
    player.rot = player.rot+(player.dir * (player.rotSpeed*GFT#))
    // calculate new player position with simple trigonometry
    newX# = player.x + (cos(player.rot) * moveStep#)
    newY# = player.y + (Sin(player.rot) * moveStep#)
    // Basic wall collision
    newX=newX#
    newY=newY#
    //if map [newX,newY]>0 then ExitFunction
    // set new position
    player.x = newX#
    player.y = newY#

    SetSpritePosition ( Player.ID, Player.x*miniMapScale, Player.y*miniMapScale )
    setspriteangle (Player.ID,player.rot)
//print("                          "+str(WrapAngle(player.rot)))
endfunction


function Raycast()
  PLx# = player.x*32
  PLy# = player.y*32
  StartAngle#=WrapAngle(player.rot-30)
  rayspd#=0.0

  for i = 1 to numRays
    //setspriteangle (DotRay [i],StartAngle#)
    cosAng#=cos(StartAngle#)
    sinAng#=Sin(StartAngle#)
    move#=0.0

    target=0
    while target=0
       move# = move#+0.025
       newX = player.x + ( cosAng# * move#)
       newY = player.y + ( sinAng# * move#)
       target=1

       select ( map [newX,newY] )
         case 0:
           target = 0
         endcase
       endselect

     endwhile

     // Backtrack to make it smooth
     target=0
     while target=0
        move#=move#-0.01
        newX = player.x + ( cosAng# * move#)
        newY = player.y + ( sinAng# * move#)
        if newX<0 then newX=0
        if newY<0 then newY=0
        select ( map [newX,newY] )
            case 0:
              target=1
              newX# = (player.x + ( cosAng# * move#))
              newY# = (player.y + ( sinAng# * move#))
              Ray[i].x =  newX#*32
              Ray[i].y =  newY#*32
            endcase
         endselect

      endwhile
      // (newx#-y#)+3 to be displayed right on the minimap,screws up raycast

      TextureX#=newX#*TextureScale
      TextureY#=newY#*TextureScale
      TextureX#=TextureX#-(newX*TextureScale)
      TextureY#=TextureY#-(newY*TextureScale)
      // convert it to an integer
      TextureX=TextureX#+(TextureScale/2)
      TextureY=TextureY#+(TextureScale/2)

      //hitting top or bottom
      GetTexture( i , TextureY , TextureX )
      //hitting left or right
      GetTexture( i , TextureX , TextureY )

      Remstart
      64 is the size of the wall blocks.
      277 the viewing plane .
      distance = (( 64 / Actual distance *cos( angle in the fov ))) * 277)
      remend

      Columns [i].Height = ( (64 / ( Distance ( PLx# , PLy# , Ray[i].x , Ray[i].y ) *cos( WrapAngle(30-rayspd#) )))*300 )

      fade=Columns [i].Height/2
      if fade>255 then fade=255
      SetSpriteColor ( Columns [i].ID , fade , fade , fade , 255 )
      SetSpriteFrame(Columns [i].ID , Columns [i].IMG )
      setspritesize(Columns [i].ID ,Column_Width, Columns [i].Height )
      SetSpritePosition ( Columns [i].ID , 2+(i*Column_Width), 240-( Columns [i].Height/2 ) )

      StartAngle#=WrapAngle(StartAngle#+rayspeed)
      rayspd#=rayspd#+rayspeed
   next i

endfunction

// used to get pixel on floor
function getGrid(x,y)
  Tile_size=64
  ``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)
ENDFUNCTION result

function GetTexture( Column , Source , Target )
    select ( Source )

      case 0:
         Columns [Column].IMG = Target
      endcase

      case 1:
         Columns [Column].IMG = Target
      endcase

      case 127:
         Columns [Column].IMG = Target
      endcase

      case TextureScale:
         Columns [Column].IMG = Target
      endcase

    endselect
endfunction

function Distance (x#,y#,x2#,y2#)
    distX# = x# - x2#
    distY# = y# - y2#
    dist# = sqrt ( ( distX# * distX# ) + ( distY# * distY# ) )
endfunction dist#

function WrapAngle(ang#)
    setspriteangle(AngDummy,ang#)
    result#=getspriteangle(AngDummy)
endfunction result#

/////////////////////////////////////////////////////////////////////
function Draw_MiniMap ()
   rect=1
   for y = 0 to mapHeight-1
      for x = 0 to mapWidth-1
         if map [ x , y ] = 1
            SetSpriteColor ( Block[rect], 155 , 155 , 155 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         else
            SetSpriteColor ( Block[rect], 255 , 255 , 255 , 255 )
            SetSpritePosition ( Block[rect], x*miniMapScale, y*miniMapScale )
            inc rect
         endif
      next x
   next y
endfunction

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 31st Oct 2011 01:12 Edited at: 31st Oct 2011 01:24

Link

Another picture!

Last fixes for today!

Attachments

Login to view attachments

Back to top

Profile PM Website

Mobiius

Valued Member

21

Years of Service

User Offline

Joined: 27th Feb 2003

Location: The Cold North

Posted: 31st Oct 2011 14:51

Link

That is coolio! It's bringing modern PC graphics back to the 80's again!

I so want a piece of that action! lol

My signature is NOT a moderator plaything! Stop changing it!

Back to top

Profile PM Email Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 31st Oct 2011 18:40 Edited at: 31st Oct 2011 18:45

Link

Quote: "That is coolio! It's bringing modern PC graphics back to the 80's again!

I so want a piece of that action! lol"

No no early 90's

Couldt help my self after playing some alien breed 3d,gloom and fears on my amiga cd32 from 94.( Raycast engine games )

Its pretty crappy right now but with some work maybe?

Here is my dbp original!
http://forum.thegamecreators.com/?m=forum_view&t=182724&b=8

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 1st Nov 2011 23:35 Edited at: 1st Nov 2011 23:35

Link

Textured walls makes it a bit better

Time to experiment with floor and ceiling textures

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 2nd Nov 2011 00:41 Edited at: 2nd Nov 2011 00:42

Link

Last update for today!

Experimented with my texture engine and it now supports any texture size.
This screen shoot have an texture with the size of 128x128 and 160 rays is casted.
Its still completely useless as its unoptimized and have draw buggs in the corners.

But could be good for somekind of dungeon master game?

Attachments

Login to view attachments

Back to top

Profile PM Website

Mobiius

Valued Member

21

Years of Service

User Offline

Joined: 27th Feb 2003

Location: The Cold North

Posted: 2nd Nov 2011 11:54

Link

Very good work! Keep it up! I'd love to see a working wolfenstein game made with AppGameKit!

My signature is NOT a moderator plaything! Stop changing it!

Back to top

Profile PM Email Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 2nd Nov 2011 17:52

Link

Quote: "Very good work! Keep it up! I'd love to see a working wolfenstein game made with AppGameKit!"

I will do my best

Back to top

Profile PM Website

Impetus73

13

Years of Service

User Offline

Joined: 28th Aug 2011

Location: Volda, Norway

Posted: 2nd Nov 2011 19:02

Link

I would kill (a bug) for the code!

----------------
AGK user - novice
Did Amiga / AMOS programming in the 90's, just started programming again with AGK.

Back to top

Profile PM Email

DVader

20

Years of Service

User Offline

Joined: 28th Jan 2004

Location:

Posted: 2nd Nov 2011 19:53

Link

Very nice. Too much maths for me I would imagine

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 2nd Nov 2011 21:56

Link

Quote: "I would kill (a bug) for the code!"

The code will be released later on

I just want to smack some weird buggs first!
I have an crazy idea of making it open source because of my lack of time to work on it.

Quote: "Very nice. Too much maths for me I would imagine "

Extremely little math as iam a simple guy.
The only math is more or less player angle,world cordinates,and the ray angles and where they hit.

The way i texture it is extremely simple that i noticed worked just as good as math!

Get an grid x,y coord and then convert it to world cordinates(with the texture size).
Then remove the world cordinates to the left and above.
Then do you simply check if the hit whas either x = 1 or 128 and the same goes with the y cordinate.
( 128 is the texture size)
Because if the x check is true then is the y cordinate the sprite frame the column should use.
And the reversed on the 2 other faces.
The screen columns that give the 3d illusion is simply sprites with animation frames,that get stretched according to distance on there height.

But keep in mind that this one so far only displays squared walls!

I have some huge ideas for making this simple and easy to understand for anyone.

If you want to help out on the engine so be patient so will i try to release the source step by step when i improve it.

Because i want as much feedback as possible on how to improve it and other ideas to make it simple!

My first dbp engine did i do to much by my self and got stuck!

Back to top

Profile PM Website

bitJericho

22

Years of Service

User Offline

Joined: 9th Oct 2002

Location: United States

Posted: 3rd Nov 2011 18:00

Link

Cliff, you should look into setting up a project on sourceforge: http://sourceforge.net/

Then you can update your code by committing with tortoisesvn.

Here's a crash course on doing such a thing:
http://www.comp.nus.edu.sg/~cs3215/tools/svn.html

If you need help with that, hook me up on email. While it might be a headache to setup, it could save you time in the future and could allow dudes like me to use your code and integrate future updates, and submit my own patches to you.

Back to top

Profile PM Email Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 3rd Nov 2011 18:18 Edited at: 3rd Nov 2011 18:22

Link

Thanks jerico i will check it out later on!

But thats for the future as i noticed some huge drawbacks that crashed the free texture size engine

And it uses huge amounts of framerates ?
I also forgot about the dual 2d cordinates

Have to rewrite some things with the world to screen command and se if it helps.

Iam a bit confused as i now have to use some very weird settings and scales to get it to look as normal as possible?

Cheers.

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 4th Nov 2011 00:54 Edited at: 4th Nov 2011 00:57

Link

First day of optimising the raycast code

But the textures seams a bit blurrier now ?

The first solution whas really simple as i now get the first hit detection with an fast ray, and if it registers an hit so do i backtrack slowly to get smooth walls.

Attachments

Login to view attachments

Back to top

Profile PM Website

JRNTexas

13

Years of Service

User Offline

Joined: 24th May 2011

Location: Austin, Texas

Posted: 4th Nov 2011 04:50

Link

This looks pretty good! How fast is it?

Back to top

Profile PM Email Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 4th Nov 2011 16:33

Link

Quote: "This looks pretty good! How fast is it? "

I will release the first playable beta to get some feedback on the speed this weekend.
I went from 25 fps to 132 with the latest changes.

But it differs if you watch down an long wide corridor so can it drop down to 30-40 ,and up close to an wall so do you get around 250-300 fps.
the ray moves with an speed of 0.03 that eats alot of fps.
If its any faster so do you get chunky walls.

But i have only worked 5 days on it

If you think of it so does never wolfenstein have any long wide corridors but many corners on its maps.
This raycast engine have its limitations !

When this is done so will i try to make it faster with linecast or something?

I have the weekend to work some more on it

Back to top

Profile PM Website

kaband

21

Years of Service

User Offline

Joined: 22nd May 2003

Location: Chicago

Posted: 4th Nov 2011 22:57

Link

Wow, this is so cool. Really nice work man. Can't wait to play with it.

Back to top

Profile PM

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 5th Nov 2011 13:34 Edited at: 5th Nov 2011 13:34

Link

Quote: "Wow, this is so cool. Really nice work man. Can't wait to play with it. "

Thanks.

Latest update with the floor!
Its currently slow as hell.
But is getting there.

Attachments

Login to view attachments

Back to top

Profile PM Website

Impetus73

13

Years of Service

User Offline

Joined: 28th Aug 2011

Location: Volda, Norway

Posted: 5th Nov 2011 16:33

Link

Could you post a video of it? so we get the feel of the thing?

----------------
AGK user - novice
Did Amiga / AMOS programming in the 90's, just started programming again with AGK.

Back to top

Profile PM Email

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 5th Nov 2011 18:40 Edited at: 5th Nov 2011 21:16

Link

I will release something playable tomorrow

Because i nead feedback on speed from you guys!

Hopefully will i solve the floor issues by then?
Wich in that turn solves the ceiling also

Edited..........
Added an screenie to show the crazy amount of sprites neaded to do the floor

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 5th Nov 2011 21:43 Edited at: 5th Nov 2011 21:49

Link

This is only for them that want to test the progress as its full of buggs and early in progress.
I know about the corner bugg and that the columns seams to wave some times.( iam doing something wrong with the positioning? )
Its very slow as agk seams to slow down if you create more then 15 000 sprites,even if they are not on screen all the time?

tab new random map.
space turns on and off the floor. ( Still not textured )

There is no source included in this as its a mess so far.

Edited....
One solution is to shrink the amount of rays but that makes it chunky.

Attachments

Login to view attachments

Back to top

Profile PM Website

bitJericho

22

Years of Service

User Offline

Joined: 9th Oct 2002

Location: United States

Posted: 6th Nov 2011 03:27 Edited at: 6th Nov 2011 03:28

Link

Solid 60fps for me, without the floor. 40fps as a low with the floor. I have a gtx260 and core 2 duo. It seems like you're making all kinds of sprites for the floor and calculating where walls are for it. What if you just render the floor first, then you don't really have to worry about culling it.

Back to top

Profile PM Email Website

The Zoq2

15

Years of Service

User Offline

Joined: 4th Nov 2009

Location: Linköping, Sweden

Posted: 6th Nov 2011 10:14

Link

Great work, 120 fps without floor 70 with floor on a GTX 550 Ti

Srry about my english im from sweeden

Back to top

Profile PM Email

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 6th Nov 2011 11:40

Link

Iam currently rewritting the whole raycasting system again.
I didt think it would be this much problems

I couldt use much from my dbp version and have to rewrite alot of it.

Quote: "Solid 60fps for me, without the floor. 40fps as a low with the floor. I have a gtx260 and core 2 duo. It seems like you're making all kinds of sprites for the floor and calculating where walls are for it. What if you just render the floor first, then you don't really have to worry about culling it."

Iam actually doing the walls first and then draws the floor where the walls reaches the floor

By doing it this way so do i not nead to place so many sprites for the floor.
If i do the floor first so will it use huge amounts of sprites all the time.
Now is the floor routine inside the wall loop and uses very little lines of code,because i use the same hit cordinate for the floor and walls.
But thanks for the feedback and trying it

Quote: "Great work, 120 fps without floor 70 with floor on a GTX 550 Ti"

Thanks for testing it

You must have an fast computer

Back to top

Profile PM Website

JimHawkins

15

Years of Service

User Offline

Joined: 26th Jul 2009

Location: Hull - UK

Posted: 6th Nov 2011 13:33

Link

Phenom II x4 810:

between 200 and 350 fps with no floor
between 48 and 90 with floor

There HAS to be a less intensive way of doing floors!

-- Jim

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 6th Nov 2011 14:10

Link

Quote: "There HAS to be a less intensive way of doing floors!"

Its the huge amount of sprites neaded that messes it up!
And that i havent solved the issues in agk to get the right texture pixel from an casted ray

Its the only way if you want various heights later on !
Then do you nead to draw the floor pixel by pixel

Back to top

Profile PM Website

bitJericho

22

Years of Service

User Offline

Joined: 9th Oct 2002

Location: United States

Posted: 6th Nov 2011 14:16 Edited at: 6th Nov 2011 14:17

Link

Perhaps you can optimize and only do individual sprites when there are floor changes nearby.

Back to top

Profile PM Email Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 6th Nov 2011 15:32 Edited at: 6th Nov 2011 15:33

Link

Quote: "Perhaps you can optimize and only do individual sprites when there are floor changes nearby."

I will try anything later on to speed things up!

But now do i only have to get the texture right on the floor

Agk dont support the amount of frames that i nead to do an 128x128 texture on the floor

So i use an 32x32 for the floor that i belive screws much of it up.
This is wath i have for the floor so far

And i have worked on it whole weekend

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 6th Nov 2011 21:39 Edited at: 6th Nov 2011 21:40

Link

Ok are wrapping things together for the first release of the source!
I removed the floor code as it sucked

So please give feedback and improvements on the raycaster

If anyone start working on any specific tasks like floor renderer or sprites let us know in this thread,and post your snippets to be added

A screenie while i put the files together and remove junk code.

Attachments

Login to view attachments

Back to top

Profile PM Website

Cliff Mellangard 3DEGS

Developer

18

Years of Service

User Offline

Joined: 20th Feb 2006

Location: Sweden

Posted: 6th Nov 2011 21:58 Edited at: 6th Nov 2011 21:59

Link

Here comes the source code to be embaressed about

Enjoy and let me know if you improve it

I want this to be an open source project for any agk user to have for there games.
With this do i mean i want your improvements not your games

First of all so is this an basic starter kit that is planned to grow.

And to be clear about it you are free to use it anyway you want.
But please give me some credit

You can download the zip file or cut and paste this!