get player movement and collision working

two_player_cleaning_game/main.fnl

@@ -120,7 +120,7 @@
   ; (tset screen :canvas (love.graphics.newCanvas screen.canvas-w screen.canvas-h))
   (set pool (tutorial.load screen))
   (pool:flush)
-  (pool:emit :load :tutorial)
+  (pool:emit :load)
   ; (utils.debug-print pool)
   ; (utils.debug-print world)
   ; (load-assets)

two_player_cleaning_game/src/entities/player.fnl

@@ -3,6 +3,9 @@
 (local levels (require "levels.fnl"))
 (local assets (require "src/assets.fnl"))
 
+(var bump-world nil)
+(var level-key nil)
+
 (lambda angle-to-direction [angle]
   "Convert angle (radians) to compass direction keyword"
   (local tau (* 2 math.pi))
@@ -29,26 +32,25 @@
         {:d-key false :a-key true  :e-key false :q-key false} (set self.rot (- self.rot (* dt 2)))
         {:d-key false :a-key false :e-key true  :q-key false} (set self.rot (- self.rot (* dt 2)))
         {:d-key false :a-key false :e-key false :q-key true} (set self.rot (+ self.rot (* dt 2)))
-      ))
+      )
-      ; (when (and (> self.battery 0) (or d-key a-key e-key q-key))
+      (when (and (> self.battery 0) (or d-key a-key e-key q-key))
-      ;   (let [
+        (let [
-      ;     dir-fn (if (or d-key a-key) #(+ $1 $2) #(- $1 $2))
+          dir-fn (if (or d-key a-key) #(+ $1 $2) #(- $1 $2))
-      ;     new-x (dir-fn player.x (* player.speed dt (math.cos player.rot)))
+          new-x (dir-fn self.x (* self.speed dt (math.cos self.rot)))
-      ;     new-y (dir-fn player.y (* player.speed dt (math.sin player.rot)))
+          new-y (dir-fn self.y (* self.speed dt (math.sin self.rot)))
-      ;     col-filter-fn (lambda [item other]
+          col-filter-fn (lambda [item other]
-      ;       (if (= other.behavior "block") :slide :cross))
+            (if (= other.behavior "block") :slide :cross))
-      ;     (x y cols len)  (bump-world:move player new-x new-y col-filter-fn)]
+          (x y cols len)  (bump-world:move self new-x new-y col-filter-fn)]
-      ;       (tset player :x x)
+            (set self.x x)
-      ;       (tset player :y y))
+            (set self.y y))
-      ;       (if (> player.battery 0)
+            (if (> self.battery 0)
-      ;         (set player.battery (- player.battery (* dt 2))))))
+              (set self.battery (- self.battery (* dt 2))))))
   (beholder.trigger "PLAYER.POS" self.x self.y))
 
-(fn player.load [self level-key]
+(fn player.load [self]
   (set self.battery 100)
   (set self.x (. levels :levels level-key :spawns :player-1 :x))
   (set self.y (. levels :levels level-key :spawns :player-1 :y))
-  ; (bump-world:add player player.x player.y player.w player.h))
   (set self.quads
     (let [
       (w h) (assets.player-sprite:getDimensions)]
@@ -62,7 +64,7 @@
         :w (love.graphics.newQuad 150 0 25 25 w h)
         :nw (love.graphics.newQuad 175 0 25 25 w h)
       }))
-  )
+  (bump-world:add self self.x self.y self.w self.h))
 
 (fn player.draw50 [self]
   "draw player sprite and hitbox"
@@ -84,4 +86,7 @@
     (love.graphics.pop))
 
 
-player
+(lambda [{:bump-world bw :level-key key}]
+  (set bump-world bw)
+  (set level-key key)
+  player)

two_player_cleaning_game/src/levels/tutorial.fnl

@@ -7,27 +7,44 @@
 (local player (require "src/entities/player.fnl"))
 (local walls (require "src/systems/walls.fnl"))
 
+; (local colliders {
+;   :added {}
+; })
+; (fn colliders.update [self]
+;   (each [_ c (ipairs self.pool.groups.colliders.entities)]
+;     (when (not (. self.added (. c 1)))
+;       (print "Adding collider to list")
+;       (utils.debug-print c)
+;       (tset self.added (. c 1) true)
+;       )))
+    ; (let [obj (. c 1)]
+    ;   (when (not (. self.added obj))
+    ;     (set self.added obj true)
+    ;     (self.pool.data.bump-world:add (unpack c))))))
+
 (fn load [screen]
   (let [
     canvas (love.graphics.newCanvas screen.canvas-w screen.canvas-h)
+    bump-world (bump.newWorld 25)
     pool (nata.new {
       :data {
         : screen
         : canvas
-        :bump-world (bump.newWorld 25)
+        : bump-world
         :level-key :tutorial
       }
-      ; :groups  {
+      :groups  {
-      ;   gravity = {filter = {'gravity'}},
+        ; gravity = {filter = {'gravity'}},
+       ; :colliders {:filter [:collider]}
        ; :post-draw {:filter  [:post-draw]}
-      ; }
+      }
       :systems [
         (nata:oop)
         camera
         walls
     ]
     })]
-    (pool:queue player)
+    (pool:queue (player {:bump-world bump-world :level-key :tutorial}))
     pool))
 
 {