Go back to more conventional design

common/src/play_clj/core.clj

@@ -16,32 +16,12 @@
 (load "core_global")
 (load "core_render")
 
-(defn wrap-entity
-  [screen entity]
-  (if (map? entity)
-    (draw screen entity)
-    entity))
-
-(defn transform-entities
-  [screen entities]
-  (->> entities list flatten (remove nil?)))
-
-(defn execute-entities
-  [screen entities]
-  (->> entities
-       (transform-entities screen)
-       (map #(wrap-entity screen %))
-       (map #(%))
-       (remove nil?)
-       doall))
-
 (defn defscreen*
   [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume
            state renderer camera]
     :as options}]
   (let [screen (atom {})
-        entities (atom '())
+        dummy-fn (fn [s])
-        dummy-fn (fn [s e])
         on-show (or on-show dummy-fn)
         on-render (or on-render dummy-fn)
         on-hide (or on-hide dummy-fn)
@@ -50,43 +30,22 @@
         on-resume (or on-resume dummy-fn)]
     (proxy [Screen] []
       (show []
-        (let [screen-map (swap! screen assoc
+        (on-show (swap! screen assoc
-                                :renderer (create-renderer renderer)
+                        :renderer (create-renderer renderer)
-                                :camera (create-camera camera)
+                        :camera (create-camera camera)
-                                :width (game :width)
+                        :width (game :width)
-                                :height (game :height)
+                        :height (game :height)
-                                :total-time 0
+                        :total-time 0
-                                :delta-time 0)]
+                        :delta-time 0
-          (->> (on-show screen-map @entities)
+                        :save #(swap! screen assoc :entities %))))
-               (transform-entities screen-map)
-               (reset! entities))))
       (render [delta-time]
-        (let [total-time (+ (:total-time @screen) delta-time)
+        (on-render (swap! screen assoc
-              screen-map (swap! screen assoc
+                          :total-time (+ (:total-time @screen) delta-time)
-                                :total-time total-time
+                          :delta-time delta-time)))
-                                :delta-time delta-time)]
+      (hide [] (on-hide @screen))
-          (->> (on-render screen-map @entities)
+      (pause [] (on-pause @screen))
-               (execute-entities screen-map)
+      (resize [w h] (on-resize (swap! screen assoc :width w :height h)))
-               (reset! entities))))
+      (resume [] (on-resume @screen)))))
-      (hide []
-        (->> (on-hide @screen @entities)
-             (execute-entities @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}]
@@ -95,15 +54,17 @@
 (defn defgame*
   [{:keys [on-create]}]
   (proxy [Game] []
-    (create []
+    (create [] (on-create this))))
-      (execute-entities nil (on-create this)))))
 
 (defmacro defgame
   [name & {:keys [] :as options}]
   `(def ~name (defgame* ~options)))
 
-(defn set-screen
+(defn set-screen!
   [^Game game ^Screen screen]
-  (fn []
+  (.setScreen game screen))
-    (.setScreen game screen)
+
-    nil))
+(defn save!
+  [{:keys [save]} entities]
+  (save entities)
+  entities)

common/src/play_clj/core_2d.clj

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

common/src/play_clj/core_global.clj

@@ -2,15 +2,13 @@
 
 ; graphics
 
-(defn clear
+(defn clear!
   ([]
-    (clear 0 0 0 0))
+    (clear! 0 0 0 0))
   ([r g b a]
-    (fn []
+    (doto (Gdx/gl)
-      (doto (Gdx/gl)
+      (.glClearColor r g b a)
-        (.glClearColor r g b a)
+      (.glClear GL20/GL_COLOR_BUFFER_BIT))))
-        (.glClear GL20/GL_COLOR_BUFFER_BIT))
-      nil)))
 
 (defn game*
   [key]

common/src/play_clj/core_render.clj

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