Add input functions to defscreen

src/play_clj/core.clj

@@ -41,7 +41,8 @@
 (defn defscreen*
   [{:keys [on-show on-render on-hide on-pause on-resize on-resume]
     :or {on-show dummy on-render dummy on-hide dummy
-         on-pause dummy on-resize dummy on-resume dummy}}]
+         on-pause dummy on-resize dummy on-resume dummy}
+    :as options}]
   (let [screen (atom {})
         entities (atom '())
         execute-fn! (fn [func screen-map]
@@ -51,6 +52,12 @@
                                  flatten
                                  (remove nil?)
                                  (compare-and-set! entities entities-list))))
+        execute-priority-fn! (fn [func options]
+                               (some->> (func (merge @screen options) @entities)
+                                        list
+                                        flatten
+                                        (remove nil?)
+                                        (reset! entities)))
         create-renderer-fn! #(swap! screen assoc :renderer (renderer %))
         update-fn! #(swap! screen merge %)]
     {:screen screen
@@ -72,7 +79,8 @@
      :hide #(execute-fn! on-hide @screen)
      :pause #(execute-fn! on-pause @screen)
      :resize #(execute-fn! on-resize @screen)
-     :resume #(execute-fn! on-resume @screen)}))
+     :resume #(execute-fn! on-resume @screen)
+     :input (input* options execute-priority-fn!)}))
 
 (defmacro defscreen
   [n & {:keys [] :as options}]
@@ -85,7 +93,9 @@
 (defn defgame*
   [{:keys [on-create] :or {on-create dummy}}]
   (proxy [Game] []
-    (create [] (on-create this))))
+    (create []
+      (set-input! (InputMultiplexer.))
+      (on-create this))))
 
 (defmacro defgame
   [n & {:keys [] :as options}]
@@ -93,11 +103,14 @@
 
 (defn set-screen!
   [^Game game & screens]
-  (let [run-fn! (fn [k & args]
+  (let [add-inputs! (fn []
+                      (doseq [screen screens]
+                        (add-input! (:input screen))))
+        run-fn! (fn [k & args]
                   (doseq [screen screens]
                     (apply (get screen k) args)))]
     (.setScreen game (reify Screen
-                       (show [this] (run-fn! :show))
+                       (show [this] (add-inputs!) (run-fn! :show))
                        (render [this delta-time] (run-fn! :render delta-time))
                        (hide [this] (run-fn! :hide))
                        (pause [this] (run-fn! :pause))

src/play_clj/core_global.clj

@@ -43,34 +43,44 @@
   [key]
   `(.isKeyPressed ^Input (Gdx/input) (get-keycode ~key)))
 
-(defn input
-  [& {:keys [key-down key-typed key-up mouse-moved
-             scrolled touch-down touch-dragged touch-up]
-      :or {key-down dummy key-typed dummy key-up dummy mouse-moved dummy
-           scrolled dummy touch-down dummy touch-dragged dummy touch-up dummy}}]
-  (let [return-fn (fn [return-val]
-                    (some #(not (nil? %)) [return-val false]))]
-    (reify InputProcessor
-      (keyDown [this keycode]
-        (return-fn (key-down keycode)))
-      (keyTyped [this character]
-        (return-fn (key-typed character)))
-      (keyUp [this keycode]
-        (return-fn (key-up keycode)))
-      (mouseMoved [this screen-x screen-y]
-        (return-fn (mouse-moved screen-x screen-y)))
-      (scrolled [this amount]
-        (return-fn (scrolled amount)))
-      (touchDown [this screen-x screen-y pointer button]
-        (return-fn (touch-down screen-x screen-y pointer button)))
-      (touchDragged [this screen-x screen-y pointer]
-        (return-fn (touch-dragged screen-x screen-y pointer)))
-      (touchUp [this screen-x screen-y pointer button]
-        (return-fn (touch-up screen-x screen-y pointer button))))))
+(defn input*
+  [{:keys [key-down key-typed key-up mouse-moved
+           scrolled touch-down touch-dragged touch-up]
+    :or {key-down dummy key-typed dummy key-up dummy mouse-moved dummy
+         scrolled dummy touch-down dummy touch-dragged dummy touch-up dummy}}
+   execute-fn!]
+  (reify InputProcessor
+    (keyDown [this keycode]
+      (execute-fn! key-down {:keycode keycode})
+      false)
+    (keyTyped [this character]
+      (execute-fn! key-typed {:character character})
+      false)
+    (keyUp [this keycode]
+      (execute-fn! key-up {:keycode keycode})
+      false)
+    (mouseMoved [this screen-x screen-y]
+      (execute-fn! mouse-moved {:screen-x screen-x :screen-y screen-y})
+      false)
+    (scrolled [this amount]
+      (execute-fn! scrolled {:amount amount})
+      false)
+    (touchDown [this screen-x screen-y pointer button]
+      (execute-fn! touch-down {:screen-x screen-x :screen-y screen-y
+                               :pointer pointer :button button})
+      false)
+    (touchDragged [this screen-x screen-y pointer]
+      (execute-fn! touch-dragged
+                   {:screen-x screen-x :screen-y screen-y :pointer pointer})
+      false)
+    (touchUp [this screen-x screen-y pointer button]
+      (execute-fn! touch-up {:screen-x screen-x :screen-y screen-y
+                             :pointer pointer :button button})
+      false)))
 
-(defmacro input-multi
+(defmacro input
   [& args]
-  `(InputMultiplexer. ~@args))
+  `(input* ~args (fn [func# options#] (func# options#))))
 
 (defn set-input!
   [^InputProcessor p]

src/play_clj/core_interop.clj

@@ -62,10 +62,6 @@
   [k & options]
   `(utils/call! ^Input (Gdx/input) ~k ~@options))
 
-(defmacro input-multi!
-  [obj k & options]
-  `(utils/call! ^InputMultiplexer ~obj ~k ~@options))
-
 (defmacro net!
   [k & options]
   `(utils/call! ^Net (Gdx/net) ~k ~@options))