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)