Remove platform-specific projects

src/play_clj/core.clj

@@ -0,0 +1,83 @@
+(ns play-clj.core
+  (:require [play-clj.utils :as utils])
+  (:import [com.badlogic.gdx Game Gdx Input$Keys Screen]
+           [com.badlogic.gdx.graphics Camera Color GL20 OrthographicCamera
+            PerspectiveCamera Texture]
+           [com.badlogic.gdx.graphics.g2d Animation SpriteBatch TextureRegion]
+           [com.badlogic.gdx.maps.tiled TmxMapLoader]
+           [com.badlogic.gdx.maps.tiled.renderers
+            BatchTiledMapRenderer
+            HexagonalTiledMapRenderer
+            IsometricStaggeredTiledMapRenderer
+            IsometricTiledMapRenderer
+            OrthogonalTiledMapRenderer]
+           [com.badlogic.gdx.scenes.scene2d Actor Stage]))
+
+(load "core_2d")
+(load "core_global")
+(load "core_render")
+
+(defn defscreen*
+  [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume]
+    :as options}]
+  (let [screen (atom {})
+        dummy-fn (fn [s])
+        on-show (or on-show dummy-fn)
+        on-render (or on-render dummy-fn)
+        on-hide (or on-hide dummy-fn)
+        on-pause (or on-pause dummy-fn)
+        on-resize (or on-resize dummy-fn)
+        on-resume (or on-resume dummy-fn)]
+    (proxy [Screen] []
+      (show []
+        (on-show (swap! screen assoc
+                        :width (game :width)
+                        :height (game :height)
+                        :total-time 0
+                        :delta-time 0
+                        :set-entities #(swap! screen assoc :entities %)
+                        :create-renderer #(swap! screen assoc
+                                                 :renderer (renderer %))
+                        :create-camera #(swap! screen assoc
+                                               :camera (camera %)))))
+      (render [delta-time]
+        (on-render (swap! screen assoc
+                          :total-time (+ (:total-time @screen) delta-time)
+                          :delta-time delta-time)))
+      (hide [] (on-hide @screen))
+      (pause [] (on-pause @screen))
+      (resize [w h] (on-resize (swap! screen assoc :width w :height h)))
+      (resume [] (on-resume @screen)))))
+
+(defmacro defscreen
+  [name & {:keys [] :as options}]
+  `(def ~name (defscreen* ~options)))
+
+(defn defgame*
+  [{:keys [on-create]}]
+  (proxy [Game] []
+    (create [] (on-create this))))
+
+(defmacro defgame
+  [name & {:keys [] :as options}]
+  `(def ~name (defgame* ~options)))
+
+(defn set-screen!
+  [^Game game ^Screen screen]
+  (.setScreen game screen))
+
+(defn set-entities!
+  [{:keys [set-entities]} entities]
+  (:entities (set-entities entities)))
+
+(defn get-entities
+  [{:keys [entities]}]
+  entities)
+
+(defn create-renderer!
+  [{:keys [create-renderer]} & {:keys [] :as args}]
+  (:renderer (create-renderer args)))
+
+(defn create-camera!
+  [{:keys [create-camera]} & {:keys [] :as args}]
+  (:camera (create-camera args)))

src/play_clj/core_2d.clj

@@ -0,0 +1,57 @@
+(in-ns 'play-clj.core)
+
+; drawing
+
+(defmulti sprite-batch #(-> % :renderer class) :default nil)
+
+(defmethod sprite-batch nil [screen]
+  (SpriteBatch.))
+
+(defmethod sprite-batch BatchTiledMapRenderer [{:keys [renderer]}]
+  (assert renderer)
+  (.getSpriteBatch renderer))
+
+(defn draw! [{:keys [renderer]} entities]
+  (assert renderer)
+  (let [batch (.getSpriteBatch renderer)]
+    (.begin batch)
+    (doseq [e entities]
+      (cond
+        (map? e)
+        (let [{:keys [image x y width height]} e]
+          (.draw batch image (float x) (float y) (float width) (float height)))
+        (isa? (type e) Actor)
+        (.draw e batch 1)))
+    (.end batch))
+  entities)
+
+; textures
+
+(defn image
+  [val]
+  (if (string? val)
+    (-> val Texture. TextureRegion.)
+    (TextureRegion. val)))
+
+(defn split-image
+  ([val size]
+    (split-image val size size))
+  ([val width height]
+    (-> val image (.split width height))))
+
+(defn flip-image
+  [val x? y?]
+  (doto (image val) (.flip x? y?)))
+
+(defmacro animation
+  [duration images & args]
+  `(Animation. ~duration
+               (utils/gdx-into-array ~images)
+               (utils/gdx-static-field :graphics :g2d :Animation
+                                       ~(or (first args) :normal))))
+
+(defn get-key-frame
+  ([screen ^Animation animation]
+    (.getKeyFrame animation (:total-time screen) true))
+  ([screen ^Animation animation is-looping?]
+    (.getKeyFrame animation (:total-time screen) is-looping?)))

src/play_clj/core_global.clj

@@ -0,0 +1,43 @@
+(in-ns 'play-clj.core)
+
+; graphics
+
+(defn clear!
+  ([]
+    (clear! 0 0 0 0))
+  ([r g b a]
+    (doto (Gdx/gl)
+      (.glClearColor r g b a)
+      (.glClear GL20/GL_COLOR_BUFFER_BIT))))
+
+(defn game*
+  [key]
+  (case key
+    :width `(.getWidth (Gdx/graphics))
+    :height `(.getHeight (Gdx/graphics))
+    :is-fullscreen? `(.isFullscreen (Gdx/graphics))
+    :is-touched? `(.isTouched (Gdx/input))
+    :x `(.getX (Gdx/input))
+    :y `(.getY (Gdx/input))
+    nil))
+
+(defmacro game
+  [key]
+  `~(game* key))
+
+; input
+
+(defn resolve-key
+  [key]
+  (if (keyword? key)
+    (case key
+      :up Input$Keys/DPAD_UP
+      :down Input$Keys/DPAD_DOWN
+      :left Input$Keys/DPAD_LEFT
+      :right Input$Keys/DPAD_RIGHT
+      nil)
+    key))
+
+(defmacro is-pressed?
+  [key]
+  `(.isKeyPressed (Gdx/input) ~(resolve-key key)))

src/play_clj/core_render.clj

@@ -0,0 +1,79 @@
+(in-ns 'play-clj.core)
+
+; renderers
+
+(defn load-tiled-map
+  [{:keys [file]}]
+  (assert (string? file))
+  (.load (TmxMapLoader.) file))
+
+(defn unit-scale
+  [{:keys [tile-size]}]
+  (assert (number? tile-size))
+  (float (/ 1 tile-size)))
+
+(defn render!
+  [{:keys [renderer ^Camera camera]}]
+  (assert renderer)
+  (cond
+    (isa? (type renderer) BatchTiledMapRenderer)
+    (doto renderer
+      (.setView camera)
+      .render)
+    (isa? (type renderer) Stage)
+    (.draw renderer)
+    :else nil))
+
+(defn tiled-map-layer
+  [{:keys [^BatchTiledMapRenderer renderer]} layer]
+  (assert renderer)
+  (-> renderer .getMap .getLayers (.get layer)))
+
+(defn tiled-map-cell
+  [{:keys [^BatchTiledMapRenderer renderer] :as screen} layer x y]
+  (assert renderer)
+  (-> (if (or (string? layer) (number? layer))
+        (tiled-map-layer screen layer)
+        layer)
+      (.getCell x y)))
+
+(defmulti renderer :type :default nil)
+
+(defmethod renderer nil [opts])
+
+(defmethod renderer :orthogonal-tiled-map [opts]
+  (OrthogonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+
+(defmethod renderer :isometric-tiled-map [opts]
+  (IsometricTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+
+(defmethod renderer :isometric-staggered-tiled-map [opts]
+  (IsometricStaggeredTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+
+(defmethod renderer :hexagonal-tiled-map [opts]
+  (HexagonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+
+(defmethod renderer :stage [_]
+  (Stage.))
+
+; cameras
+
+(defmulti camera identity :default :orthographic)
+
+(defmethod camera :orthographic [_]
+  (OrthographicCamera.))
+
+(defmethod camera :perspective [_]
+  (PerspectiveCamera.))
+
+(defn resize-camera!
+  [{:keys [^Camera camera]} width height]
+  (assert camera)
+  (.setToOrtho camera false width height))
+
+(defn move-camera!
+  [{:keys [^Camera camera]} x y]
+  (assert camera)
+  (when x (set! (. (. camera position) x) x))
+  (when y (set! (. (. camera position) y) y))
+  (.update camera))

src/play_clj/utils.clj

@@ -0,0 +1,28 @@
+(ns play-clj.utils
+  (:require [clojure.string :as s])
+  (:import [com.badlogic.gdx.utils Array]))
+
+(defn- split-keys
+  [key]
+  (-> key name (s/split #"-")))
+
+(defn- join-keys
+  [keys]
+  (->> keys (map name) (s/join ".") (str "com.badlogic.gdx.")))
+
+(defn gdx-static-field*
+  [args]
+  (->> (last args)
+       split-keys
+       (map s/upper-case)
+       (s/join "_")
+       (str (join-keys (butlast args)) "/")
+       symbol))
+
+(defmacro gdx-static-field
+  [& args]
+  `~(gdx-static-field* args))
+
+(defn gdx-into-array
+  [a]
+  (-> a into-array Array.))