Fit map

src/actors/bullet.fnl

@@ -0,0 +1,32 @@
+(local geom (require :geom))
+(local dungeon (require :scenes.dungeon))
+(local bullet {})
+
+(fn bullet.spawn [s pos angle friendly? atk props]
+  (let [color (or props.color [1 0 0 1])
+        speed (or props.speed 300)
+        name (or props.name "bullet")]
+    {
+     :kind "bullet"
+     : name
+     :color (or props.color [1 0 0 1]
+                speed (or props.speed 300)
+                name (or props.name "bullet")
+                {: kind})
+     : friendly?
+     :enemy? (not friendly?)
+     : pos
+     : angle
+     : color
+     :hitbox {:shape :line :size 6}
+     :show-line {: color :len 6 :thickness 2}
+     :expiry props.expiry
+     : atk
+     : speed
+     :moving? true}))
+
+(fn bullet.update [s actor dt]
+  (when (not (geom.point-in-polygon? actor.pos s.level-border))
+    (dungeon.delete-actor s actor)))
+
+bullet

src/actors/gold-coin.fnl

@@ -0,0 +1,13 @@
+(local coin {})
+
+(fn coin.spawn [s pos]
+  {:kind "gold-coin"
+   :name "gold coin"
+   : pos
+   :color [1 0.8 0 1]
+   :char "$"
+   :char-scale 1
+   :hitbox {:size 5 :shape :circle}
+   :collect {:money 1}})
+
+coin

src/actors/grid-bug.fnl

@@ -0,0 +1,22 @@
+(local lume (require :lib.lume))
+
+(local grid-bug {})
+
+(fn grid-bug.spawn [s pos]
+  {
+   :kind "grid-bug"
+   :name "Gridbug"
+   : pos
+   :enemy? true
+   :color [(lume.color "#811A74")]
+   :char "x"
+   :char-scale 0.8
+   :hp 1
+   :max-hp 1
+   :atk 2
+   :speed 50
+   :angle 0
+   :ai {:kind :random}
+   :hitbox {:size 4 :shape :circle}})
+
+grid-bug

src/actors/killer-tomato.fnl

@@ -0,0 +1,42 @@
+(local dungeon (require :scenes.dungeon))
+(local kt {})
+
+(fn kt.spawn [s pos ?generation ...]
+  {:kind "killer-tomato"
+   :name "killer tomato"
+   : pos
+   :generation (or ?generation 1)
+   :update kt.update
+   :on-death kt.on-death
+   :enemy? true
+   :color [1 0 0]
+   :char "t"
+   :hp 3
+   :max-hp 3
+   :atk 6
+   :hitbox {:size 8 :shape :circle}
+   :seed-timer nil
+   :seed-count 0})
+
+(fn kt.update [s actor]
+  (if (and (< actor.generation 3)
+           (< actor.hp actor.max-hp)
+           (< actor.seed-count 3))
+      (if
+       (not actor.seed-timer)
+       (do
+         (set actor.seed-timer (+ s.elapsed-time
+                                  (/ (math.random 50 100) 128))))
+       (< actor.seed-timer s.elapsed-time)
+       (do
+         (set actor.seed-timer nil)
+         (set actor.seed-count (+ 1 actor.seed-count))
+         (table.insert s.log "The killer tomato has propagated a tomato seed...")
+         (dungeon.spawn-actor s :tomato-seed actor.pos (+ 1 actor.generation))))))
+
+(fn kt.on-death [s actor]
+  (when (< (love.math.random) 0.2)
+    (dungeon.spawn-actor s :tomato actor.pos
+        (dungeon.log (.. "The Killer Tomato became docile!")))))
+
+kt

src/actors/leprechaun.fnl

@@ -0,0 +1,72 @@
+(import-macros {: vec2-op} :geom-macros)
+(local dungeon (require :scenes.dungeon))
+(local vision (require :vision))
+(local geom (require :geom))
+(local leprechaun {})
+
+(fn leprechaun.spawn [s pos]
+  {
+   :kind "leprechaun"
+   :name "Leprechaun"
+   :update leprechaun.update
+   : pos
+   :enemy? true
+   :color [.2 1 .2 1]
+   :char "l"
+   :hp 5
+   :max-hp 5
+   :atk 5
+   :hitbox {:size 8 :shape :circle}
+   :speed 30
+   :angle 0
+   :target-timer s.elapsed-time
+   :bullet-timer nil})
+
+(fn leprechaun.update [s actor dt]
+  (if
+   (not actor.bullet-timer)
+   (set actor.bullet-timer
+        (+ s.elapsed-time
+         (/ (math.random 50 100) 64)))
+   (< actor.bullet-timer s.elapsed-time)
+   (do
+     (set actor.bullet-timer nil)
+     (when (vision.see-between-points? actor.pos s.player.pos s.level-border)
+           (dungeon.spawn-actor s
+                                :bullet
+                                actor.pos
+                                (geom.angle (vec2-op - s.player.pos actor.pos))
+                                false
+                                10
+                                {:speed 100
+                                 :color [0.8 0.8 0.5 1]
+                                 :name "Leprechaun Dagger"
+                                 :expiry (+ s.elapsed-time 2)}))))
+  (if
+   (not actor.target-timer)
+   (do
+     (set actor.target-timer (+ s.elapsed-time
+                                (/ (math.random 40 80) 64))))
+   (< actor.target-timer s.elapsed-time)
+   (do
+     (set actor.target-timer nil)
+     (let [coin
+           (dungeon.find-nearest-visible s actor :gold-coin)
+           stairs
+           (dungeon.find-nearest-visible s actor :stairs-down)
+           behind-player
+           [(vec2-op +
+                     s.player.pos
+                     [(geom.polar->rectangular s.player.angle -300)])]]
+       (set actor.speed (if (or coin stairs) 50 85))
+       (dungeon.actor-look-at-pos actor (unpack
+                                         (if
+                                          stairs stairs.pos
+                                          coin coin.pos
+                                          behind-player)))
+       (set actor.angle (+ actor.angle (* 0.4 (math.random))))))
+   (do
+     (when (not (dungeon.actor-step-forward actor dt s.level-border))
+       (set actor.target-timer s.elapsed-time)))))
+
+leprechaun

src/actors/particle.fnl

@@ -0,0 +1,18 @@
+(local particle {})
+
+(fn particle.spawn [s pos angle props]
+  {:kind "particle"
+   :name "particle"
+   :update particle.update
+   : angle
+   : pos
+   :always-visible? true
+   :moving? true
+   :color props.color
+   :char props.char
+   :char-scale props.char-scale
+   :show-line props.show-line
+   :lifetime props.lifetime
+   :speed props.speed})
+
+particle

src/actors/player.fnl

@@ -0,0 +1,142 @@
+(import-macros {: vec2-op} :geom-macros)
+(local geom (require :geom))
+(local dungeon (require :scenes.dungeon))
+(local scene (require :scene)) ; used for HACK to get mouse pos
+(local vision (require :vision))
+(local util (require :util))
+
+(local player {})
+
+(fn player.spawn [s pos]
+  {
+   :kind "player"
+   :name "player"
+   :update player.update
+   :realtime-update player.realtime-update
+   :keypressed player.keypressed
+   :mousemoved player.mousemoved
+   :mousepressed player.mousepressed
+   : pos
+   :friendly? true
+   :always-visible? true
+   :vision? true
+   :color [1 1 1]
+   :char "@"
+   :char-scale 1.3
+   :angle 0
+   :speed 90
+   :hp 3
+   :max-hp 4
+   :hide-hp? true
+   :stamina 5
+   :max-stamina 10
+   :stamina-regen-rate 5
+   :bullet-stamina-cost 6
+   :bullet-atk 80
+   :melee-stamina-cost 3
+   :melee-atk 20
+   :movement-cost 2
+   :freeze-until 0
+   :hitbox {:size 8 :shape :circle}
+   :show-line {:color [1 1 1 0.3]
+               :len 100}})
+
+(fn player.update [s actor dt]
+  (set actor.stamina
+       (math.min
+        actor.max-stamina
+        (+ actor.stamina (* dt actor.stamina-regen-rate)))))
+
+(fn player.realtime-update [s actor dt]
+  ;; keyboard input
+  (let [shift-down? (util.shift-down?)
+        key-offsets {:a [-1 0] :h [-1 0] :left [-1 0]
+                     :s [0 1] :j [0 1] :down [0 1]
+                     :w [0 -1] :k [0 -1] :up [0 -1]
+                     :d [1 0] :l [1 0] :right [1 0]}]
+    ;; average all the angle inputs
+    (let [offset
+          (accumulate [pos [0 0]
+                       key kpos (pairs key-offsets)]
+            (if (love.keyboard.isScancodeDown key)
+                [(vec2-op + pos kpos)]
+                pos))
+          (angle distance) (geom.rectangular->polar (unpack offset))]
+      (when (> distance 0)
+           (let [speed (* actor.speed dt (if shift-down? 0.2 1))
+                 offset [(geom.polar->rectangular
+                          angle
+                          speed)]
+                 next-pos [(vec2-op + offset actor.pos)]]
+             (if (geom.point-in-polygon? next-pos s.level-border)
+                 (player.move-to s actor next-pos)))))))
+
+(fn player.keypressed [s actor scancode]
+  (match scancode
+    (where "." (util.shift-down?))
+    (do
+      (local distance (geom.distance (vec2-op - actor.pos s.stairs-down.pos)))
+      (when (< distance 20) (dungeon.next-level s))
+      true)
+    (where (or "." :tab))
+    (do
+      (set actor.freeze-until (+ s.elapsed-time 0.5))
+      true)
+    :space
+    (do
+      (player.swing-sword s actor))
+    _
+    false))
+
+(fn player.mousepressed [s actor x y button]
+  (match button
+   1
+     (player.fire-bullet s actor)
+   2
+     (player.swing-sword s actor)))
+
+(fn player.mousemoved [s actor x y]
+  (set actor.angle (geom.angle (vec2-op - [x y] actor.pos))))
+
+(fn player.move-to [s actor newpos]
+  (set s.delta-time (+ s.delta-time
+                       (/ (geom.distance (vec2-op - newpos actor.pos))
+                          actor.speed)))
+  (set actor.stamina (- actor.stamina (* actor.movement-cost
+                                         s.delta-time)))
+  (dungeon.actor-look-at-pos actor (scene.get-mouse-position))
+  (vision.update-visible s.border-seen actor.pos s.level-border)
+  (set actor.pos newpos))
+
+(fn player.freeze [s actor duration]
+  (set actor.freeze-until (+ s.elapsed-time duration)))
+
+(fn player.swing-sword [s actor]
+  (dungeon.actor-try-stamina-action
+   actor
+   actor.melee-stamina-cost
+   (lambda []
+     (player.freeze s actor 0.2)
+     (dungeon.spawn-actor
+      s
+      :sword
+      actor.pos
+      actor.angle
+      true
+      actor.melee-atk
+      {:duration 0.2}))))
+
+(fn player.fire-bullet [s actor dt]
+  (dungeon.actor-try-stamina-action
+   actor
+   actor.bullet-stamina-cost
+   (lambda []
+     (dungeon.spawn-actor s
+                          :bullet
+                          actor.pos
+                          actor.angle
+                          true
+                          actor.bullet-atk
+                          {}))))
+
+player

src/actors/stairs-down.fnl

@@ -0,0 +1,12 @@
+(local stairs {})
+
+(fn stairs.spawn [s pos]
+  {
+   :kind "stairs-down"
+   :name "downward staircase"
+   : pos
+   :color [1 0.7 0 1]
+   :char ">"
+   :hitbox {:size 8 :shape :circle}})
+
+stairs