player rendering

src/frontend/il/app.cljs

@@ -4,8 +4,6 @@
    ["pixi.js" :as pixi]
    [goog.dom :as dom]
    [cljs.core.async :as async :refer [go go-loop <! >!]]
-   [il.common.race :as race]
-   [il.common.class :as class]
    [frontend.il.entity :as entity]
    [frontend.il.update :as update]))
 
@@ -53,6 +51,7 @@
         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-from-server rx-chan)
                                       (drain-outbox! tx-chan)
@@ -67,8 +66,6 @@
                                    (assoc player :renderable (:shootbox player)))
         things-to-update (concat player-renderables entity-renderables world-renderables)]
     (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]
@@ -80,17 +77,11 @@
               (.init {:resizeTo js/window :autoDensity true :resolution (.-devicePixelRatio js/window)}))
         state (atom {:player {:velocity {:x 0 :y 0}
                               :keymap {:w 0 :a 0 :s 0 :d 0 :lmb 0}
-                              :last-attack -1
+                              :last-attack -1}
-                              :attack-speed 0.66
-                              :meta {:name "Player"
-                                     :race race/human
-                                     :class class/priest}
-                              :sprite "https://pixijs.com/assets/bunny.png"
-                              :speed 10
-                              :renderable nil}
                      :elapsed 0
                      :outbox []
-                     :entities {}})
+                     :entities {}
+                     :players {}})
         width (.-width js/window.screen)
         height (.-height js/window.screen)
         stage (.-stage app)

src/frontend/il/update.cljs

@@ -64,6 +64,14 @@
                                                 (apply-velocity dt)))]
     (assoc state :entities 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]
   (let [{player :player} state
         updated-player (-> player
@@ -84,14 +92,27 @@
 (defn update-from-server [state rx-chan]
   (loop [state-acc state
          {:keys [type] :as msg} (async/poll! rx-chan)]
-    (if (and (not (nil? msg)) (= type "sync"))
+    (if-not (nil? msg)
-      (let [entities (msg :entities)
+      (cond
-            state-entities (state-acc :entities)
+        (= type "init") (update state-acc :player merge msg)
-            tx-entities (update-vals entities (fn [e] {:sprite (:sprite e)
+        (= type "sync") (let [entities (msg :entities)
-                                                       :tx (:x e)
+                              players (if-not (nil? (get-in state-acc [:player :id]))
-                                                       :ty (:y e)}))
+                                        (dissoc (msg :players) (get-in state-acc [:player :id]))
-            merged-entities (deep-merge state-entities tx-entities)]
+                                        {})
-        (recur
+                              state-entities (state-acc :entities)
-         (assoc state-acc :entities merged-entities)
+                              state-players (state-acc :players)
-         (async/poll! rx-chan)))
+                              tx-entities (update-vals entities (fn [e] {:sprite (:sprite e)
+                                                                         :tx (:x e)
+                                                                         :ty (:y e)}))
+                              tx-players (update-vals players (fn [e] {:sprite (:sprite e)
+                                                                       :tx (:x e)
+                                                                       :ty (:y e)}))
+                              merged-entities (deep-merge state-entities tx-entities)
+                              merged-players (deep-merge state-players tx-players)]
+                          (recur
+                           (assoc state-acc
+                                  :entities merged-entities
+                                  :players merged-players)
+                           (async/poll! rx-chan)))
+        :else state-acc)
       state-acc)))

src/il/core.clj

@@ -5,6 +5,7 @@
             [compojure.route :as route]
             [clojure.core.async :as async :refer [<! >! go-loop]]
             [hiccup.core :as h]
+            [il.player :as p]
             [il.state :as s]
             [il.json :as j]
             [il.handler :as handler]
@@ -12,7 +13,8 @@
 
 (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})
+                (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))
@@ -72,10 +74,14 @@
             _ (println updated-state)
             entities (updated-state :entities)
             players (updated-state :players)]
-        (doseq [{out :out} (vals 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))
           (when-not (nil? out)
             (>! out (j/to-json {:type "sync"
-                                :entities entities})))))
+                                :entities entities
+                                :players players})))))
       (let [elapsed (- (System/currentTimeMillis) start-time)
             sleep-time (max 0 (- 50 elapsed))]
         (<! (async/timeout sleep-time)))

src/il/player.clj

@@ -0,0 +1,13 @@
+(ns il.player
+  (:require
+   [il.common.race :as race]
+   [il.common.class :as class]))
+
+(def default-player
+  {:attack-speed 0.66
+   :meta {:name "Player"
+          :race race/human
+          :class class/priest}
+   :sprite "https://pixijs.com/assets/bunny.png"
+   :speed 10
+   :renderable nil})