ivan/il
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stuff

Browse Source
This commit is contained in:
rawley
2026-07-25 22:53:26 -06:00
parent ba10d04fa2
commit a179e453b1
4 changed files with 55 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/frontend/il/app.cljs
View File

@@ -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]
(when renderable
(set! (.. renderable -x) x)
(set! (.. renderable -y) y)))))
(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))))))))

28
src/frontend/il/update.cljs
View File

@@ -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 #(-> %
(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 :entities new-entities)))
(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))]
(if-not (nil? player)
(-> (assoc state :player updated-player)
(apply-player-position send-interval)
(apply-player-shoot mouse-pos))))
(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]))

30
src/il/core.clj
View File

@@ -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))
(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)))

8
src/il/handler.clj
View File

@@ -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