100 lines
2.6 KiB
Core
100 lines
2.6 KiB
Core
MAP_CurrentMap: MAP_Map
|
|
MAP_OpenPaths: Array(MAP_Path)
|
|
MAP_ClosePaths: Array(MAP_Path)
|
|
MAP_History: Array(MAP_Path)
|
|
MAP_TargetP: V2I
|
|
MAP_StartP: V2I
|
|
MAP_ReachedTarget := false
|
|
|
|
MAP_Tile :: int
|
|
MAP_Map :: struct
|
|
data: *MAP_Tile
|
|
x: int
|
|
y: int
|
|
actors: Array(MAP_Actor)
|
|
|
|
MAP_Actor :: struct
|
|
p: V2I
|
|
target_p: V2I
|
|
|
|
MAP_Path :: struct
|
|
value_to_sort_by: int // distance from target
|
|
p: V2I
|
|
came_from: V2I
|
|
|
|
MAP_Reset :: ()
|
|
bytes := SizeOf(MAP_Tile) * MAP_CurrentMap.x->U64 * MAP_CurrentMap.y->U64
|
|
|
|
Reset(&MAP_CurrentMap.actors)
|
|
Reset(&MAP_OpenPaths)
|
|
Reset(&MAP_ClosePaths)
|
|
Reset(&MAP_History)
|
|
MAP_ReachedTarget = false
|
|
|
|
memset(MAP_CurrentMap.data, 0, bytes)
|
|
Add(&MAP_CurrentMap.actors, {{4, 4}, {8, 8}})
|
|
MAP_PathFindStart(MAP_CurrentMap.actors.data + 0)
|
|
|
|
MAP_Init :: ()
|
|
MAP_CurrentMap.x = 60
|
|
MAP_CurrentMap.y = 40
|
|
bytes := SizeOf(MAP_Tile) * MAP_CurrentMap.x->U64 * MAP_CurrentMap.y->U64
|
|
MAP_CurrentMap.data = malloc(bytes)
|
|
MAP_Reset()
|
|
|
|
MAP_InsertOpenPath :: (p: V2I, target_p: V2I, came_from: V2I)
|
|
if p.x < 0 || p.x >= MAP_CurrentMap.x ;; return
|
|
if p.y < 0 || p.y >= MAP_CurrentMap.y ;; return
|
|
if MAP_CurrentMap.data[p.x + p.y * MAP_CurrentMap.x] == 1 ;; return
|
|
|
|
for i := 0, i < MAP_ClosePaths.len, i += 1
|
|
it := MAP_ClosePaths.data + i
|
|
if it.p.x == p.x && it.p.y == p.y ;; return
|
|
|
|
for i := 0, i < MAP_OpenPaths.len, i += 1
|
|
it := MAP_OpenPaths.data + i
|
|
if it.p.x == p.x && it.p.y == p.y ;; return
|
|
|
|
|
|
dx := target_p.x - p.x
|
|
dy := target_p.y - p.y
|
|
d := dx*dx + dy*dy
|
|
InsertSortedDecreasing(&MAP_OpenPaths, {d, p, came_from})
|
|
|
|
MAP_PathFindStart :: (actor: *MAP_Actor)
|
|
Reset(&MAP_OpenPaths)
|
|
Reset(&MAP_ClosePaths)
|
|
MAP_TargetP = actor.target_p
|
|
MAP_StartP = actor.p
|
|
MAP_InsertOpenPath(actor.p, actor.target_p, actor.p)
|
|
|
|
MAP_GetCloseP :: (p: V2I): *MAP_Path
|
|
for i := 0, i < MAP_ClosePaths.len, i += 1
|
|
it := MAP_ClosePaths.data + i
|
|
if it.p.x == p.x && it.p.y == p.y ;; return it
|
|
|
|
Assert(false)
|
|
return 0
|
|
|
|
MAP_PathFindStep :: ()
|
|
if MAP_ReachedTarget ;; return
|
|
|
|
it := Pop(&MAP_OpenPaths)
|
|
Add(&MAP_ClosePaths, it)
|
|
|
|
MAP_ReachedTarget = it.p.x == MAP_TargetP.x && it.p.y == MAP_TargetP.y
|
|
if MAP_ReachedTarget
|
|
Add(&MAP_History, it)
|
|
for !(it.p.x == MAP_StartP.x && it.p.y == MAP_StartP.y)
|
|
it = *MAP_GetCloseP(it.came_from)
|
|
Add(&MAP_History, it)
|
|
return
|
|
|
|
// @language_todo: Add continue keyword
|
|
// if x == 0 && y == 0 ;; continue
|
|
for y := -1, y <= 1, y += 1
|
|
for x := -1, x <= 1, x += 1
|
|
if (x == 0 && y == 0) == false
|
|
p := V2I{it.p.x + x, it.p.y + y}
|
|
MAP_InsertOpenPath(p, MAP_TargetP, it.p)
|