From a179e453b15f6a3845e490c594705dbdd56e8a83 Mon Sep 17 00:00:00 2001
From: rawley <rawleyfowler@gmail.com>
Date: Sat, 25 Jul 2026 22:53:26 -0600
Subject: [PATCH] stuff

---
 src/frontend/il/app.cljs    | 35 +++++++++++++++-------------------
 src/frontend/il/update.cljs | 38 +++++++++++++++++--------------------
 src/il/core.clj             | 32 ++++++++++++++++---------------
 src/il/handler.clj          |  8 ++++++--
 4 files changed, 55 insertions(+), 58 deletions(-)

diff --git a/src/frontend/il/app.cljs b/src/frontend/il/app.cljs
index 6192315..2c17c2b 100644
--- a/src/frontend/il/app.cljs
+++ b/src/frontend/il/app.cljs
@@ -36,12 +36,12 @@
   (when (count outbox)
     (go
       (doseq [msg outbox]
-        (println state)
-        (println "Writing event: " msg)
+        (js/console.log (clj->js state))
+        (js/console.log "Writing event: " (clj->js msg))
         (>! tx-chan (js/JSON.stringify (clj->js msg))))))
   (assoc state :outbox []))
 
-(defn ticker [app state layers rx-chan tx-chan t]
+(defn ticker [app state layers sb rx-chan tx-chan t]
   (let [dt (.-deltaTime t)
         {world-layer :world-layer
          entity-layer :entity-layer} layers
@@ -50,9 +50,9 @@
         send-interval 25 ; Send every 25ms (10 tps)
         elapsed (.-elapsedMS t)
         {:keys [player entities]} (-> (update @state :elapsed + elapsed)
-                                      (update/update-entities dt layers)
-                                      (update/update-players dt layers)
-                                      (update/update-player dt send-interval layers entity-relative-mouse-pos)
+                                      (update/update-state :entities dt layers)
+                                      (update/update-state :players dt layers)
+                                      (update/update-player dt send-interval layers entity-relative-mouse-pos sb)
                                       (update/update-from-server rx-chan)
                                       (drain-outbox! tx-chan)
                                       (->> (swap! state merge)))
@@ -69,8 +69,9 @@
       (let [{renderable :renderable
              x :x
              y :y} thing]
-        (set! (.. renderable -x) x)
-        (set! (.. renderable -y) y)))))
+        (when renderable
+          (set! (.. renderable -x) x)
+          (set! (.. renderable -y) y))))))
 
 (defn init []
   (let [app (doto (pixi/Application.)
@@ -93,6 +94,11 @@
         layers {:entity-layer entity-layer
                 :world-layer world-layer
                 :ui-layer ui-layer}
+        sb-callback (fn [v _] (swap! state update-in [:player :keymap] assoc :lmb v))
+        sb (entity/player-shoot-box
+            entity-layer
+            (partial sb-callback true)
+            (partial sb-callback false))
         websocket (doto (js/WebSocket. (str "ws://" js/location.host "/ws"))
                     (.addEventListener "open" #(go-loop []
                                                  (when-let [msg (<! tx-chan)]
@@ -112,15 +118,4 @@
                     (.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))}
-                               (@state :player))
-                      p (entity/render entity-layer e)
-                      sb-callback (fn [v _] (swap! state update-in [:player :keymap] assoc :lmb v))
-                      sb (entity/player-shoot-box
-                          entity-layer
-                          (partial sb-callback true)
-                          (partial sb-callback false))
-                      player (assoc e :renderable p :shootbox sb)]
-                  (swap! state update-in [:player] merge player)
-                  (.. app -ticker (add (partial ticker app state layers rx-chan tx-chan)))))))))
+                (.. app -ticker (add (partial ticker app state layers sb rx-chan tx-chan))))))))
diff --git a/src/frontend/il/update.cljs b/src/frontend/il/update.cljs
index d32ef63..da2b49c 100644
--- a/src/frontend/il/update.cljs
+++ b/src/frontend/il/update.cljs
@@ -14,9 +14,10 @@
     e))
 
 (defn apply-renderable [e layers]
-  (if-not (contains? e :renderable)
+  (if (and (nil? (e :renderable)) (e :sprite))
     (let [{entity-layer :entity-layer} layers
           renderable (entity/render entity-layer e)]
+      (js/console.log (clj->js e))
       (assoc e :renderable renderable))
     e))
 
@@ -56,30 +57,25 @@
       state)))
 
 ;; TODO: Cleanup entities somehow
-(defn update-entities [state dt layers]
-  (let [{entities :entities} state
-        new-entities (update-vals entities #(-> %
-                                                (apply-server-position)
-                                                (apply-renderable layers)
-                                                (apply-velocity dt)))]
-    (assoc state :entities new-entities)))
+(defn update-state [state key dt layers]
+  (let [{v key} state
+        new-entities (update-vals v #(-> %
+                                         (apply-server-position)
+                                         (apply-renderable layers)
+                                         (apply-velocity dt)))]
+    (assoc state key new-entities)))
 
-(defn update-players [state dt layers]
-  (let [{players :players} state
-        new-players (update-vals players #(-> %
-                                              (apply-server-position)
-                                              (apply-renderable layers)
-                                              (apply-velocity dt)))]
-    (assoc state :players new-players)))
-
-(defn update-player [state dt send-interval layers mouse-pos]
+(defn update-player [state dt send-interval layers mouse-pos sb]
   (let [{player :player} state
         updated-player (-> player
                            (apply-renderable layers)
+                           (assoc :shootbox sb)
                            (apply-velocity dt))]
-    (-> (assoc state :player updated-player)
-        (apply-player-position send-interval)
-        (apply-player-shoot mouse-pos))))
+    (if-not (nil? player)
+      (-> (assoc state :player updated-player)
+          (apply-player-position send-interval)
+          (apply-player-shoot mouse-pos))
+      (update state :outbox conj {:type "request-init"}))))
 
 (defn- deep-merge [& maps]
   (apply merge-with
@@ -94,7 +90,7 @@
          {:keys [type] :as msg} (async/poll! rx-chan)]
     (if-not (nil? msg)
       (cond
-        (= type "init") (update state-acc :player merge msg)
+        (= type "init") (update state-acc :player merge (dissoc msg :type))
         (= type "sync") (let [entities (msg :entities)
                               players (if-not (nil? (get-in state-acc [:player :id]))
                                         (dissoc (msg :players) (get-in state-acc [:player :id]))
diff --git a/src/il/core.clj b/src/il/core.clj
index cb8f8e2..6600bc3 100644
--- a/src/il/core.clj
+++ b/src/il/core.clj
@@ -13,24 +13,27 @@
 
 (defn ws-handler [state state-chan player-id]
   (go-websocket [in out err]
-                (s/change state-chan update :players assoc player-id {:out out :in in :err err :x 0 :y 0
-                                                                      :data (merge p/default-player {:id player-id})})
                 (go-loop []
                   (when-let [e (<! err)]
                     (println (.getMessage e))
                     (recur)))
                 (go-loop []
                   (if-let [raw (<! in)]
-                    (when (contains? (@state :players) player-id) ; Only if player has been initialized do we accept messages
+                    (if (contains? (@state :players) player-id)
                       (let [msg (j/from-json raw)
-                            type (get msg :type "invalid")]
+                            type (get msg :type "invalid")
+                            state @state]
                         (cond
-                          (= type "position") (handler/handle-position @state state-chan player-id msg)
-                          (= type "shoot") (handler/handle-shoot @state state-chan player-id msg)
-                          (= type "invalid") (>! out "Hello World!"))
+                          (= type "position") (handler/handle-position state state-chan player-id msg)
+                          (= type "shoot") (handler/handle-shoot state state-chan player-id msg)
+                          (= type "request-init") (handler/handle-request-init state state-chan player-id msg)
+                          (= type "invalid") (>! out "Invalid command!"))
                         (println msg)
-                        (println @state))
-                      (recur))
+                        (println state)
+                        (recur))
+                      (do (s/change state-chan update :players assoc player-id {:out out :in in :err err :x 0 :y 0
+                                                                                :data (merge p/default-player {:id player-id})})
+                          (recur)))
                     (do
                       (s/change state-chan update :players dissoc player-id)
                       (println "Closed: " player-id))))))
@@ -71,17 +74,16 @@
                                  event-state
                                  (event-state :systems))
             updated-state (swap! state conj system-state)
-            _ (println updated-state)
             entities (updated-state :entities)
             players (updated-state :players)]
-        (doseq [{out :out init? :initialized data :data} (vals players)]
-          (when (nil? init?)
-            (>! out (j/to-json (assoc data :type "init")))
-            (s/change state-chan update-in [:players (data :id)] assoc :init true))
+        (doseq [{:keys [initialized data out] :as player} (vals players)]
           (when-not (nil? out)
+            (when (nil? initialized)
+              (>! out (j/to-json (assoc (merge data (select-keys player [:x :y])) :type "init")))
+              (s/change state-chan update-in [:players (data :id)] assoc :initialized true))
             (>! out (j/to-json {:type "sync"
                                 :entities entities
-                                :players players})))))
+                                :players (update-vals players #(select-keys % [:x :y :data :sprite]))})))))
       (let [elapsed (- (System/currentTimeMillis) start-time)
             sleep-time (max 0 (- 50 elapsed))]
         (<! (async/timeout sleep-time)))
diff --git a/src/il/handler.clj b/src/il/handler.clj
index 406a65f..746c848 100644
--- a/src/il/handler.clj
+++ b/src/il/handler.clj
@@ -3,14 +3,18 @@
             [il.common.velocity :as v]))
 
 (defn handle-position [_ state-chan player-id {x :x y :y}]
+  (println "Setting player movement: " player-id x y)
   (s/change state-chan update-in [:players player-id] assoc :x x :y y))
 
-(defn handle-shoot [state state-chan player-id msg]
+(defn handle-request-init [_ state-chan player-id _]
+  (s/change state-chan update-in [:players player-id] dissoc :initialized))
+
+(defn handle-shoot [_ state-chan player-id msg]
   (let [bullet-id (random-uuid)
         ; player (get-in state [:players player-id])
         {tx :x ty :y player :player} msg
         {x :x y :y} player
-        speed 25 ; TODO: Get projectile speed from player weapon
+        speed 50 ; TODO: Get projectile speed from player weapon
         velocity (v/velocity-for x y tx ty speed)
         bullet {:sprite "/sprite/projectile.png" ; TODO: Render sprite based on player weapon
                 :x x