aaa/map.fnl

(fn make-map [w h fill]
  (let [res []]
    (for [y 1 h]
      (let [row []]
        (for [x 1 w]
          (tset row x fill))
        (tset res y row)))
    res))

(fn in-bounds [m v]
  (if (<= 1 v.y (# m))
    (if (<= 1 v.x (# (. m 1))) true false)
    false))

(fn in-border [m v]
  (if (<= 2 v.y (dec (# m)))
    (if (<= 2 v.x (dec (# (. m 1)))) true false)
    false))

(fn gget [m v] 
  (if (in-bounds m v)
    (. (. m (. v :y)) (. v :x))))

(fn gset [m v x]
  (if if (in-bounds m v)
    (tset (. m (. v :y)) (. v :x) x)))

(fn geach [m f]
  ;calls f on each tile with coords and value
  (for [y 1 (# m)]
    (let [row (. m y)]
      (for [x 1 (# row)]
        (f (point x y) (. row x))))))

(fn draw-map [m v lookup]
  ;assumes 8x tiles, lookup is a fn to find sprite number from map value
  (each [y row (pairs m)]
    (each [x val (pairs row)]
      (spr val (+ (* x 8) v.x) (+ (* y 8) v.y)))))

(fn themeget [col k]
  (let [v (. col k)]
    (if (= (type v) "table")
        (rand-nth v) v)))

(fn map->tiles [m t theme]
  (geach m (fn [v g]
    (if 
      (= g 0) 
      (gset t v (themeget theme :0))
      (= g 1) 
      (if (= 0 (gget m (vadd v (point 0 -1))))
          (gset t v (themeget theme :0->1)) ;wall-floor transition
          (gset t v (themeget theme :1)))
      (= g 2) 
      (if (= 0 (gget m (vadd v (point 0 -1))))
          (gset t v (themeget theme :0->2)) ;wall-water transition
          (= 1 (gget m (vadd v (point 0 -1))))
          (gset t v (themeget theme :1->2)) ;floor-water transition
          (gset t v (themeget theme :2))) ))))

(fn random-tile [m n]
  (let [w (# (. m 1))
        h (# m)
        v (point (rand w) (rand h))]
    (if (= (gget m v) n) v (random-tile m n))))

(fn attempt-tile-dist [m n pos d max]
  (let [v (random-tile m n)]
    (if (>= (dist v pos) d) v
      (if (> max 0)
        (attempt-tile-dist m n pos d (- max 1))
        (attempt-tile-dist m n pos (- d 3) 5)))))

(fn random-tile-dist [m n pos d]
  (attempt-tile-dist m n pos d 5))

(var lastdrunk (point 1 0))
(fn drunk-dungeon [m v cnt tile bav]
  (var v v)
  (for [i 1 cnt]
    (gset m v tile)
    (let [dir (if (chance (or bav 50)) lastdrunk
                  (rand-nth [(point -1 0) (point 1 0) (point 0 -1) (point 0 1)]))
          nv (vadd v dir)]
      (set lastdrunk dir)
      (when (in-border m nv)
        (set v nv)))))

;TODO BSP dungeon
;dungeon is two points, pos and dim