Add type hints

src/play_clj/core.clj

@@ -4,7 +4,8 @@
            [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 MapLayers]
+           [com.badlogic.gdx.maps.tiled TiledMap TiledMapTileLayer TmxMapLoader]
            [com.badlogic.gdx.maps.tiled.renderers
             BatchTiledMapRenderer
             HexagonalTiledMapRenderer

src/play_clj/core_2d.clj

@@ -2,17 +2,31 @@
 
 ; drawing
 
-(defn draw! [{:keys [renderer]} entities]
+(defmulti sprite-batch #(-> % :renderer class) :default nil)
+
+(defmethod sprite-batch nil
+  [screen]
+  (SpriteBatch.))
+
+(defmethod sprite-batch BatchTiledMapRenderer
+  [{:keys [^BatchTiledMapRenderer renderer]}]
+  (.getSpriteBatch renderer))
+
+(defmethod sprite-batch Stage
+  [{:keys [^Stage renderer]}]
+  (.getSpriteBatch renderer))
+
+(defn draw! [{:keys [renderer] :as screen} entities]
   (assert renderer)
-  (let [batch (.getSpriteBatch renderer)]
+  (let [^SpriteBatch batch (sprite-batch screen)]
     (.begin batch)
     (doseq [e entities]
       (cond
         (map? e)
-        (let [{:keys [image x y width height]} e]
+        (let [{:keys [^TextureRegion 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)))
+        (.draw ^Actor e batch 1)))
     (.end batch))
   entities)
 
@@ -21,18 +35,18 @@
 (defn image
   [val]
   (if (string? val)
-    (-> val Texture. TextureRegion.)
-    (TextureRegion. val)))
+    (-> ^String val Texture. TextureRegion.)
+    (TextureRegion. ^TextureRegion val)))
 
 (defn split-image
   ([val size]
     (split-image val size size))
   ([val width height]
-    (-> val image (.split width height))))
+    (-> val ^TextureRegion image (.split width height))))
 
 (defn flip-image
   [val x? y?]
-  (doto (image val) (.flip x? y?)))
+  (doto ^TextureRegion (image val) (.flip x? y?)))
 
 (defmacro animation
   [duration images & args]

src/play_clj/core_render.clj

@@ -17,12 +17,11 @@
   (assert renderer)
   (cond
     (isa? (type renderer) BatchTiledMapRenderer)
-    (doto renderer
+    (doto ^BatchTiledMapRenderer renderer
       (.setView camera)
       .render)
     (isa? (type renderer) Stage)
-    (.draw renderer)
-    :else nil))
+    (.draw ^Stage renderer)))
 
 (defn tiled-map-layer
   [{:keys [^BatchTiledMapRenderer renderer]} layer]
@@ -33,8 +32,8 @@
   [{:keys [^BatchTiledMapRenderer renderer] :as screen} layer x y]
   (assert renderer)
   (-> (if (or (string? layer) (number? layer))
-        (tiled-map-layer screen layer)
-        layer)
+        ^TiledMapTileLayer (tiled-map-layer screen layer)
+        ^TiledMapTileLayer layer)
       (.getCell x y)))
 
 (defmulti renderer :type :default nil)
@@ -42,16 +41,20 @@
 (defmethod renderer nil [opts])
 
 (defmethod renderer :orthogonal-tiled-map [opts]
-  (OrthogonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+  (OrthogonalTiledMapRenderer. ^TiledMap (load-tiled-map opts)
+                               ^double (unit-scale opts)))
 
 (defmethod renderer :isometric-tiled-map [opts]
-  (IsometricTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+  (IsometricTiledMapRenderer. ^TiledMap (load-tiled-map opts)
+                              ^double (unit-scale opts)))
 
 (defmethod renderer :isometric-staggered-tiled-map [opts]
-  (IsometricStaggeredTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+  (IsometricStaggeredTiledMapRenderer. ^TiledMap (load-tiled-map opts)
+                                       ^double (unit-scale opts)))
 
 (defmethod renderer :hexagonal-tiled-map [opts]
-  (HexagonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
+  (HexagonalTiledMapRenderer. ^TiledMap (load-tiled-map opts)
+                              ^double (unit-scale opts)))
 
 (defmethod renderer :stage [_]
   (Stage.))
@@ -67,7 +70,7 @@
   (PerspectiveCamera.))
 
 (defn resize-camera!
-  [{:keys [^Camera camera]} width height]
+  [{:keys [^OrthographicCamera camera]} width height]
   (assert camera)
   (.setToOrtho camera false width height))