[DBP] Water simulation, including waves, spashes, and water pressure, using cellular automata

Author

Message

lower logic

17

Years of Service

User Offline

Joined: 15th Jun 2006

Location:

Posted: 27th Dec 2006 05:25 Edited at: 27th Dec 2006 19:24

Link

I read about this in a book I got for christmas - game programming gems 3. This snippet models water using celluar automata.
Controls:
spacebar to start and play/pause simulation
left click to clear or draw walls (it will draw/erase based on if you click on a wall or not)
right click and mousemove to add flow to the water.

sync on
sync rate 0
cls
`hide mouse
global grid_width
global grid_height
global cell_size as float
cell_size=7
grid_width = screen width()/cell_size
grid_height = screen height()/cell_size

type xy_type
   x as float
   y as float
endtype

type cell_type
   flow as xy_type
   oldflow as xy_type
   mass as float
   solid
endtype

dim cell(grid_width,grid_height) as cell_type

for x=1 to grid_width-2
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=0.0
next y
next x

for x=0 to grid_width-1
   cell(x,0).solid=1
   cell(x,grid_height-1).solid=1
next x
for y=0 to grid_height-1
   cell(0,y).solid=1
   cell(grid_width-1,y).solid=1
next y
for x=1 to 48
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=1.0
cell(x,y).flow.x=0
next y
next x

global lasttimer=timer()
lasttimer=timer()
running=0
global rendermode=1
do
   cls
   if spacekey()=1 and spkey=0
      running=1-running
   endif
   spkey=spacekey()
   t#=FrameTime()
   `if running=1
      process_cells(t#*running)
      `process_cells(t#*running)
      `process_cells(t#*running)
   `endif
   if mouseclick()=1 and mc=0
      x=mousex()/cell_size
      y=mousey()/cell_size
      draw=1-cell(x,y).solid
   endif
      mmx#=mousemovex()
      mmy#=mousemovey()
   if mouseclick()=2
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=0 to grid_width-1
      if nx>=0 and nx<grid_width
      for ny=0 to grid_height-1
      if ny>=0 and ny<grid_height
      d#=((nx-x)^2+(ny-y)^2+0.0)*5
      if d#<10^2
         cell(nx,ny).flow.x=cell(nx,ny).flow.x+mmx#/d#
         cell(nx,ny).flow.y=cell(nx,ny).flow.y+mmy#/d#
      endif
      endif
      next ny
      endif
      next nx
   endif

mc=mouseclick()
   if mouseclick()=1
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
      cell(nx,ny).solid=draw
      endif
      next ny
      endif
      next nx
   endif
   sync
loop

function FrameTime()
   t#=(timer()-lasttimer)*0.001
   lasttimer=timer()
endfunction t#

function process_cells(time#)
for l=1 to 1
totalmass#=0
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         totalmass#=totalmass#+cell(x,y).mass
         if cell(x,y).solid=0
            if time#>0
               if cell(x,y+1).solid=0
                  diff#=-(cell(x,y+1).mass-cell(x,y).mass)
                  if (cell(x,y).mass>1 or cell(x,y+1).mass>1) and (cell(x,y+1).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x,y+1).mass+0.01)
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,88)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*3
                  else
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,260)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*0.6
                  endif
               endif
               if cell(x+1,y).solid=0
                  diff#=-(cell(x+1,y).mass-cell(x,y).mass)
                  if (cell(x,y).mass>1 or cell(x+1,y).mass>1) and (cell(x+1,y).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x+1,y).mass+0.01)
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,88)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*3
                  else
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,260)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*0.6
                  endif
              endif
            endif
         endif
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         cell(x,y).oldflow.x=cell(x,y).flow.x
         cell(x,y).oldflow.y=cell(x,y).flow.y
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
      if time#>0
            if cell(x,y).mass-cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=cell(x,y).mass
            endif
            if cell(x+1,y).mass+cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=-cell(x+1,y).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.x<0 then cell(x,y).oldflow.x=0
            endif
            if cell(x+1,y).solid=1
               if cell(x,y).oldflow.x>0 then cell(x,y).oldflow.x=0
            endif

cell(x,y).mass=cell(x,y).mass-cell(x,y).oldflow.x
            cell(x+1,y).mass=cell(x+1,y).mass+cell(x,y).oldflow.x

if cell(x,y).mass-cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=cell(x,y).mass
            endif
            if cell(x,y+1).mass+cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=-cell(x,y+1).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.y<0 then cell(x,y).oldflow.y=0
            endif
            if cell(x,y+1).solid=1
               if cell(x,y).oldflow.y>0 then cell(x,y).oldflow.y=0
            endif

cell(x,y).mass=cell(x,y).mass-(cell(x,y).oldflow.y)
            cell(x,y+1).mass=cell(x,y+1).mass+(cell(x,y).oldflow.y)

if cell(x,y).solid=0
               a#=1-cell(x-1,y).solid
               b#=1-cell(x,y-1).solid
               c#=1-cell(x+1,y).solid
               d#=1-cell(x,y+1).solid
               fx#=(cell(x-1,y).oldflow.x*a#+cell(x,y).oldflow.x*32+cell(x+1,y).oldflow.x*c#+cell(x,y-1).oldflow.x*b#+cell(x,y+1).oldflow.x*d#)/(32+a#+b#+c#+d#)
               fy#=(cell(x,y-1).oldflow.y*b#+cell(x,y).oldflow.y*32+cell(x,y+1).oldflow.y*d#+cell(x-1,y).oldflow.y*a#+cell(x+1,y).oldflow.y*c#)/(32+a#+b#+c#+d#)
               cell(x,y).flow.x=fx#
               cell(x,y).flow.y=fy#
               if cell(x,y+1).solid=0
                  cell(x,y).flow.y=cell(x,y).flow.y+time#*0.3
               endif
            endif

cell(x,y).flow.x=cell(x,y).flow.x*0.999
            cell(x,y).flow.y=cell(x,y).flow.y*0.999
         endif
      next y
   next x
   next l

if rendermode=1
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               m#=cell(x,y).mass
               if m#>1 then m#=1
               g#=cell(x,y).mass-1
               if g#<0 then g#=0
               if g#>1 then g#=1
               r#=cell(x,y).mass-2
               if r#<0 then r#=0
               if r#>1 then r#=1
               ink rgb((1-(m#)/1.0+r#)*255,(1-(m#)/1.0+g#-r#)*255,(1-g#)*255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
if rendermode=2
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               vx#=cell(x,y).flow.x*60
               vy#=cell(x,y).flow.y*60
               if vx#>1 then vx#=1
               if vx#<-1 then vx#=-1
               if vy#>1 then vy#=1
               if vy#<-1 then vy#=-1
               ink rgb(255.0*(1-abs(vx#)),255.0*(1-abs(vy#)),255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
endfunction

+ Code Snippet

sync on
sync rate 0
cls
`hide mouse
global grid_width
global grid_height
global cell_size as float
cell_size=7
grid_width = screen width()/cell_size
grid_height = screen height()/cell_size

type xy_type
   x as float
   y as float
endtype

type cell_type
   flow as xy_type
   oldflow as xy_type
   mass as float
   solid
endtype

dim cell(grid_width,grid_height) as cell_type

for x=1 to grid_width-2
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=0.0
next y
next x

for x=0 to grid_width-1
   cell(x,0).solid=1
   cell(x,grid_height-1).solid=1
next x
for y=0 to grid_height-1
   cell(0,y).solid=1
   cell(grid_width-1,y).solid=1
next y
for x=1 to 48
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=1.0
cell(x,y).flow.x=0
next y
next x

global lasttimer=timer()
lasttimer=timer()
running=0
global rendermode=1
do
   cls
   if spacekey()=1 and spkey=0
      running=1-running
   endif
   spkey=spacekey()
   t#=FrameTime()
   `if running=1
      process_cells(t#*running)
      `process_cells(t#*running)
      `process_cells(t#*running)
   `endif
   if mouseclick()=1 and mc=0
      x=mousex()/cell_size
      y=mousey()/cell_size
      draw=1-cell(x,y).solid
   endif
      mmx#=mousemovex()
      mmy#=mousemovey()
   if mouseclick()=2
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=0 to grid_width-1
      if nx>=0 and nx<grid_width
      for ny=0 to grid_height-1
      if ny>=0 and ny<grid_height
      d#=((nx-x)^2+(ny-y)^2+0.0)*5
      if d#<10^2
         cell(nx,ny).flow.x=cell(nx,ny).flow.x+mmx#/d#
         cell(nx,ny).flow.y=cell(nx,ny).flow.y+mmy#/d#
      endif
      endif
      next ny
      endif
      next nx
   endif

   mc=mouseclick()
   if mouseclick()=1
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
      cell(nx,ny).solid=draw
      endif
      next ny
      endif
      next nx
   endif
   sync
loop

function FrameTime()
   t#=(timer()-lasttimer)*0.001
   lasttimer=timer()
endfunction t#

function process_cells(time#)
for l=1 to 1
totalmass#=0
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         totalmass#=totalmass#+cell(x,y).mass
         if cell(x,y).solid=0
            if time#>0
               if cell(x,y+1).solid=0
                  diff#=-(cell(x,y+1).mass-cell(x,y).mass)
                  if (cell(x,y).mass>1 or cell(x,y+1).mass>1) and (cell(x,y+1).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x,y+1).mass+0.01)
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,88)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*3
                  else
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,260)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*0.6
                  endif
               endif
               if cell(x+1,y).solid=0
                  diff#=-(cell(x+1,y).mass-cell(x,y).mass)
                  if (cell(x,y).mass>1 or cell(x+1,y).mass>1) and (cell(x+1,y).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x+1,y).mass+0.01)
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,88)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*3
                  else
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,260)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*0.6
                  endif
              endif
            endif
         endif
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         cell(x,y).oldflow.x=cell(x,y).flow.x
         cell(x,y).oldflow.y=cell(x,y).flow.y
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
      if time#>0
            if cell(x,y).mass-cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=cell(x,y).mass
            endif
            if cell(x+1,y).mass+cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=-cell(x+1,y).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.x<0 then cell(x,y).oldflow.x=0
            endif
            if cell(x+1,y).solid=1
               if cell(x,y).oldflow.x>0 then cell(x,y).oldflow.x=0
            endif

            cell(x,y).mass=cell(x,y).mass-cell(x,y).oldflow.x
            cell(x+1,y).mass=cell(x+1,y).mass+cell(x,y).oldflow.x

            if cell(x,y).mass-cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=cell(x,y).mass
            endif
            if cell(x,y+1).mass+cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=-cell(x,y+1).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.y<0 then cell(x,y).oldflow.y=0
            endif
            if cell(x,y+1).solid=1
               if cell(x,y).oldflow.y>0 then cell(x,y).oldflow.y=0
            endif

            cell(x,y).mass=cell(x,y).mass-(cell(x,y).oldflow.y)
            cell(x,y+1).mass=cell(x,y+1).mass+(cell(x,y).oldflow.y)

            if cell(x,y).solid=0
               a#=1-cell(x-1,y).solid
               b#=1-cell(x,y-1).solid
               c#=1-cell(x+1,y).solid
               d#=1-cell(x,y+1).solid
               fx#=(cell(x-1,y).oldflow.x*a#+cell(x,y).oldflow.x*32+cell(x+1,y).oldflow.x*c#+cell(x,y-1).oldflow.x*b#+cell(x,y+1).oldflow.x*d#)/(32+a#+b#+c#+d#)
               fy#=(cell(x,y-1).oldflow.y*b#+cell(x,y).oldflow.y*32+cell(x,y+1).oldflow.y*d#+cell(x-1,y).oldflow.y*a#+cell(x+1,y).oldflow.y*c#)/(32+a#+b#+c#+d#)
               cell(x,y).flow.x=fx#
               cell(x,y).flow.y=fy#
               if cell(x,y+1).solid=0
                  cell(x,y).flow.y=cell(x,y).flow.y+time#*0.3
               endif
            endif

            cell(x,y).flow.x=cell(x,y).flow.x*0.999
            cell(x,y).flow.y=cell(x,y).flow.y*0.999
         endif
      next y
   next x
   next l

if rendermode=1
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               m#=cell(x,y).mass
               if m#>1 then m#=1
               g#=cell(x,y).mass-1
               if g#<0 then g#=0
               if g#>1 then g#=1
               r#=cell(x,y).mass-2
               if r#<0 then r#=0
               if r#>1 then r#=1
               ink rgb((1-(m#)/1.0+r#)*255,(1-(m#)/1.0+g#-r#)*255,(1-g#)*255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
if rendermode=2
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               vx#=cell(x,y).flow.x*60
               vy#=cell(x,y).flow.y*60
               if vx#>1 then vx#=1
               if vx#<-1 then vx#=-1
               if vy#>1 then vy#=1
               if vy#<-1 then vy#=-1
               ink rgb(255.0*(1-abs(vx#)),255.0*(1-abs(vy#)),255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
endfunction

If it runs slowly on your computer increase the cell_size variable (line 8) until it runs smoothly.

Screen shots:

Water travelling up a pipe into a bucket because of water pressure:

Splash fun:

Flowing water:

The change in colors from blue to green to red represents the water pressure.

Back to top

Profile PM

Mr Tank

21

Years of Service

User Offline

Joined: 25th Nov 2002

Location: United Kingdom

Posted: 27th Dec 2006 05:42

Link

This looks pretty awesome. I really have to go to bed now, but i'll definitely check it out properly later.

You'll be able to click on this someday.

Back to top

Profile PM Website

Kohaku

19

Years of Service

User Offline

Joined: 3rd May 2004

Location: The not very United Kingdom

Posted: 27th Dec 2006 06:16

Link

That's quite incredible!

You are not alone.

Back to top

Profile PM Website

Zotoaster

19

Years of Service

User Offline

Joined: 20th Dec 2004

Location: Scotland

Posted: 27th Dec 2006 14:14

Link

HOLY F***!

I know a bit about physics, made my own water simulation with help from Ric, but, oh, oh, this, this is just, incredible...

Back to top

Profile PM Email

Chris Franklin_

17

Years of Service

User Offline

Joined: 21st Dec 2006

Location: Home

Posted: 27th Dec 2006 14:18

Link

Quote: "HOLY F***!

I know a bit about physics, made my own water simulation with help from Ric, but, oh, oh, this, this is just, incredible..."

Ditto ^

Awesome man , keep it up

I've got a new account because all my order's go to my new e-mail.

Back to top

Profile PM

El Goorf

17

Years of Service

User Offline

Joined: 17th Sep 2006

Location: Uni: Manchester, Home: Dunstable

Posted: 27th Dec 2006 14:22

Link

Quote: "HOLY F***! "

Quote: "Ditto ^"

yes... very <censored> good.

Back to top

Profile PM Website

lower logic

17

Years of Service

User Offline

Joined: 15th Jun 2006

Location:

Posted: 27th Dec 2006 19:55 Edited at: 27th Dec 2006 20:20

Link

Thanks for all the comments. Cellular automata can also be used to simulate air flow (which can be used to simulate realistic explosions going around corners when in a confined space), heat transfer (conduction, convection, and radiation), and fire.

Just by removing the gravity and changing the code a bit, you have air/air pressure simulation:

sync on
sync rate 0
cls
`hide mouse
global grid_width
global grid_height
global cell_size as float
cell_size=8
grid_width = screen width()/cell_size
grid_height = screen height()/cell_size

type xy_type
   x as float
   y as float
endtype

type cell_type
   flow as xy_type
   oldflow as xy_type
   mass as float
   solid
endtype

dim cell(grid_width,grid_height) as cell_type

for x=1 to grid_width-2
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=0.0
next y
next x

for x=0 to grid_width-1
   cell(x,0).solid=1
   cell(x,grid_height-1).solid=1
next x
for y=0 to grid_height-1
   cell(0,y).solid=1
   cell(grid_width-1,y).solid=1
next y
for x=18 to 48
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=1.0
cell(x,y).flow.x=0
next y
next x

global lasttimer=timer()
lasttimer=timer()
running=0
global rendermode=1
do
   cls
   if spacekey()=1 and spkey=0
      running=1-running
   endif
   spkey=spacekey()
   t#=FrameTime()
   `if running=1
      process_cells(t#*running)
      `process_cells(t#*running)
      `process_cells(t#*running)
   `endif
   if mouseclick()=1 and mc=0
      x=mousex()/cell_size
      y=mousey()/cell_size
      draw=1-cell(x,y).solid
   endif
   if mouseclick()=2
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
         cell(nx,ny).mass=7
      endif
      next ny
      endif
      next nx
   endif

mc=mouseclick()
   if mouseclick()=1
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
      cell(nx,ny).solid=draw
      endif
      next ny
      endif
      next nx
   endif
   sync
loop

function FrameTime()
   t#=(timer()-lasttimer)*0.001
   lasttimer=timer()
endfunction t#

function process_cells(time#)
for l=1 to 1
totalmass#=0
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         totalmass#=totalmass#+cell(x,y).mass
         if cell(x,y).solid=0
            if time#>0
               if cell(x,y+1).solid=0
                  diff#=-(cell(x,y+1).mass-cell(x,y).mass)
                `  if (cell(x,y).mass>1 or cell(x,y+1).mass>1) and (cell(x,y+1).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x,y+1).mass+0.01)
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,128)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*5
                `  else
                `     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,160)
                `  endif
               endif
               if cell(x+1,y).solid=0
                  diff#=-(cell(x+1,y).mass-cell(x,y).mass)
                `  if (cell(x,y).mass>1 or cell(x+1,y).mass>1) and (cell(x+1,y).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x+1,y).mass+0.01)
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,128)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*5
               `   else
              `       cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,160)
              `    endif
              endif
            endif
         endif
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         cell(x,y).oldflow.x=cell(x,y).flow.x
         cell(x,y).oldflow.y=cell(x,y).flow.y
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
      if time#>0
            if cell(x,y).mass-cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=cell(x,y).mass
            endif
            if cell(x+1,y).mass+cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=-cell(x+1,y).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.x<0 then cell(x,y).oldflow.x=0
            endif
            if cell(x+1,y).solid=1
               if cell(x,y).oldflow.x>0 then cell(x,y).oldflow.x=0
            endif

cell(x,y).mass=cell(x,y).mass-cell(x,y).oldflow.x
            cell(x+1,y).mass=cell(x+1,y).mass+cell(x,y).oldflow.x

if cell(x,y).mass-cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=cell(x,y).mass
            endif
            if cell(x,y+1).mass+cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=-cell(x,y+1).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.y<0 then cell(x,y).oldflow.y=0
            endif
            if cell(x,y+1).solid=1
               if cell(x,y).oldflow.y>0 then cell(x,y).oldflow.y=0
            endif

cell(x,y).mass=cell(x,y).mass-(cell(x,y).oldflow.y)
            cell(x,y+1).mass=cell(x,y+1).mass+(cell(x,y).oldflow.y)

if cell(x,y).solid=0
               a#=1-cell(x-1,y).solid
               b#=1-cell(x,y-1).solid
               c#=1-cell(x+1,y).solid
               d#=1-cell(x,y+1).solid
               fx#=(cell(x-1,y).oldflow.x*a#+cell(x,y).oldflow.x*32+cell(x+1,y).oldflow.x*c#+cell(x,y-1).oldflow.x*b#+cell(x,y+1).oldflow.x*d#)/(32+a#+b#+c#+d#)
               fy#=(cell(x,y-1).oldflow.y*b#+cell(x,y).oldflow.y*32+cell(x,y+1).oldflow.y*d#+cell(x-1,y).oldflow.y*a#+cell(x+1,y).oldflow.y*c#)/(32+a#+b#+c#+d#)
               cell(x,y).flow.x=fx#
               cell(x,y).flow.y=fy#
               if cell(x,y+1).solid=0
              `   cell(x,y).flow.y=cell(x,y).flow.y+time#*0.1
               endif
            endif

cell(x,y).flow.x=cell(x,y).flow.x*0.999
            cell(x,y).flow.y=cell(x,y).flow.y*0.999
            cell(x,y).mass=cell(x,y).mass*0.995
         endif
      next y
   next x
   next l

if rendermode=1
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               m#=cell(x,y).mass
               if m#>1 then m#=1
               g#=cell(x,y).mass-1
               if g#<0 then g#=0
               if g#>1 then g#=1
               r#=cell(x,y).mass-2
               if r#<0 then r#=0
               if r#>1 then r#=1
               ink rgb((1-(m#)/1.0+r#)*255,(1-(m#)/1.0+g#-r#)*255,(1-g#)*255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
if rendermode=2
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               vx#=cell(x,y).flow.x*60
               vy#=cell(x,y).flow.y*60
               if vx#>1 then vx#=1
               if vx#<-1 then vx#=-1
               if vy#>1 then vy#=1
               if vy#<-1 then vy#=-1
               ink rgb(255.0*(1-abs(vx#)),255.0*(1-abs(vy#)),255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
endfunction

+ Code Snippet

sync on
sync rate 0
cls
`hide mouse
global grid_width
global grid_height
global cell_size as float
cell_size=8
grid_width = screen width()/cell_size
grid_height = screen height()/cell_size

type xy_type
   x as float
   y as float
endtype

type cell_type
   flow as xy_type
   oldflow as xy_type
   mass as float
   solid
endtype

dim cell(grid_width,grid_height) as cell_type

for x=1 to grid_width-2
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=0.0
next y
next x

for x=0 to grid_width-1
   cell(x,0).solid=1
   cell(x,grid_height-1).solid=1
next x
for y=0 to grid_height-1
   cell(0,y).solid=1
   cell(grid_width-1,y).solid=1
next y
for x=18 to 48
for y=1 to grid_height-2
cell(x,y).solid=0
cell(x,y).mass=1.0
cell(x,y).flow.x=0
next y
next x

global lasttimer=timer()
lasttimer=timer()
running=0
global rendermode=1
do
   cls
   if spacekey()=1 and spkey=0
      running=1-running
   endif
   spkey=spacekey()
   t#=FrameTime()
   `if running=1
      process_cells(t#*running)
      `process_cells(t#*running)
      `process_cells(t#*running)
   `endif
   if mouseclick()=1 and mc=0
      x=mousex()/cell_size
      y=mousey()/cell_size
      draw=1-cell(x,y).solid
   endif
   if mouseclick()=2
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
         cell(nx,ny).mass=7
      endif
      next ny
      endif
      next nx
   endif

   mc=mouseclick()
   if mouseclick()=1
      x=mousex()/cell_size
      y=mousey()/cell_size
      for nx=x-1 to x+1
      if nx>=0 and nx<grid_width
      for ny=y-1 to y+1
      if ny>=0 and ny<grid_height
      cell(nx,ny).solid=draw
      endif
      next ny
      endif
      next nx
   endif
   sync
loop

function FrameTime()
   t#=(timer()-lasttimer)*0.001
   lasttimer=timer()
endfunction t#

function process_cells(time#)
for l=1 to 1
totalmass#=0
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         totalmass#=totalmass#+cell(x,y).mass
         if cell(x,y).solid=0
            if time#>0
               if cell(x,y+1).solid=0
                  diff#=-(cell(x,y+1).mass-cell(x,y).mass)
                `  if (cell(x,y).mass>1 or cell(x,y+1).mass>1) and (cell(x,y+1).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x,y+1).mass+0.01)
                     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,128)
                     cell(x,y).flow.y=cell(x,y).flow.y+diff#*time#*5
                `  else
                `     cell(x,y).flow.y=curvevalue(diff#,cell(x,y).flow.y,160)
                `  endif
               endif
               if cell(x+1,y).solid=0
                  diff#=-(cell(x+1,y).mass-cell(x,y).mass)
                `  if (cell(x,y).mass>1 or cell(x+1,y).mass>1) and (cell(x+1,y).mass>cell(x,y).mass+0.01 or cell(x,y).mass>cell(x+1,y).mass+0.01)
                     cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,128)
                     cell(x,y).flow.x=cell(x,y).flow.x+diff#*time#*5
               `   else
              `       cell(x,y).flow.x=curvevalue(diff#,cell(x,y).flow.x,160)
              `    endif
              endif
            endif
         endif
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         cell(x,y).oldflow.x=cell(x,y).flow.x
         cell(x,y).oldflow.y=cell(x,y).flow.y
      next y
   next x
   for x=0 to grid_width-1
      for y=0 to grid_height-1
      if time#>0
            if cell(x,y).mass-cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=cell(x,y).mass
            endif
            if cell(x+1,y).mass+cell(x,y).oldflow.x<0
               cell(x,y).oldflow.x=-cell(x+1,y).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.x<0 then cell(x,y).oldflow.x=0
            endif
            if cell(x+1,y).solid=1
               if cell(x,y).oldflow.x>0 then cell(x,y).oldflow.x=0
            endif

            cell(x,y).mass=cell(x,y).mass-cell(x,y).oldflow.x
            cell(x+1,y).mass=cell(x+1,y).mass+cell(x,y).oldflow.x

            if cell(x,y).mass-cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=cell(x,y).mass
            endif
            if cell(x,y+1).mass+cell(x,y).oldflow.y<0
               cell(x,y).oldflow.y=-cell(x,y+1).mass
            endif
            if cell(x,y).solid=1
               if cell(x,y).oldflow.y<0 then cell(x,y).oldflow.y=0
            endif
            if cell(x,y+1).solid=1
               if cell(x,y).oldflow.y>0 then cell(x,y).oldflow.y=0
            endif

            cell(x,y).mass=cell(x,y).mass-(cell(x,y).oldflow.y)
            cell(x,y+1).mass=cell(x,y+1).mass+(cell(x,y).oldflow.y)

            if cell(x,y).solid=0
               a#=1-cell(x-1,y).solid
               b#=1-cell(x,y-1).solid
               c#=1-cell(x+1,y).solid
               d#=1-cell(x,y+1).solid
               fx#=(cell(x-1,y).oldflow.x*a#+cell(x,y).oldflow.x*32+cell(x+1,y).oldflow.x*c#+cell(x,y-1).oldflow.x*b#+cell(x,y+1).oldflow.x*d#)/(32+a#+b#+c#+d#)
               fy#=(cell(x,y-1).oldflow.y*b#+cell(x,y).oldflow.y*32+cell(x,y+1).oldflow.y*d#+cell(x-1,y).oldflow.y*a#+cell(x+1,y).oldflow.y*c#)/(32+a#+b#+c#+d#)
               cell(x,y).flow.x=fx#
               cell(x,y).flow.y=fy#
               if cell(x,y+1).solid=0
              `   cell(x,y).flow.y=cell(x,y).flow.y+time#*0.1
               endif
            endif

            cell(x,y).flow.x=cell(x,y).flow.x*0.999
            cell(x,y).flow.y=cell(x,y).flow.y*0.999
            cell(x,y).mass=cell(x,y).mass*0.995
         endif
      next y
   next x
   next l

if rendermode=1
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               m#=cell(x,y).mass
               if m#>1 then m#=1
               g#=cell(x,y).mass-1
               if g#<0 then g#=0
               if g#>1 then g#=1
               r#=cell(x,y).mass-2
               if r#<0 then r#=0
               if r#>1 then r#=1
               ink rgb((1-(m#)/1.0+r#)*255,(1-(m#)/1.0+g#-r#)*255,(1-g#)*255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
if rendermode=2
   for x=0 to grid_width-1
      for y=0 to grid_height-1
         if cell(x,y).solid=0
            if cell(x,y).mass>0
               vx#=cell(x,y).flow.x*60
               vy#=cell(x,y).flow.y*60
               if vx#>1 then vx#=1
               if vx#<-1 then vx#=-1
               if vy#>1 then vy#=1
               if vy#<-1 then vy#=-1
               ink rgb(255.0*(1-abs(vx#)),255.0*(1-abs(vy#)),255),0
            else
               ink -1,0
            endif
         else
            ink 0,0
         endif
         box x*cell_size,y*cell_size,(x+1)*cell_size,(y+1)*cell_size
         ink 0,0
       `  if abs(cell(x,y).flow.x)>0.1 or abs( cell(x,y).flow.y)>0.1
        `    line (x+0.5)*cell_size,(y+0.5)*cell_size,(x+0.5)*cell_size+cell(x,y).flow.x*60,(y+0.5)*cell_size+cell(x,y).flow.y*60
        ` endif
      next y
   next x
endif
endfunction

Changes between this snippet and the first snippet include:
-Removed gravity
-Removed water specific interaction
-Amplified the air sort of interaction (so waves last longer, but waves can also be tuned down or completely removed if wanted)
-Changed the right mouse click so that now increased the air pressure (waves propagate in all directions until they hit walls).
-Air eventually drains out of the system so the pressure can return to normal after a while.

An explosion going down a hallway:

A wall protecting the area behind it from the explosion, simulating realistic cover:

Back to top

Profile PM

jasonhtml

20

Years of Service

User Offline

Joined: 20th Mar 2004

Location: OC, California, USA

Posted: 28th Dec 2006 02:06

Link

this is absolutely fantastic! nice work!

forum.thegamecreators.com/?m=forum_view&t=78971&b=8&p=0
forum.thegamecreators.com/?m=forum_view&t=91115&b=32

Back to top

Profile PM Email Website

Sven B

19

Years of Service

User Offline

Joined: 5th Jan 2005

Location: Belgium

Posted: 28th Dec 2006 14:01

Link

It is indeed fantastic.
Too bad it consumes so much fps though

...

It's the programmer's life:
Have a problem, solve the problem, and have a new problem to solve.

Back to top

Profile PM Email

TEH_CODERER

20

Years of Service

User Offline

Joined: 12th Nov 2003

Location: Right behind you!

Posted: 28th Dec 2006 16:01

Link

Wow-ee! That is absolutely awesome!

Back to top

Profile PM Email

Zotoaster

19

Years of Service

User Offline

Joined: 20th Dec 2004

Location: Scotland

Posted: 28th Dec 2006 22:04

Link

Lower Logic - Straight as I am, will you marry me?

*Ahem*

You should write a tutorial

Back to top

Profile PM Email

Dared1111

17

Years of Service

User Offline

Joined: 25th Oct 2006

Location:

Posted: 29th Dec 2006 11:33 Edited at: 29th Dec 2006 22:06

Link

can you write a tutorial on how to write this sort of thing?

Game progress- 30 percent

Back to top

Profile PM Website

lower logic

17

Years of Service

User Offline

Joined: 15th Jun 2006

Location:

Posted: 29th Dec 2006 18:52

Link

Haha, thanks. I'll think about writing a tutorial.

Back to top

Profile PM

MadrMan

18

Years of Service

User Offline

Joined: 17th Dec 2005

Location: 0x5AB63C

Posted: 7th Jan 2007 14:22

Link

one word: "WOW"

Back to top

Profile PM

Ankillito

17

Years of Service

User Offline

Joined: 10th Dec 2006

Location: Litigious California

Posted: 10th Jan 2007 06:00

Link

Just browsing around, can't test it yet as DBP is in the mail. It looks awesome, but is there a practical, in terms of gaming use? Either way, it's still impressive and I haven't even run it.

"There will always be evil, for, without evil, the good shall lose their virtue."

Back to top

Profile PM

lower logic

17

Years of Service

User Offline

Joined: 15th Jun 2006

Location:

Posted: 10th Jan 2007 17:33 Edited at: 10th Jan 2007 17:35

Link

I haven't tried this in an actual game, so I'm not sure how practical it would be, but I can sum up what the book said:

It's only practical when the cells are large. In a FPS game, the cells would be cubes, and would need to be around 0.5 meters long on each edge. To accurately represent the open space, you'd want to use some algorithm that moved the corners of each cell so that they were flush with the floor/walls so water couldn't move through walls or floor. Also, when cells aren't doing anything you'd want to remove them from the loops to optimize the simulation.

In an actual game you'd use the data from the cells to figure out when objects should catch on fire and use your own fire animations from there. You'd calculate the damage from explosions based on the difference in air pressure and use your own models to show the damage.

For water it wouldn't be practical to simulate splashes in 3d games as rendering the shape of the 3d water would take a lot of calculations, so it'd only really be useful for water pressure simulation, which isn't needed in many games.

Back to top

Profile PM

Zotoaster

19

Years of Service

User Offline

Joined: 20th Dec 2004

Location: Scotland

Posted: 10th Jan 2007 20:32

Link

Well, lets not just think 3D. This simulation is in 2D, and I personally would be much more impressed playing a 2D game with effects like this, rather than playing a 3D game with effects that look fake.

Back to top

Profile PM Email

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 11th Jan 2007 01:27

Link

Very impressive indeed! 5 starts: *****

-db

GameDeveloper, make your own games with a drag-and-drop interface. Basically t3dgm+fpsc editor combined.
http://forum.thegamecreators.com/?m=forum_view&t=86045&b=8&p=2

Back to top

Profile PM Email Website

Sixty Squares

17

Years of Service

User Offline

Joined: 7th Jun 2006

Location: Somewhere in the world

Posted: 13th Jan 2007 03:33

Link

Wow.

Back to top

Profile PM Email

Ankillito

17

Years of Service

User Offline

Joined: 10th Dec 2006

Location: Litigious California

Posted: 15th Jan 2007 21:19

Link

Quote: "In an actual game you'd use the data from the cells to figure out when objects should catch on fire and use your own fire animations from there."

OIC. I just ran it now that I have DBP. I believe I agree with the aboved censored remark.

"There will always be evil, for, without evil, the good shall lose their virtue."

Back to top

Profile PM

fik

19

Years of Service

User Offline

Joined: 28th Sep 2004

Location:

Posted: 25th Jan 2007 13:39

Link

Totaly brilliant pice of work what more can be said.

Back to top

Profile PM

revenant chaos

Valued Member

17

Years of Service

User Offline

Joined: 21st Mar 2007

Location: Robbinsdale, MN

Posted: 5th Apr 2007 14:58

Link

this is absolutely amazing, this thing is even better then the 3d renderer that only uses 2d commands, and i thought that was incredible. Keep up the outstanding work.

I know what a hassle it would be to write a tutorial (in 9th grade I wrote a tutorial for the Texas instruments TI-83+ basic and distributed it to my class mates, who kept asking me to teach them, but never bothered to learn), but a tutorial in this sort of thing could bring the whole forum up to speed. I cant possibly see a tutorial of this sort going to waste, and it would be much appreciated if you could take some time to make some progressively more complex lessons.

keep rockin' on lower logic

Back to top

Profile PM Email Website

Dared1111

17

Years of Service

User Offline

Joined: 25th Oct 2006

Location:

Posted: 22nd Jun 2007 21:44

Link

revival!!!

gets out pads, others need to see this...

Your signature has been erased by a mod because it was too big

Back to top

Profile PM Website

qwe

20

Years of Service

User Offline

Joined: 3rd Sep 2003

Location: place

Posted: 26th Jun 2007 18:35

Link

Conway's Game of Life is a cellular automata program which is easy to code. look into that (wikipedia it) and code your own Game of Life if you want to get started with cellular automata. you might want to pick up a physics textbook if you want to make a water simulation:p

here's a simple but inefficient Game of Life in DBP

REM Ini
sync on
sync rate 60

REM Var
dim a(256,256)
dim b(256,256)

REM Setup array...
`This adds a glider
a(210,210) = 1
a(211,210) = 1
a(212,210) = 1
a(210,211) = 1
a(211,212) = 1
`This adds random stuff
for x = 1 to 254
	for y = 1 to 150
		if rnd(2) = 0 then a(x, y) = 1
	next y
next x

REM Main
do
	
	step_grid()
	display_grid()
	user_modify_grid()
	
	sync
loop

function step_grid()
	
	`clear b and store counts
	for x = 1 to 254
		for y = 1 to 254
			
			b(x,y) = 0
			
			for a = -1 to 1
				for b = -1 to 1
					
					if a = 0 and b = 0
						
					else
						if a(x+a,y+b) = 1 then inc b(x,y)
					endif
					
				next b
			next a
			
		next y
	next x
	
	`clear a and reset cells
	for x = 0 to 254
		for y = 0 to 254
			
			if a(x,y) = 0
				if b(x,y) = 3 then a(x,y) = 1
			else
				if b(x,y) < 2 or b(x,y) > 3 then a(x,y) = 0
			endif
			
		next y
	next x
	
endfunction

function display_grid()
	
	cls
	print screen fps()
	
	for x = 0 to 254
		for y = 0 to 254
			if a(x,y) = 1 then box x,y,x+1,y+1
		next y
	next x
	
endfunction

function user_modify_grid()
	
	if mouseclick()
		if mousex() < 256 and mousey() < 256
			a(mousex(), mousey()) = 1
		endif
	endif
	
endfunction

+ Code Snippet

REM Ini
sync on
sync rate 60

REM Var
dim a(256,256)
dim b(256,256)

REM Setup array...
`This adds a glider
a(210,210) = 1
a(211,210) = 1
a(212,210) = 1
a(210,211) = 1
a(211,212) = 1
`This adds random stuff
for x = 1 to 254
	for y = 1 to 150
		if rnd(2) = 0 then a(x, y) = 1
	next y
next x

REM Main
do
	
	step_grid()
	display_grid()
	user_modify_grid()
	
	sync
loop

function step_grid()
	
	`clear b and store counts
	for x = 1 to 254
		for y = 1 to 254
			
			b(x,y) = 0
			
			for a = -1 to 1
				for b = -1 to 1
					
					if a = 0 and b = 0
						
					else
						if a(x+a,y+b) = 1 then inc b(x,y)
					endif
					
				next b
			next a
			
		next y
	next x
	
	`clear a and reset cells
	for x = 0 to 254
		for y = 0 to 254
			
			if a(x,y) = 0
				if b(x,y) = 3 then a(x,y) = 1
			else
				if b(x,y) < 2 or b(x,y) > 3 then a(x,y) = 0
			endif
			
		next y
	next x
	
endfunction

function display_grid()
	
	cls
	print screen fps()
	
	for x = 0 to 254
		for y = 0 to 254
			if a(x,y) = 1 then box x,y,x+1,y+1
		next y
	next x
	
endfunction

function user_modify_grid()
	
	if mouseclick()
		if mousex() < 256 and mousey() < 256
			a(mousex(), mousey()) = 1
		endif
	endif
	
endfunction

Back to top

Profile PM Email

RomuluS85

18

Years of Service

User Offline

Joined: 10th Apr 2006

Location:

Posted: 1st Jul 2007 20:51

Link

i'm attempting to port that in to DBGDK...
uuh... what the h*ck does:
diff# =-(cell(x,y+1).mass - cell(x,y).mass)
mean (that minus sign in the beginning to be exact...)

been a while since i last wrote DBPro code...

Back to top

Profile PM

RomuluS85

18

Years of Service

User Offline

Joined: 10th Apr 2006

Location:

Posted: 1st Jul 2007 23:11

Link

hmm... and in addition, i'm thinking about implementing that to a game... for example, for a grenade shockwave...

and one thing that came to my mind is:
does it really need to update the whole surroundings...
i mean, if you have a grenade it's shock wave has a theoretical maximum distance it can travel (before the wave becomes so small that it has no effect what so ever...)

take a smaller search "matrix" (x,y square) and fill it with the terrain around the grenade, do the Cellural Automata code for that and it should speed up a lot (since the search area is alot smaller).
this in addition could be used to give vector to the leafs / dust fx etc...

Back to top

Profile PM

Brain111

17

Years of Service

User Offline

Joined: 5th Feb 2007

Location: In my own little world.

Posted: 9th Jul 2007 06:35

Link

That's delicious.

Maybe there would be a fast way to use large cells but somehow render something other than squares to make them look smoothe? I don't necessesarilly mean just render dots, but I don't know what I'm thinking. Just some sort of way to make it look like a blob rather than a brick.

Anarchy Burger - hold the Government!

Back to top

Profile PM

Turoid

20

Years of Service

User Offline

Joined: 1st Nov 2003

Location: The Netherlands

Posted: 9th Jul 2007 12:47

Link

That is really good! I thought that my fluid simulation was cool

NICE WORK!!

I am awesome and always right.

Back to top

Profile PM

the carcinogen

16

Years of Service

User Offline

Joined: 2nd Aug 2007

Location:

Posted: 2nd Aug 2007 09:21

Link

there is a game called Plasma Pong that was a winner at this year's Slamdance Guerilla Gamemaker Competition. It uses fluid dynamics in almost the same format to create an incredible game of Pong.

you can check it out at http://www.plasmapong.com.

Back to top

Profile PM

Sorry your browser is not supported!

Code Snippets / [DBP] Water simulation, including waves, spashes, and water pressure, using cellular automata