From 445863ee415bdbbe42f93b07970d470cfbae1cc0 Mon Sep 17 00:00:00 2001
From: rawley <rawleyfowler@gmail.com>
Date: Fri, 10 Jul 2026 22:49:57 -0600
Subject: [PATCH] shootas

---
 src/frontend/il/app.cljs | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/frontend/il/app.cljs b/src/frontend/il/app.cljs
index 6195be1..25f03b1 100644
--- a/src/frontend/il/app.cljs
+++ b/src/frontend/il/app.cljs
@@ -24,20 +24,23 @@
   (let [id (swap! entity-id inc)]
     (swap! state update-in [:entities] conj {(-> id str keyword) entity})))
 
-(defn on-shoot [state entity-id player-sprite e]
+(defn on-shoot [state entity-id entity-layer player-sprite  e]
   (.log js/console e)
   (let [speed 15
         image "/sprite/projectile.png"
         start-x (.-x player-sprite)
         start-y (.-y player-sprite)
-        target-x (.. e -global -x)
-        target-y (.. e -global -y)
-        dx (- start-x target-x)
-        dy (- start-y target-y)
+        position (.toLocal ^js entity-layer (.-global e))
+        target-x (.-x position)
+        target-y (.-y position)
+        dx (- target-x start-x)
+        dy (- target-y start-y)
         h (js/Math.sqrt (+ (* dx dx) (* dy dy)))
         vx (* (/ dx h) speed)
         vy (* (/ dy h) speed)]
     (.log js/console "tx " target-x " ty " target-y " dx " dx " dy " dy " h " h)
+    (.log js/console "sx " start-x " sy " start-y)
+    (.log js/console player-sprite)
     (add-entity state entity-id {:sprite image
                                  :hyp h
                                  :x start-x
@@ -73,24 +76,24 @@
   (let [dt (.-deltaTime t)
         {world-layer :world-layer} layers
         {:keys [player entities]} (-> @state
-                               (update/update-entities dt layers)
-                               (update/update-player dt layers)
-                               (->> (swap! state merge)))
+                                      (update/update-entities dt layers)
+                                      (update/update-player dt layers)
+                                      (->> (swap! state merge)))
         sx (- (/ (.. app -screen -width) 2) (player :x))
         sy (- (/ (.. app -screen -height) 2) (player :y))
         entity-renderables (->> (vals entities)
                                 (remove #(nil? (% :renderable)))
-                                (vector))
+                                (vec))
         world-renderables (vector {:renderable world-layer :x sx :y sy})
         player-renderables (vector player
                                    (assoc player :renderable (:shootbox player)))
         things-to-update (concat player-renderables entity-renderables world-renderables)]
-    (println player-renderables (count player-renderables) (count things-to-update))
     (doseq [thing things-to-update]
+                                        ; TODO: Add lerp here, we shouldn't just launch things around with their X/Y
+                                        ; instead if the difference between curr-pos and tar-pos is > than vel try to move it to their every frame via vel
       (let [{renderable :renderable
              x :x
              y :y} thing]
-        (println "Rendering thing " renderable x y)
         (set! (.. renderable -x) x)
         (set! (.. renderable -y) y)))))
 
@@ -116,14 +119,14 @@
                 (init-input-handlers state)
                 (add-entity state entity-id {:x 500 :y 500 :sprite "https://pixijs.com/assets/bunny.png"})
                 (-> stage
-                    (.addChild world-layer) ; Bottom of the layer stack
+                    (.addChild world-layer)  ; Bottom of the layer stack
                     (.addChild entity-layer) ; Middle of the layer stack
                     (.addChild ui-layer))    ; Top of the layer stack
                 (let [e (merge {:x (-> width (/ 2) (int))
                                 :y (-> height (/ 2) (int))}
                                base-player)
                       p (entity/render entity-layer e)
-                      sb (entity/player-shoot-box entity-layer (partial on-shoot state entity-id p))
+                      sb (entity/player-shoot-box entity-layer (partial on-shoot state entity-id entity-layer p))
                       player (assoc e :renderable p :shootbox sb)]
                   (swap! state update-in [:player] merge player)
                   (.. app -ticker (add (partial ticker app state layers)))))))))