Make all entities into function objects

common/src/play_clj/core.clj

@@ -12,31 +12,27 @@
             IsometricTiledMapRenderer
             OrthogonalTiledMapRenderer]))
 
-(defmulti execute-entity :command :default :draw)
-
-(defmethod execute-entity :set-screen [{:keys [^Game game ^Screen screen]}]
-  (.setScreen game screen))
-
 (load "core_2d")
 (load "core_global")
 (load "core_render")
 
-(defn expand-entity
+(defn wrap-entity
-  [entity]
+  [screen entity]
-  (if (keyword? entity)
+  (if (map? entity)
-    {:command entity}
+    (draw screen entity)
     entity))
 
 (defn transform-entities
-  [entities]
+  [screen entities]
-  (->> entities list flatten (remove nil?) (map expand-entity)))
+  (->> entities list flatten (remove nil?)))
 
 (defn execute-entities
   [screen entities]
   (->> entities
-       (map #(assoc % :screen-map screen))
+       (transform-entities screen)
-       (map execute-entity)
+       (map #(wrap-entity screen %))
-       (remove #(not (:persistent? %)))
+       (map #(%))
+       (remove nil?)
        doall))
 
 (defn defscreen*
@@ -45,35 +41,52 @@
     :as options}]
   (let [screen (atom {})
         entities (atom '())
-        on-show (or on-show (fn [s]))
+        dummy-fn (fn [s e])
-        on-render (or on-render (fn [s d]))
+        on-show (or on-show dummy-fn)
-        on-hide (or on-hide (fn [s]))
+        on-render (or on-render dummy-fn)
-        on-pause (or on-pause (fn [s]))
+        on-hide (or on-hide dummy-fn)
-        on-resize (or on-resize (fn [s w h]))
+        on-pause (or on-pause dummy-fn)
-        on-resume (or on-resume (fn [s]))]
+        on-resize (or on-resize dummy-fn)
+        on-resume (or on-resume dummy-fn)]
     (proxy [Screen] []
       (show []
-        (->> (swap! screen assoc
+        (let [screen-map (swap! screen assoc
-                    :renderer (create-renderer renderer)
+                                :renderer (create-renderer renderer)
-                    :camera (create-camera camera)
+                                :camera (create-camera camera)
-                    :total-time 0
+                                :width (game :width)
-                    :delta-time 0)
+                                :height (game :height)
-             on-show
+                                :total-time 0
-             transform-entities
+                                :delta-time 0)]
-             (reset! entities)))
+          (->> (on-show screen-map @entities)
+               (transform-entities screen-map)
+               (reset! entities))))
       (render [delta-time]
         (let [total-time (+ (:total-time @screen) delta-time)
               screen-map (swap! screen assoc
                                 :total-time total-time
                                 :delta-time delta-time)]
           (->> (on-render screen-map @entities)
-               transform-entities
                (execute-entities screen-map)
                (reset! entities))))
-      (hide [] (on-hide @screen))
+      (hide []
-      (pause [] (on-pause @screen))
+        (->> (on-hide @screen @entities)
-      (resize [w h] (on-resize @screen w h))
+             (execute-entities @screen)
-      (resume [] (on-resume @screen)))))
+             (reset! entities)))
+      (pause []
+        (->> (on-pause @screen @entities)
+             (execute-entities @screen)
+             (reset! entities)))
+      (resize [w h]
+        (let [screen-map (swap! screen assoc
+                                :width w
+                                :height h)]
+          (->> (on-resize screen-map @entities)
+               (execute-entities screen-map)
+               (reset! entities))))
+      (resume []
+        (->> (on-resume @screen @entities)
+             (execute-entities @screen)
+             (reset! entities))))))
 
 (defmacro defscreen
   [name & {:keys [] :as options}]
@@ -83,10 +96,14 @@
   [{:keys [on-create]}]
   (proxy [Game] []
     (create []
-      (->> (on-create this)
+      (execute-entities nil (on-create this)))))
-           transform-entities
-           (execute-entities nil)))))
 
 (defmacro defgame
   [name & {:keys [] :as options}]
   `(def ~name (defgame* ~options)))
+
+(defn set-screen
+  [^Game game ^Screen screen]
+  (fn []
+    (.setScreen game screen)
+    nil))

common/src/play_clj/core_2d.clj

@@ -10,13 +10,14 @@
 (defmethod sprite-batch BatchTiledMapRenderer [screen]
   (.getSpriteBatch (:renderer screen)))
 
-(defmethod execute-entity :draw [{:keys [screen-map image x y width height] :as entity}]
+(defn draw [screen {:keys [image x y width height] :as entity}]
-  (let [batch (sprite-batch screen-map)]
+  (fn []
-    (.begin batch)
+    (let [batch (sprite-batch screen)]
-    (when (and image x y width height)
+      (.begin batch)
-      (.draw batch image (float x) (float y) (float width) (float height)))
+      (when (and image x y width height)
-    (.end batch))
+        (.draw batch image (float x) (float y) (float width) (float height)))
-  entity)
+      (.end batch))
+    entity))
 
 ; textures
 

common/src/play_clj/core_global.clj

@@ -2,11 +2,15 @@
 
 ; graphics
 
-(defmethod execute-entity :clear [{:keys [r g b a] :as entity}]
+(defn clear
-  (doto (Gdx/gl)
+  ([]
-    (.glClearColor (or r 0) (or g 0) (or b 0) (or a 0))
+    (clear 0 0 0 0))
-    (.glClear GL20/GL_COLOR_BUFFER_BIT))
+  ([r g b a]
-  entity)
+    (fn []
+      (doto (Gdx/gl)
+        (.glClearColor r g b a)
+        (.glClear GL20/GL_COLOR_BUFFER_BIT))
+      nil)))
 
 (defn game*
   [key]

common/src/play_clj/core_render.clj

@@ -12,11 +12,13 @@
   (assert (number? tile-size))
   (float (/ 1 tile-size)))
 
-(defmethod execute-entity :render-tiled-map [{:keys [screen-map] :as entity}]
+(defn render-tiled-map
-  (doto (:renderer screen-map)
+  [{:keys [^BatchTiledMapRenderer renderer ^Camera camera]}]
-    (.setView (:camera screen-map))
+  (fn []
-    .render)
+    (doto renderer
-  entity)
+      (.setView camera)
+      .render)
+    nil))
 
 (defn tiled-map-layer
   [{:keys [^BatchTiledMapRenderer renderer]} layer]
@@ -53,12 +55,16 @@
 (defmethod create-camera :perspective [_]
   (PerspectiveCamera.))
 
-(defn resize-camera!
+(defn resize-camera
   [{:keys [^Camera camera]} width height]
-  (.setToOrtho camera false width height))
+  (fn []
+    (.setToOrtho camera false width height)
+    nil))
 
-(defn move-camera!
+(defn move-camera
   [{:keys [^Camera camera]} x y]
-  (when x (set! (. camera x) x))
+  (fn []
-  (when y (set! (. camera y) y))
+    (when x (set! (. camera x) x))
-  (.update camera))
+    (when y (set! (. camera y) y))
+    (.update camera)
+    nil))