Sorry your browser is not supported!

Rem Project: zombie
Rem Created: Sunday, December 18, 2011

Rem ***** Main Source File *****
sync on : sync rate 60  : w = screen width() : h = screen height()

global node_dist = 10
node_dificulty = 5
node_xcount = w/node_dist : node_ycount = h/node_dist

dim n(node_xcount,node_ycount) as UDTnode

for i = 1 to node_xcount : for j = 1 to node_ycount
    n(i,j).x# = i*node_dist : n(i,j).y# = j*node_dist
    n(i,j).cost# = 1 
    if rnd(node_dificulty) > 1 then n(i,j).exist = 1
    n(i,j).i = i : n(i,j).j = j 
NEXT : next
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
    if n(i,j).exist = 0 
            accepted = 0        
            if n(i-1,j).exist = 0 then accepted = 1 
            if n(i+1,j).exist = 0 then accepted = 1 
            if n(i,j+1).exist = 0 then accepted = 1 
            if n(i,j-1).exist = 0 then accepted = 1 
            if accepted = 0 then n(i,j).exist = 1   
    ENDIF
NEXT : next

node_color1 = rgb(40,80,160)
node_color2 = rgb(160,80,40)
node_color3 = rgb(60,120,240)
node_color4 = rgb(255,40,10)


dim open(9) as UDTnode
dim path(100000) as UDTnode

do

    mx# = mousex() : my# = mousey() 
    node_mx = getnode(mx#) : node_my = getnode(my#)
    
    for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
        if n(i,j).exist = 1 then a2dot n(i,j).x#,n(i,j).y#,node_color1 
        if n(i,j).exist = 0 
            a2dot n(i,j).x#,n(i,j).y#,node_color2
            if n(i,j).status = 1 then a2circle n(i,j).x#,n(i,j).y#,5,rgb(255,0,0)
            if n(i-1,j).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i-1,j).x#,n(i-1,j).y#,node_color2 
            if n(i,j-1).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i,j-1).x#,n(i,j-1).y#,node_color2
        endif        
    NEXT : next
    
    for i = 1 to pathlength
        if i > 1 then a2line n(path(i).i,path(i).j).x#,n(path(i).i,path(i).j).y#,n(path(i-1).i,path(i-1).j).x#,n(path(i-1).i,path(i-1).j).y#,node_color4 
    NEXT
    
    if mouseclick() = 1 and clicked = 0
        if n(node_mx,node_my).exist = 1 
            zx# = n(node_mx,node_my).x# : zy# = n(node_mx,node_my).y# 
            node_zx = node_mx : node_zy = node_my
            gosub _getpath:
            clicked = 1
        endif
        else
        if mouseclick() = 0 then clicked = 0
    endif
    
    if mouseclick() = 2 
        if n(node_mx,node_my).exist = 1 then targetx# = n(node_mx,node_my).x# : targety# = n(node_mx,node_my).y#    
        node_targetx = node_mx : node_targety = node_my                         
    ENDIF
    print A_closedcount
    a2circle targetx#,targety#,node_dist,node_color3
    a2circle targetx#,targety#,node_dist/2,node_color3
    
    a2circle zx#,zy#,node_dist/2,node_color4
    a2circle zx#,zy#,node_dist/4,node_color4
    
    
    sync
    cls
LOOP

_getpath:
for i = 1 to pathlength
    n(path(i).i,path(i).j).status = 0
NEXT

A_closedcount = 0

repeat 
n(node_zx,node_zy).status = 1
A_opencount = 0 
for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
    if k > 0 and k < node_xcount and o > 0 and o < node_ycount
    if n(k,o).status = 0 and n(k,o).exist = 1 
        inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
        rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)*0.5+abs(o-node_zy)*0.5
        open(A_opencount).value# = dist(k,o,node_targetx,node_targety)
    endif   
    endif
NEXT : next

if A_opencount = 0 
    A_failcheck = 0
    repeat
    inc A_failcheck
    node_zx = path(A_closedcount-A_failcheck).i : node_zy = path(A_closedcount-A_failcheck).j
    for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
        if k > 0 and k < node_xcount and o > 0 and o < node_ycount
            if n(k,o).status = 0 and n(k,o).exist = 1 
                inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
                rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)+abs(o-node_zy)
                open(A_opencount).value# = dist(k,o,node_targetx,node_targety)
            endif   
        endif
    NEXT : next
    until A_opencount > 0
endif

if A_opencount > 0
    A_openmin# = 100000 : A_openmini = 0
    for i = 1 to A_opencount
        if open(i).value# < A_openmin# then A_openmin# = open(i).value# : A_openmini = i    
    NEXT
    inc A_closedcount

    if A_closedcount < 10000
        path(A_closedcount).i = open(A_openmini).i : path(A_closedcount).j = open(A_openmini).j
        node_zx = path(A_closedcount).i : node_zy = path(A_closedcount).j
    endif
endif

until path(A_closedcount).i = node_targetx and path(A_closedcount).j = node_targety or A_closedcount > 10000

pathlength = A_closedcount

return

type UDTnode
    x# : y# 
    cost# : exist
    i : j 
    px : py
    status
    value#
endtype

type UDTzombiedata
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd  
endtype  
type UDTzombie
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
    pathlength
    dat as UDTzombiedata
endtype


function nodedot(x#,y#)
    x = getnode(x#) : y = getnode(y#) : nx# = n(x,y).x# : ny# = n(x,y).y#
    a2fillcircle nx#,ny#,2,rgb(255,255,255) 
ENDFUNCTION

function getnode(x#)
     c = int(x#/node_dist+0.5)
ENDFUNCTION c

function dist(x1#,y1#,x2#,y2#)
    d# = sqrt((x1#-x2#)^2+(y1#-y2#)^2)
ENDFUNCTION d#

Rem Project: zombie
Rem Created: Sunday, December 18, 2011

Rem ***** Main Source File *****
sync on : sync rate 60  : w = screen width() : h = screen height()

global node_dist = 10
node_dificulty = 5
node_xcount = w/node_dist : node_ycount = h/node_dist

dim n(node_xcount,node_ycount) as UDTnode

for i = 1 to node_xcount : for j = 1 to node_ycount
    n(i,j).x# = i*node_dist : n(i,j).y# = j*node_dist
    n(i,j).cost# = 1 
    if rnd(node_dificulty) > 1 then n(i,j).exist = 1
    n(i,j).i = i : n(i,j).j = j 
NEXT : next
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
    if n(i,j).exist = 0 
            accepted = 0        
            if n(i-1,j).exist = 0 then accepted = 1 
            if n(i+1,j).exist = 0 then accepted = 1 
            if n(i,j+1).exist = 0 then accepted = 1 
            if n(i,j-1).exist = 0 then accepted = 1 
            if accepted = 0 then n(i,j).exist = 1   
    ENDIF
NEXT : next

node_color1 = rgb(40,80,160)
node_color2 = rgb(160,80,40)
node_color3 = rgb(60,120,240)
node_color4 = rgb(255,40,10)


dim open(9) as UDTnode
dim path(100000) as UDTnode

do

    mx# = mousex() : my# = mousey() 
    node_mx = getnode(mx#) : node_my = getnode(my#)
    
    for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
        if n(i,j).exist = 1 then dot n(i,j).x#,n(i,j).y#,node_color1 
        if n(i,j).exist = 0 
            dot n(i,j).x#,n(i,j).y#,node_color2
            if n(i,j).status = 1 then circle n(i,j).x#,n(i,j).y#,5
            if n(i-1,j).exist = 0 then line n(i,j).x#,n(i,j).y#,n(i-1,j).x#,n(i-1,j).y#
            if n(i,j-1).exist = 0 then line n(i,j).x#,n(i,j).y#,n(i,j-1).x#,n(i,j-1).y#
        endif        
    NEXT : next
    
    for i = 1 to pathlength
        if i > 1 then line n(path(i).i,path(i).j).x#,n(path(i).i,path(i).j).y#,n(path(i-1).i,path(i-1).j).x#,n(path(i-1).i,path(i-1).j).y#
    NEXT
    
    if mouseclick() = 1 and clicked = 0
        if n(node_mx,node_my).exist = 1 
            zx# = n(node_mx,node_my).x# : zy# = n(node_mx,node_my).y# 
            node_zx = node_mx : node_zy = node_my
            gosub _getpath:
            clicked = 1
        endif
        else
        if mouseclick() = 0 then clicked = 0
    endif
    
    if mouseclick() = 2 
        if n(node_mx,node_my).exist = 1 then targetx# = n(node_mx,node_my).x# : targety# = n(node_mx,node_my).y#    
        node_targetx = node_mx : node_targety = node_my                         
    ENDIF
    
    print A_closedcount
    
    circle targetx#,targety#,node_dist
    circle targetx#,targety#,node_dist/2
    
    circle zx#,zy#,node_dist/2
    circle zx#,zy#,node_dist/4
    
    
    sync
    cls
LOOP

_getpath:
for i = 1 to pathlength
    n(path(i).i,path(i).j).status = 0
NEXT

A_closedcount = 0

repeat 
n(node_zx,node_zy).status = 1
A_opencount = 0 
for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
    if k > 0 and k < node_xcount and o > 0 and o < node_ycount
    if n(k,o).status = 0 and n(k,o).exist = 1 
        inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
        rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)*0.5+abs(o-node_zy)*0.5
        open(A_opencount).value# = dist(k,o,node_targetx,node_targety)
    endif   
    endif
NEXT : next

if A_opencount = 0 
    A_failcheck = 0
    repeat
    inc A_failcheck
    node_zx = path(A_closedcount-A_failcheck).i : node_zy = path(A_closedcount-A_failcheck).j
    for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
        if k > 0 and k < node_xcount and o > 0 and o < node_ycount
            if n(k,o).status = 0 and n(k,o).exist = 1 
                inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
                rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)+abs(o-node_zy)
                open(A_opencount).value# = dist(k,o,node_targetx,node_targety)
            endif   
        endif
    NEXT : next
    until A_opencount > 0
endif

if A_opencount > 0
    A_openmin# = 100000 : A_openmini = 0
    for i = 1 to A_opencount
        if open(i).value# < A_openmin# then A_openmin# = open(i).value# : A_openmini = i    
    NEXT
    inc A_closedcount

    if A_closedcount < 10000
        path(A_closedcount).i = open(A_openmini).i : path(A_closedcount).j = open(A_openmini).j
        node_zx = path(A_closedcount).i : node_zy = path(A_closedcount).j
    endif
endif

until path(A_closedcount).i = node_targetx and path(A_closedcount).j = node_targety or A_closedcount > 10000

pathlength = A_closedcount

return

type UDTnode
    x# : y# 
    cost# : exist
    i : j 
    px : py
    status
    value#
endtype

type UDTzombiedata
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd  
endtype  
type UDTzombie
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
    pathlength
    dat as UDTzombiedata
endtype


function getnode(x#)
     c = int(x#/node_dist+0.5)
ENDFUNCTION c

function sqaredist(x1#,y1#,x2#,y2#)
    d# = (x1#-x2#)^2+(y1#-y2#)^2
ENDFUNCTION d#
function dist(x1#,y1#,x2#,y2#)
    d# = sqrt((x1#-x2#)^2+(y1#-y2#)^2)
ENDFUNCTION d#

Rem Project: zombie
Rem Created: Sunday, December 18, 2011

Rem ***** Main Source File *****
sync on : sync rate 60  : w = screen width() : h = screen height()

global node_dist = 10
node_dificulty = 3
node_blocksize = 4
node_xcount = w/node_dist : node_ycount = h/node_dist

dim n(node_xcount,node_ycount) as UDTnode

for i = 1 to node_xcount : for j = 1 to node_ycount
    n(i,j).x# = i*node_dist : n(i,j).y# = j*node_dist
    n(i,j).cost# = 1 
    n(i,j).exist = 1
    n(i,j).i = i : n(i,j).j = j 
NEXT : next
for i = 1 to node_xcount-node_blocksize step node_blocksize : for j = 1 to node_ycount-node_blocksize step node_blocksize
  if rnd(node_dificulty) < 2 
        for k = 0 to node_blocksize : for o = 0 to node_blocksize
            n(i+k,j+o).exist = 0
        next : next
  endif
next : next
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
    if n(i,j).exist = 0 
            accepted = 0                  
            if n(i-1,j).exist = 0 then accepted = 1 
            if n(i+1,j).exist = 0 then accepted = 1 
            if n(i,j+1).exist = 0 then accepted = 1 
            if n(i,j-1).exist = 0 then accepted = 1 
            if accepted = 0 then n(i,j).exist = 1   
    ENDIF
NEXT : next

node_color1 = rgb(40,80,160)
node_color2 = rgb(160,80,40)

node_color3 = rgb(60,120,240)
node_color4 = rgb(255,40,10)
node_color41 = rgb(120,20,5)


dim open(9) as UDTnode
dim path(100000) as UDTnode

do

    mx# = mousex() : my# = mousey() 
    node_mx = getnode(mx#) : node_my = getnode(my#)
    
    for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
        if n(i,j).exist = 1 then a2dot n(i,j).x#,n(i,j).y#,node_color1 
        if n(i,j).exist = 0 
            a2dot n(i,j).x#,n(i,j).y#,node_color2           
            if n(i-1,j).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i-1,j).x#,n(i-1,j).y#,node_color2 
            if n(i,j-1).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i,j-1).x#,n(i,j-1).y#,node_color2
        endif        
    NEXT : next
    
    for i = 1 to pathlength
        if i > 1 then a2line n(path(i).i,path(i).j).x#,n(path(i).i,path(i).j).y#,n(path(i-1).i,path(i-1).j).x#,n(path(i-1).i,path(i-1).j).y#,rgb(100,255*i/pathlength,0)
    NEXT
    
    if mouseclick() = 1 and clicked = 0
        if n(node_mx,node_my).exist = 1 
            zx# = n(node_mx,node_my).x# : zy# = n(node_mx,node_my).y# 
            node_zx = node_mx : node_zy = node_my
            gosub _getpath:
            clicked = 1
        endif
        else
        if mouseclick() = 0 then clicked = 0
    endif
    
    if mouseclick() = 2 
        if n(node_mx,node_my).exist = 1 then targetx# = n(node_mx,node_my).x# : targety# = n(node_mx,node_my).y#    
        node_targetx = node_mx : node_targety = node_my                         
    ENDIF
    print A_closedcount
    a2circle targetx#,targety#,node_dist,node_color3
    a2circle targetx#,targety#,node_dist/2,node_color3
    
    a2circle zx#,zy#,node_dist/2,node_color4
    a2circle zx#,zy#,node_dist/4,node_color4
      
    sync
    cls
    
LOOP

_getpath:
for i = 0 to pathlength+10
    n(path(i).i,path(i).j).status = 0
NEXT

A_closedcount = 0

repeat 
n(node_zx,node_zy).status = 1
A_opencount = 0 
for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
    if k > 0 and k < node_xcount and o > 0 and o < node_ycount
    if n(k,o).status = 0 and n(k,o).exist = 1 
        inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
        rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)*0.5+abs(o-node_zy)*0.5
        open(A_opencount).value# = dist(k,o,node_targetx,node_targety)+dist(k,o,node_zx,node_zy)
    endif   
    endif
NEXT : next

if A_opencount = 0 
    A_failcheck = 0
    repeat
    inc A_failcheck
    node_zx = path(A_closedcount-A_failcheck).i : node_zy = path(A_closedcount-A_failcheck).j
    for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
        if k > 0 and k < node_xcount and o > 0 and o < node_ycount
            if n(k,o).status = 0 and n(k,o).exist = 1 
                inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
                rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)+abs(o-node_zy)
                open(A_opencount).value# = dist(k,o,node_targetx,node_targety)+dist(k,o,node_zx,node_zy)
            endif   
        endif
    NEXT : next
    until A_opencount > 0
    A_closedcount = A_closedcount-A_failcheck
endif

if A_opencount > 0
    A_openmin# = 10000000 : A_openmini = 0
    for i = 1 to A_opencount
        if open(i).value# < A_openmin# then A_openmin# = open(i).value# : A_openmini = i    
    NEXT
    inc A_closedcount

    if A_closedcount < 10000
        path(A_closedcount).i = open(A_openmini).i : path(A_closedcount).j = open(A_openmini).j
        node_zx = path(A_closedcount).i : node_zy = path(A_closedcount).j
    endif
endif

until path(A_closedcount).i = node_targetx and path(A_closedcount).j = node_targety or A_closedcount > 10000

pathlength = A_closedcount

return

type UDTnode
    x# : y# 
    cost# : exist
    i : j 
    px : py
    status
    value#
endtype

type UDTdeffender
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
endtype
type UDTzombiedata
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd  
endtype  
type UDTzombie
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
    pathlength
    dat as UDTzombiedata
endtype


function nodedot(x#,y#)
    x = getnode(x#) : y = getnode(y#) : nx# = n(x,y).x# : ny# = n(x,y).y#
    a2fillcircle nx#,ny#,2,rgb(255,255,255) 
ENDFUNCTION

function getnode(x#)
     c = int(x#/node_dist+0.5)
ENDFUNCTION c

function dimscreen(dimness as dword)
    a2setblendmode 2,2,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function softdimscreen(dimness as dword)
    a2setblendmode 2,10,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function sqaredist(x1#,y1#,x2#,y2#)
    d# = (x1#-x2#)^2+(y1#-y2#)^2
ENDFUNCTION d#
function dist(x1#,y1#,x2#,y2#)
    d# = sqrt((x1#-x2#)^2+(y1#-y2#)^2)
ENDFUNCTION d#
remstart
function borderx(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cx# = w
        if x# <= 0 then cx# = 0
    endif
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cx# = (h/2.0)/k#+w/2.0
        if y# <= 0 then cx# = w/2.0-(h/2.0)/k#
    endif
    else
    cx# = -1000
    endif
ENDfunction cx#
function bordery(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cy# = k#*(w/2.0)+h/2.0 
        if x# <= 0 then cy# = h/2.0-k#*(w/2.0)
    endif 
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cy# = h
        if y# <= 0 then cy# = 0 
    eNDIF
    else
    cy# = -1000
    endif
ENDfunction cy#
remend

    node_zx = path(A_closedcount-A_failcheck).i : node_zy = path(A_closedcount-A_failcheck).j

Get START location
Get Goal location

Check Start location, I call it (Center Point)
Check all direction from (Center Point)

Give all nine location we just check a Rating value, the closer it is to the GOAL location, the lower the value.

Flag all nine location so we don't check it again.

Check all locations that has a Rating value and select the lowest value as the next (Center Point).

Flag this new (Center Point) location so we don't check it again.

-REPEAT- Until reaches GOAL.

Remstart
***********************************************************
	Astar Pathfinding Example
	By Ashinga
***********************************************************
This is not quite the standard example as everything is
renamed to my preference. This is pretty much just taken
right out of my own project and added with a mess load
of remarks. Hope it helps.

***********************************************************
Controls:
	L-Click: Place walls
	R-Click: Erase walls

	L-Click + (1)Button: Set the START location
	L-Click + (2)Button: Set the GOAL location
	
	(R)Button: Reveals the Rate values
	(D)Button: Reveals the Dist values
	(C)Button: Reveals the Cost values
	
	Returnkey: Astar Pathfinding
***********************************************************
Remend


sync on
sync rate 0

REM This is the array size, change at will.
global YourMapX
global YourMapY
YourMapX = 10
YourMapY = 10
dim YourMapArray(YourMapX,YourMapY)


REM Initialize the Astar variables/arrays
gosub InitializeAstar


REM START/GOAL preset values, change at will.
StartX = 2
StartY = 2
GoalX = 5
GoalY = 5


REM Main Loop
do

	gosub Render_Maps
	gosub Handle_Control

	sync
loop


	Handle_Control:
		if returnkey()
			if KeyR = 0
				REM Press return to run Astar
				WayPointCount = Astar(StartX,StartY,GoalX,GoalY)
			endif
			KeyR = 1
			else
			KeyR = 0
		endif
		
		REM Mouse Control
		if mouseclick()
			WayPointCount = -1
			Option = 0
			if keystate(2) then Option = 1
			if keystate(3) then Option = 2
			REM Normal Left and Right-Click to modify Walls
			if Option = 0
				if mouseclick() = 1
					YourMapArray(mousex()/25,mousey()/25) = 1
					else
					YourMapArray(mousex()/25,mousey()/25) = 0
				endif
			endif
			REM Hold 1 and Left-Click to set START
			if Option = 1 then StartX = mousex()/25 : StartY = mousey()/25
			REM Hold 2 and Left-Click to set GOAL
			if Option = 2 then GoalX = mousex()/25 : GoalY = mousey()/25
		endif
		
		ink 0,0
		for lpy = 0 to YourMapY
		for lpx = 0 to YourMapX
			x = lpx*25
			y = lpy*25
			if keystate(19) then text x,y,str$(Rate(lpx,lpy))
			if keystate(32) then text x,y,str$(Dist(lpx,lpy))
			if keystate(46) then text x,y,str$(Cost(lpx,lpy))
		next lpx
		next lpy
	return




	REM Graphical Display
	Render_Maps:
		
		for lpy = 0 to YourMapY
		for lpx = 0 to YourMapX
			x = lpx*25
			y = lpy*25
			if YourMapArray(lpx,lpy) = 0 then ink rgb(255,255,255),0	REM Null
			if YourMapArray(lpx,lpy) = 1 then ink rgb(155,155,155),0	REM Wall?
			box x,y,x+24,y+24
		next lpx
		next lpy
		
		REM START Area
		x = StartX*25+5
		y = StartY*25+5
		ink rgb(0,255,0),0
		box x,y,x+14,y+14
		
		REM GOAL Area
		x = GoalX*25+5
		y = GoalY*25+5
		ink rgb(255,0,0),0
		box x,y,x+14,y+14
		
		REM WayPoint
		ink rgb(0,0,255),0
		for lp = 0 to WayPointCount
			x2 = WayPointX(lp)*25+10
			y2 = WayPointY(lp)*25+10
			box x2,y2,x2+4,y2+4
			
			if lp > 0
				x1 = WayPointX(lp-1)*25+10
				y1 = WayPointY(lp-1)*25+10
				line x1,y1,x2,y2
			endif
		next lp

	return
	
	



REM ****************************************************************************************************
REM 					Astar Initialize
REM ****************************************************************************************************

InitializeAstar:
	REM The Astar array size should be the same as your map or GREATER
	global AstarMapX
	global AstarMapY
	global AstarMapMax
	AstarMapX = YourMapX
	AstarMapY = YourMapY
	AstarMapMax = AstarMapX*AstarMapY
	
	REM The "Distance" array records how far away the GOAL is to the currently checked position.
	dim Dist(AstarMapX,AstarMapY)
	
	REM The "Cost" array records how many movements or checks it has already taken or performed.
	dim Cost(AstarMapX,AstarMapY)
	
	REM The "Rate" array is the overal value or "Score" of Dist+Cost. Astar starts searching at
	REM the START position and ends checking at the GOAL position, but when recording the path
	REM or "WayPoint" it starts recording from the Goal and find it's way back to the START based
	REM on the values stored on these arrays
	dim Rate(AstarMapX,AstarMapY)
	
	
	REM The Record X and Y array records which direction you are checking from. Once the checks reaches
	REM the GOAL this allows you to re-trace your path back to the START and recording the path onto the
	REM WayPoint array below.
	dim RecordX(AstarMapX,AstarMapY)
	dim RecordY(AstarMapX,AstarMapY)
	
	REM When checking YOURMAP it checks an element (center point) plus eight different directions ranging
	REM out from it, thus the name A-star. These 9 different elements that are being checked are also flagged as "Open".
	REM Meaning available for checking as the next (center point), thus will flag more open elements on the next check.
	dim OpenX(AstarMapMax)
	dim OpenY(AstarMapMax)
	
	REM The "Close" array works along with the "Open" array. Once an OpenX,Y array is used to check as (center point)
	REM this array is flagged, disabling that coordinate from checking again in the future. So each "Open" value are
	REM only checked once.
	dim Close(AstarMapMax)
	
	
	REM This array marks which part of YOURMAP has already been checked to flag an "Open" array so it doesn't do it again.
	dim ClosedMap(AstarMapX,AstarMapY)
	
	
	REM This array is the current checking position.
	dim CheckX(AstarMapMax)
	dim CheckY(AstarMapMax)
	
	
	REM Used to record the final path once your checks reaches the GOAL. The amount of waypoints are optional, but to be
	REM safe just use the max amount.
	dim WayPointX(AstarMapMax)
	dim WayPointY(AstarMapMax)
	
	REM Node is the amount of checks or loops to perform. This amount is also optional although, a Node of 5 will only
	REM run 5 checks total, which wont get you anywhere unless the START and GOAL values are next to each other.
	REM It's preferend to use the max amount of the array to enable the checking of all elements or areas.
	global NodeMax
	NodeMax = AstarMapMax-1
return









REM ****************************************************************************************************
REM 					Astar Function
REM ****************************************************************************************************

Function Astar(StartX,StartY,GoalX,GoalY)
	
	REM Reset to null
	for y = 0 to AstarMapY
	for x = 0 to AstarMapX
		ClosedMap(x,y) = 0
		RecordX(x,y) = 0
		RecordY(x,y) = 0
	next x
	next y

	REM Reset to null
	for lp = 0 to AstarMapMax
		Close(lp) = 0
	next lp
	
	REM Initial values
	CheckX(0) = StartX
	CheckY(0) = StartY
	REM Initial cost
	Cost = 0
	REM The OpenCount variable used to determind the amount of all flagged "Open" array.
	OpenCount = -1
	Dist(StartX,StartY) = (StartX-GoalX)*(StartX-GoalX) + (StartY-GoalY)+(StartY-GoalY)
	Cost(StartX,StartY) = Cost
	Rate(StartX,StartY) = Dist(StartX,StartY) + Cost(StartX,StartY)


	REM Loop for the amount of NodeMax
	for N = 0 to NodeMax
		
		REM Checking the (center point) plus eight different direction, total of 9 elements.
 		for lpy = -1 to 1
 		for lpx = -1 to 1
 			x = CheckX(N) + lpx
			y = CheckY(N) + lpy
 			
 			REM Area check as to not check outside the array size.
			if x > -1 and y > -1 and x =< AstarMapX and y =< AstarMapY
			
				REM ClosedMap flags areas that has already been check.
				if ClosedMap(x,y) = 0
				
					REM After checking this area, it wont be checked again.
					ClosedMap(x,y) = 1
					
					
					REM *************************************************
					REM *			Insert YOURMAP here.				*
					REM *************************************************
					REM Checks to see if YOURMAP is a null value. Or what ever value chosen.
					if YourMapArray(x,y) = 0
					
						REM Cost is a bit higher for checking diagonals
						if lpx = 0 or lpy = 0 then DiagonalCost = 0 else DiagonalCost = 4
						
						REM Getting the distance
						if x > GoalX then DistX = x-GoalX else DistX = GoalX-x
						if y > GoalY then DistY = y-GoalY else DistY = GoalY-y
						
						REM Recording the values.
						Dist(x,y) = DistX + DistY
						Cost(x,y) = 10 + Cost + DiagonalCost
						Rate(x,y) = Dist(x,y) + Cost(x,y)
						
						REM Recordes the direction based on the (center point)
						RecordX(x,y) = lpx
						RecordY(x,y) = lpy
						
						REM The amount of Opened array is increased
						inc OpenCount
						REM Add this location as Opened
						OpenX(OpenCount) = x
						OpenY(OpenCount) = y
					endif
				endif

			endif
		next lpx
		next lpy
		

		REM Checking the "Rate" array values of all the opened areas to find the best rate which is the lowest
		REM value meaning it's the closest to the GOAL and use it as the next (center point) for checking.
		
		REM Set to value to high because we need to compare and find the lowest value.
		SelectRate = 65535
		for lp = 0 to OpenCount
			
			REM Search for an "Open" array that has not been closed.
			if Close(lp) = 0
			
				x = OpenX(lp)
				y = OpenY(lp)
				
				REM Comparing Rates and searching for the lowest value
				if Rate(x,y) < SelectRate
					
					SelectRate = Rate(x,y)
					SelectX = x
					SelectY = y
					SelectClose = lp
				endif
			endif
	    next lp

	    
		REM The new (Center Point) is now flagged as Closed so it doesn't get checked again.
		Close(SelectClose) = 1

		REM Updating the new (Center Point) coordinates.
		CheckX(N+1) = SelectX
		CheckY(N+1) = SelectY

		REM Updating the current cost based on the cost of the new (Center Point).
		Cost = Cost + (Cost(SelectX,SelectY)-Cost)


		REM GOAL check. Once the goal is reached, we exit this loop then construct the waypoint.
		if SelectX = GoalX and SelectY = GoalY
			REM Forcing the loop variable to equal the max value kicks us out of the For/Next loop.
			N = NodeMax
		endif
		
		REM The amount of Open checks has reached the maximun areas, this means the path from the
		REM START to GOAL is block and there is no way to get there.
		if OpenCount = AstarMapMax
			REM Forcing the loop variable to equal the max value kicks us out of the For/Next loop.
			N = NodeMax
			REM Force the START and GOAL to be the same. GOAL is imposible to reach.
			GoalX = StartX
			GoalY = StartY
		endif
		
	next N



	REM Construct the WayPoint, starting from the GOAL to the START. It will be following the
	REM values of the RecordX,Y array giving the direction all the way to the START location.
	
	REM The recording method is based on your own preference. This example is just using
	REM coordinates based off of the array.
	
	
	REM Set the GOAL value at element ZERO
	WayPointX(0) = GoalX
	WayPointY(0) = GoalY
	WayPointCount = -1

	REM Looping from ONE not ZERO. 
	For N = 1 to NodeMax
		
		REM Coordinates of the previous waypoint
		x = WayPointX(N-1)
		y = WayPointY(N-1)
		WayPointX(N) = x - RecordX(x,y)
		WayPointY(N) = y - RecordY(x,y)
		
		REM Found the START values, exit this loop.
		if WayPointX(N) = StartX and WayPointY(N) = StartY
			WayPointCount = N
			N = NodeMax
		endif
	next N


	REM Returning the amount of waypoints so we know where the start of the waypoint is.
EndFunction WayPointCount

Rem Project: zombie
Rem Project: zombie
Rem Created: Sunday, December 18, 2011

Rem ***** Main Source File *****
sync on : sync rate 60  : w = screen width() : h = screen height()

global node_dist = 10
node_dificulty = 8
node_blocksize = 10
node_xcount = w/node_dist : node_ycount = h/node_dist

global dim n(node_xcount,node_ycount) as UDTnode

for i = 1 to node_xcount : for j = 1 to node_ycount
    n(i,j).x# = i*node_dist : n(i,j).y# = j*node_dist
    n(i,j).cost# = 1 
    n(i,j).exist = 1
    n(i,j).i = i : n(i,j).j = j 
NEXT : next
for i = 1 to node_xcount-node_blocksize step node_blocksize : for j = 1 to node_ycount-node_blocksize step node_blocksize
  if rnd(node_dificulty) < 2 
        for k = 0 to node_blocksize : for o = 0 to node_blocksize
            n(i+k,j+o).exist = 0
        next : next
  endif
next : next
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
    if n(i,j).exist = 0 
            accepted = 0                  
            if n(i-1,j).exist = 0 then accepted = 1 
            if n(i+1,j).exist = 0 then accepted = 1 
            if n(i,j+1).exist = 0 then accepted = 1 
            if n(i,j-1).exist = 0 then accepted = 1 
            if accepted = 0 then n(i,j).exist = 1   
    ENDIF
NEXT : next

node_color1 = rgb(40,80,160)
node_color2 = rgb(160,80,40)

node_color3 = rgb(60,120,240)
node_color4 = rgb(255,40,10)
node_color41 = rgb(120,20,5)


dim open(20000) as UDTnode
dim path(20000) as UDTnode
global node_max 
node_max =  node_xcount*node_ycount

global AstarMapX = node_xcount
global AstarMapY = node_ycount
global AstarMapMax = node_max

global dim CheckX(node_max)
global dim CheckY(node_max)
global dim WayPointX(node_max)
global dim WayPointY(node_max)
global dim Close(node_max)
global dim OpenX(node_max)
global dim OpenY(node_max)
global NodeMax = AstarMapMax-1

do

    mx# = mousex() : my# = mousey() 
    node_mx = getnode(mx#) : node_my = getnode(my#)
    
    for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
        if n(i,j).exist = 1 then a2dot n(i,j).x#,n(i,j).y#,node_color1 
        if n(i,j).exist = 0 
            a2dot n(i,j).x#,n(i,j).y#,node_color2           
            if n(i-1,j).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i-1,j).x#,n(i-1,j).y#,node_color2 
            if n(i,j-1).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i,j-1).x#,n(i,j-1).y#,node_color2
        endif        
    NEXT : next
    
    for i = 0 to pathlength
        if i > 0 then a2line WayPointX(i)*node_dist,WayPointY(i)*node_dist,WayPointX(i-1)*node_dist,WayPointY(i-1)*node_dist,rgb(255,(255.0*i)/pathlength,0)
    NEXT
    if calc1 = 1 and calc2 = 1 then pathlength = astar(node_zx,node_zy,node_targetx,node_targety)
    if mouseclick() = 1 and clicked = 0
        if n(node_mx,node_my).exist = 1 
            zx# = n(node_mx,node_my).x# : zy# = n(node_mx,node_my).y# 
            node_zx = node_mx : node_zy = node_my
            calc1 = 1     
            clicked = 1
        endif
        else
        if mouseclick() = 0 then clicked = 0
    endif
    
    if mouseclick() = 2 
        if n(node_mx,node_my).exist = 1 then targetx# = n(node_mx,node_my).x# : targety# = n(node_mx,node_my).y#    
        node_targetx = node_mx : node_targety = node_my   
        calc2 = 1                   
    ENDIF
    
    if spacekey() and mode = 0
        select n(node_mx,node_my).exist
            case 0               
                mode = 1
            endcase
            case 1
                 mode = 2
            endcase
        endselect
        else
        if spacekey() = 0 then mode = 0
    ENDIF
    
    if spacekey() 
        select mode
            case 1
                 n(node_mx,node_my).exist = 1 
            endcase
            case 2
                 n(node_mx,node_my).exist = 0 
                 n(node_mx+1,node_my+1).exist = 0 
                 n(node_mx+1,node_my).exist = 0 
                 n(node_mx,node_my+1).exist = 0 
            endcase
        endselect

    ENDIF
    print pathlength
    a2circle targetx#,targety#,node_dist,node_color3
    a2circle targetx#,targety#,node_dist/2,node_color3
    
    a2circle zx#,zy#,node_dist/2,node_color4
    a2circle zx#,zy#,node_dist/4,node_color4
      
    sync
    cls
    
LOOP

Rem ***** Main Source File *****
Function Astar(StartX,StartY,GoalX,GoalY)
    
    REM Reset to null
    for y = 0 to AstarMapY
    for x = 0 to AstarMapX
        n(x,y).closed = 0
        n(x,y).recordx = 0
        n(x,y).recordy = 0
    next x
    next y
       
    REM Reset to null
    for lp = 0 to AstarMapMax
        Close(lp) = 0
    next lp
    
    REM Initial values
    CheckX(0) = StartX
    CheckY(0) = StartY
    REM Initial cost
    Cost = 0
    REM The OpenCount variable used to determind the amount of all flagged "Open" array.
    OpenCount = -1
    n(StartX,StartY).dist# = (StartX-GoalX)*(StartX-GoalX) + (StartY-GoalY)*(StartY-GoalY)
    n(StartX,StartY).cost# = Cost
    n(StartX,StartY).rate# = n(StartX,StartY).dist# + n(StartX,StartY).dist#


    REM Loop for the amount of NodeMax
    for N = 0 to NodeMax
        
        REM Checking the (center point) plus eight different direction, total of 9 elements.
         for lpy = -1 to 1
         for lpx = -1 to 1
            x = CheckX(N) + lpx
            y = CheckY(N) + lpy
             
             REM Area check as to not check outside the array size.
            if x > -1 and y > -1 and x =< AstarMapX and y =< AstarMapY
            
                REM ClosedMap flags areas that has already been check.
                if n(x,y).closed = 0                
                    REM After checking this area, it wont be checked again.
                    n(x,y).closed = 1                                                          
                    REM Checks to see if YOURMAP is a null value. Or what ever value chosen.
                    if n(x,y).exist = 1                    
                        REM Cost is a bit higher for checking diagonals
                        if lpx = 0 or lpy = 0 then DiagonalCost = 0 else DiagonalCost = 4                        
                        REM Getting the distance
                        if x > GoalX then DistX = x-GoalX else DistX = GoalX-x
                        if y > GoalY then DistY = y-GoalY else DistY = GoalY-y                        
                        REM Recording the values.
                        n(x,y).dist# = DistX + DistY
                        n(x,y).cost# = 10 + Cost + DiagonalCost
                        n(x,y).rate# = n(x,y).dist# + n(x,y).cost#
                        REM Recordes the direction based on the (center point)
                        n(x,y).recordx = lpx
                        n(x,y).recordy = lpy                        
                        REM The amount of Opened array is increased
                        inc OpenCount
                        REM Add this location as Opened
                        OpenX(OpenCount) = x
                        OpenY(OpenCount) = y
                    endif
                endif

            endif
        next lpx
        next lpy
        

        REM Checking the "Rate" array values of all the opened areas to find the best rate which is the lowest
        REM value meaning it's the closest to the GOAL and use it as the next (center point) for checking.
        
        REM Set to value to high because we need to compare and find the lowest value.
        SelectRate = 65535
        for lp = 0 to OpenCount
            
            REM Search for an "Open" array that has not been closed.
            if Close(lp) = 0
            
                x = OpenX(lp)
                y = OpenY(lp)
                
                REM Comparing Rates and searching for the lowest value
                if n(x,y).rate# < SelectRate
                    
                    SelectRate = n(x,y).rate#
                    SelectX = x
                    SelectY = y
                    SelectClose = lp
                endif
            endif
        next lp

        
        REM The new (Center Point) is now flagged as Closed so it doesn't get checked again.
        Close(SelectClose) = 1

        REM Updating the new (Center Point) coordinates.
        CheckX(N+1) = SelectX
        CheckY(N+1) = SelectY

        REM Updating the current cost based on the cost of the new (Center Point).
        Cost = Cost + (n(SelectX,SelectY).cost#-Cost)


        REM GOAL check. Once the goal is reached, we exit this loop then construct the waypoint.
        if SelectX = GoalX and SelectY = GoalY
            REM Forcing the loop variable to equal the max value kicks us out of the For/Next loop.
            N = NodeMax
        endif
        
        REM The amount of Open checks has reached the maximun areas, this means the path from the
        REM START to GOAL is block and there is no way to get there.
        if OpenCount = NodeMax
            REM Forcing the loop variable to equal the max value kicks us out of the For/Next loop.
            N = NodeMax
            REM Force the START and GOAL to be the same. GOAL is imposible to reach.
            GoalX = StartX
            GoalY = StartY
        endif
        
    next N



    REM Construct the WayPoint, starting from the GOAL to the START. It will be following the
    REM values of the RecordX,Y array giving the direction all the way to the START location.
    
    REM The recording method is based on your own preference. This example is just using
    REM coordinates based off of the array.
    
    
    REM Set the GOAL value at element ZERO
    WayPointX(0) = GoalX
    WayPointY(0) = GoalY
    WayPointCount = -1

    REM Looping from ONE not ZERO. 
    For N = 1 to NodeMax
        
        REM Coordinates of the previous waypoint
        x = WayPointX(N-1)
        y = WayPointY(N-1)
        WayPointX(N) = x - n(x,y).recordx
        WayPointY(N) = y - n(x,y).recordy
        
        REM Found the START values, exit this loop.
        if WayPointX(N) = StartX and WayPointY(N) = StartY
            WayPointCount = N
            N = NodeMax
        endif
    next N
    REM Returning the amount of waypoints so we know where the start of the waypoint is.
EndFunction WayPointCount

remstart
_getpath:
for i = 0 to pathlength+10
    n(path(i).i,path(i).j).status = 0
NEXT

A_closedcount = 0

repeat 
n(node_zx,node_zy).status = 1
A_opencount = 0 
for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
    if k > 0 and k < node_xcount and o > 0 and o < node_ycount
    if n(k,o).status = 0 and n(k,o).exist = 1 
        inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
        rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)*0.5+abs(o-node_zy)*0.5
        open(A_opencount).value# = dist(k,o,node_targetx,node_targety)+dist(k,o,node_zx,node_zy)
    endif   
    endif
NEXT : next

if A_opencount = 0 
    A_failcheck = 0
    repeat
    inc A_failcheck
    node_zx = path(A_closedcount-A_failcheck).i : node_zy = path(A_closedcount-A_failcheck).j
    for k = node_zx-1 to node_zx+1 : for o = node_zy-1 to node_zy+1
        if k > 0 and k < node_xcount and o > 0 and o < node_ycount
            if n(k,o).status = 0 and n(k,o).exist = 1 
                inc A_opencount : open(A_opencount).i = k : open(A_opencount).j = o 
                rem open(A_opencount).value = abs(k-node_targetx)+abs(o-node_targety)+abs(k-node_zx)+abs(o-node_zy)
                open(A_opencount).value# = dist(k,o,node_targetx,node_targety)+dist(k,o,node_zx,node_zy)
            endif   
        endif
    NEXT : next
    until A_opencount > 0
    A_closedcount = A_closedcount-A_failcheck
endif

if A_opencount > 0
    A_openmin# = 10000000 : A_openmini = 0
    for i = 1 to A_opencount
        if open(i).value# < A_openmin# then A_openmin# = open(i).value# : A_openmini = i    
    NEXT
    inc A_closedcount

    if A_closedcount < 10000
        path(A_closedcount).i = open(A_openmini).i : path(A_closedcount).j = open(A_openmini).j
        node_zx = path(A_closedcount).i : node_zy = path(A_closedcount).j
    endif
endif

until path(A_closedcount).i = node_targetx and path(A_closedcount).j = node_targety or A_closedcount > 10000

pathlength = A_closedcount

return
remend
type UDTnode
    x# : y# 
    exist
    i : j 
    px : py
    status
    value# : cost#
    closed
    recordx : recordy
    dist# : rate# : cost#
endtype

type UDTdeffender
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
endtype
type UDTzombiedata
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd  
endtype  
type UDTzombie
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
    pathlength
    dat as UDTzombiedata
endtype


function nodedot(x#,y#)
    x = getnode(x#) : y = getnode(y#) : nx# = n(x,y).x# : ny# = n(x,y).y#
    a2fillcircle nx#,ny#,2,rgb(255,255,255) 
ENDFUNCTION

function getnode(x#)
     c = int(x#/node_dist+0.5)
ENDFUNCTION c

function dimscreen(dimness as dword)
    a2setblendmode 2,2,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function softdimscreen(dimness as dword)
    a2setblendmode 2,10,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function squaredist(x1#,y1#,x2#,y2#)
    d# = (x1#-x2#)^2+(y1#-y2#)^2
ENDFUNCTION d#
function dist(x1#,y1#,x2#,y2#)
    d# = sqrt((x1#-x2#)^2+(y1#-y2#)^2)
ENDFUNCTION d#
remstart
function borderx(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cx# = w
        if x# <= 0 then cx# = 0
    endif
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cx# = (h/2.0)/k#+w/2.0
        if y# <= 0 then cx# = w/2.0-(h/2.0)/k#
    endif
    else
    cx# = -1000
    endif
ENDfunction cx#
function bordery(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cy# = k#*(w/2.0)+h/2.0 
        if x# <= 0 then cy# = h/2.0-k#*(w/2.0)
    endif 
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cy# = h
        if y# <= 0 then cy# = 0 
    eNDIF
    else
    cy# = -1000
    endif
ENDfunction cy#
remend

Rem Project: zombie
Rem Created: Sunday, December 18, 2011

Rem ***** Main Source File *****
sync on : sync rate 60  : w = screen width() : h = screen height()



gosub _nodeinit: 
gosub _Astarinit:

zombies = 5

gosub _zombieinit:






do
    mx# = mousex() : my# = mousey() 
    node_mx = getnode(mx#) : node_my = getnode(my#)
    
    gosub _drawmap:   
    gosub _input:
    
    if mouseclick()
        for i = 1 to zombies
            repeat z(i).nx = rnd(node_xcount) : z(i).ny = rnd(node_ycount) : until n(z(i).nx,z(i).ny).exist = 1
            z(i).x# = z(i).nx*node_dist : z(i).y# = z(i).ny*node_dist         
            z(i).pathlength = astar(z(i).nx,z(i).ny,node_targetx,node_targety)
            z(i).currentnode = z(i).pathlength-1
            for j = 0 to z(i).pathlength
                waypoint(i,j).x# = WayPointX(j)*node_dist : waypoint(i,j).y# = WayPointY(j)*node_dist
            next
        NEXT    
    endif
     
    
    
    for i = 1 to zombies
        rem z(i).pathlength = astar(z(i).nx,z(i).ny,node_targetx,node_targety)
        if z(i).currentnode > 0
            z(i).z# = atanfull(z(i).x#-waypoint(i,z(i).currentnode).x#,z(i).y#-waypoint(i,z(i).currentnode).y#)+180
            z(i).x# = newxvalue(z(i).x#,z(i).z#,z(i).spd#) : z(i).y# = newzvalue(z(i).y#,z(i).z#,z(i).spd#)
        endif
        if z(i).pathlength > 0 then if dist(z(i).x#,z(i).y#,waypoint(i,z(i).currentnode).x#,waypoint(i,z(i).currentnode).y#) < 12 then z(i).currentnode = z(i).currentnode-1 
        z(i).nx = getnode(z(i).x#) : z(i).ny = getnode(z(i).y#)               
        for j = 0 to z(i).pathlength
            if j > 0 then a2line WayPoint(i,j).x#,WayPoint(i,j).y#,WayPoint(i,j-1).x#,WayPoint(i,j-1).y#,rgb(55,(55.0*j)/z(i).pathlength,0)
        NEXT  
        a2fillcircle z(i).x#,z(i).y#,10,node_color1
    next          
    
   
    print currentnode            
    print pathlength
    
    a2circle targetx#,targety#,node_dist,node_color3
    a2circle targetx#,targety#,node_dist/2,node_color3
    
    a2circle zx#,zy#,node_dist/2,node_color4
    a2circle zx#,zy#,node_dist/4,node_color4
      
    sync
    cls
    
LOOP

_zombieinit:

dim z(zombies) as UDTzombie
dim waypoint(zombies,AstarMapMax) as UDTxyfloat
for i = 1 to zombies
    z(i).spd# = 3+rnd(25)/12.0
    z(i).exist = 1
    repeat z(i).nx = rnd(node_xcount) : z(i).ny = rnd(node_ycount) : until n(z(i).nx,z(i).ny).exist = 1
    z(i).x# = z(i).nx*node_dist : z(i).y# = z(i).ny*node_dist
NEXT

return



_input:

if mouseclick() = 1 
        if n(node_mx,node_my).exist = 1 
            zx# = n(node_mx,node_my).x# : zy# = n(node_mx,node_my).y# 
            node_zx = node_mx : node_zy = node_my  
            pathlength = astar(node_zx,node_zy,node_targetx,node_targety) 
            currentnode = pathlength-1          
        endif
endif   
    if mouseclick() = 2 
        if n(node_mx,node_my).exist = 1 
            targetx# = n(node_mx,node_my).x# : targety# = n(node_mx,node_my).y#    
            node_targetx = node_mx : node_targety = node_my    
            pathlength = astar(node_zx,node_zy,node_targetx,node_targety) 
            currentnode = pathlength-1  
        endif              
    ENDIF
    
    if spacekey() and mode = 0
        select n(node_mx,node_my).exist
            case 0 : mode = 1 : endcase               
            case 1 : mode = 2 : endcase
        endselect
        else
        if spacekey() = 0 then mode = 0
    ENDIF
    
    if spacekey() 
        select mode
            case 1 : n(node_mx,node_my).exist = 1 : endcase       
            case 2
                 n(node_mx,node_my).exist = 0 : n(node_mx+1,node_my+1).exist = 0                  
                 n(node_mx+1,node_my).exist = 0 : n(node_mx,node_my+1).exist = 0                  
            endcase
        endselect
    ENDIF    
return

_drawmap:
a2startlinebatch lineamount
lineamount = 0
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
        rem if n(i,j).exist = 1 then a2dot n(i,j).x#,n(i,j).y#,node_color1 
        if n(i,j).exist = 0          
            if n(i-1,j).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i-1,j).x#,n(i-1,j).y#,node_color2 
            if n(i,j-1).exist = 0 then a2line n(i,j).x#,n(i,j).y#,n(i,j-1).x#,n(i,j-1).y#,node_color2
            inc lineamount,2
        endif        
    NEXT : next
return
a2endbatch


_Astarinit:

global node_max 
node_max =  node_xcount*node_ycount

global AstarMapX = node_xcount
global AstarMapY = node_ycount
global AstarMapMax = node_max

global dim CheckX(node_max)
global dim CheckY(node_max)
global dim WayPointX(node_max)
global dim WayPointY(node_max)
global dim Close(node_max)
global dim OpenX(node_max)
global dim OpenY(node_max)
global NodeMax = AstarMapMax-1

return

_nodeinit:
global node_dist = 10
node_dificulty = 50
node_blocksize = 10
node_xcount = w/node_dist : node_ycount = h/node_dist

global dim n(node_xcount,node_ycount) as UDTnode

for i = 1 to node_xcount : for j = 1 to node_ycount
    n(i,j).x# = i*node_dist : n(i,j).y# = j*node_dist
    n(i,j).cost# = 1 
    n(i,j).exist = 1
    n(i,j).i = i : n(i,j).j = j 
NEXT : next
for i = 1 to node_xcount-node_blocksize step node_blocksize : for j = 1 to node_ycount-node_blocksize step node_blocksize
  if rnd(node_dificulty) < 2 
        for k = 0 to node_blocksize : for o = 0 to node_blocksize
            n(i+k,j+o).exist = 0
        next : next
  endif
next : next
for i = 2 to node_xcount-1 : for j = 2 to node_ycount-1
    if n(i,j).exist = 0 
            accepted = 0                  
            if n(i-1,j).exist = 0 then accepted = 1 
            if n(i+1,j).exist = 0 then accepted = 1 
            if n(i,j+1).exist = 0 then accepted = 1 
            if n(i,j-1).exist = 0 then accepted = 1 
            if accepted = 0 then n(i,j).exist = 1   
    ENDIF
NEXT : next

repeat node_zx = rnd(node_xcount) : node_zy = rnd(node_ycount) : until n(node_zx,node_zy).exist = 1
repeat node_targetx = rnd(node_xcount) : node_targety = rnd(node_ycount) : until n(node_targetx,node_targety).exist = 1

zx# = node_zx*node_dist : zy# = node_zy*node_dist
targetx# = node_targetx*node_dist : targety# = node_targety*node_dist
node_color1 = rgb(40,80,160)
node_color2 = rgb(160,80,40)

node_color3 = rgb(60,120,240)
node_color4 = rgb(255,40,10)
node_color41 = rgb(120,20,5)

return

type UDTxyfloat
    x# : y#
endtype

type UDTnode
    x# : y# 
    exist
    i : j 
    value# : cost#
    closed
    recordx : recordy
    dist# : rate# : cost#
endtype

type UDTdeffender
    x# : y# : z#
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
endtype
type UDTzombiedata
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd  
endtype  
type UDTzombie
    x# : y# : z#
    nx : ny
    vec
    tx# : ty#
    hp# : arm# : spd# : trn# : dmg# : ref# 
    img : sprt : snd
    exist : dead 
    pathlength : currentnode
    dat as UDTzombiedata
endtype



function nodedot(x#,y#)
    x = getnode(x#) : y = getnode(y#) : nx# = n(x,y).x# : ny# = n(x,y).y#
    a2fillcircle nx#,ny#,2,rgb(255,255,255) 
ENDFUNCTION

function getnode(x#)
     c = int(x#/node_dist+0.5)
ENDFUNCTION c

function dimscreen(dimness as dword)
    a2setblendmode 2,2,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function softdimscreen(dimness as dword)
    a2setblendmode 2,10,3
    a2fillbox 0,0,screen width(),screen height(),dimness
    a2setblendmode 2,2,1 : a2dot 1,-10,0
ENDFUNCTION
function squaredist(x1#,y1#,x2#,y2#)
    d# = (x1#-x2#)^2+(y1#-y2#)^2
ENDFUNCTION d#
function dist(x1#,y1#,x2#,y2#)
    d# = sqrt((x1#-x2#)^2+(y1#-y2#)^2)
ENDFUNCTION d#

Function Astar(StartX,StartY,GoalX,GoalY)

    for i = 0 to AstarMapX : for j = 0 to AstarMapY    
        n(i,j).closed = 0 : n(i,j).recordx = 0 : n(i,j).recordy = 0                
    next i : next j          
    for i = 0 to AstarMapMax
        Close(i) = 0
    next i
    
    CheckX(0) = StartX : CheckY(0) = StartY : Cost = 0 : OpenCount = -1    
    n(StartX,StartY).dist# = (StartX-GoalX)*(StartX-GoalX) + (StartY-GoalY)*(StartY-GoalY)
    n(StartX,StartY).cost# = Cost
    n(StartX,StartY).rate# = n(StartX,StartY).dist# + n(StartX,StartY).dist#
    for N = 0 to NodeMax          
         for lpx = -1 to 1 : for lpy = -1 to 1        
            x = CheckX(N) + lpx : y = CheckY(N) + lpy                                     
            if x > -1 and y > -1 and x =< AstarMapX and y =< AstarMapY                         
                if n(x,y).closed = 0                
                    n(x,y).closed = 1                                                          
                    if n(x,y).exist = 1                    
                        if lpx = 0 or lpy = 0 then DiagonalCost = 0 else DiagonalCost = 4                        
                        if x > GoalX then DistX = x-GoalX else DistX = GoalX-x
                        if y > GoalY then DistY = y-GoalY else DistY = GoalY-y                        
                        n(x,y).dist# = DistX + DistY
                        n(x,y).cost# = 10 + Cost + DiagonalCost
                        n(x,y).rate# = n(x,y).dist# + n(x,y).cost#
                        n(x,y).recordx = lpx : n(x,y).recordy = lpy                                                
                        inc OpenCount
                        OpenX(OpenCount) = x : OpenY(OpenCount) = y                        
                    endif
                endif
            endif
        next lpx : next lpy        
        
        SelectRate = 65535
        for lp = 0 to OpenCount
            if Close(lp) = 0           
                x = OpenX(lp) : y = OpenY(lp)
                if n(x,y).rate# < SelectRate                    
                    SelectRate = n(x,y).rate#
                    SelectX = x : SelectY = y : SelectClose = lp                  
                endif
            endif
        next lp
        Close(SelectClose) = 1
        CheckX(N+1) = SelectX : CheckY(N+1) = SelectY
        Cost = Cost + (n(SelectX,SelectY).cost#-Cost)
        
        if SelectX = GoalX and SelectY = GoalY          
            N = NodeMax
        endif
        if OpenCount = NodeMax           
            N = NodeMax  
            GoalX = StartX : GoalY = StartY                               
        endif
        if N = NodeMax-1
     
            goto _jump: 
        ENDIF
        
    next N
    
    _jump:
    
    WayPointX(0) = GoalX : WayPointY(0) = GoalY : WayPointCount = -1
    
    For N = 1 to NodeMax
        x = WayPointX(N-1) : y = WayPointY(N-1)      
        WayPointX(N) = x - n(x,y).recordx : WayPointY(N) = y - n(x,y).recordy
        
        if WayPointX(N) = StartX and WayPointY(N) = StartY
            WayPointCount = N
            N = NodeMax
        endif
    next N
   
EndFunction WayPointCount

remstart
function borderx(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cx# = w
        if x# <= 0 then cx# = 0
    endif
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cx# = (h/2.0)/k#+w/2.0
        if y# <= 0 then cx# = w/2.0-(h/2.0)/k#
    endif
    else
    cx# = -1000
    endif
ENDfunction cx#
function bordery(x#,y#)
    x# = x#-p.x# : y# = y#-p.y# : k# = y#/x#
    if x# > w or x# < -w or y# > h or y# < -h
    If -h/2.0 <= k#*(w/2.0) and k#*(w/2.0) <= h/2.0 
        if x# > 0 then cy# = k#*(w/2.0)+h/2.0 
        if x# <= 0 then cy# = h/2.0-k#*(w/2.0)
    endif 
    If -w/2.0 <= (h/2.0)/k# and (h/2.0)/k# <= w/2.0 
        if y# > 0 then cy# = h
        if y# <= 0 then cy# = 0 
    eNDIF
    else
    cy# = -1000
    endif
ENDfunction cy#
remend