cleanup

.gitignore

@@ -12,4 +12,6 @@ pom.xml.asc
 .lein-failures
 .nrepl-port
 figwheel_server.log
-resources/public/js
+resources/public/js
+*.iml
+.idea

src/cljs/topdown2d/collision.cljs

@@ -34,16 +34,6 @@
       :s (assoc obj :y (+ y pxs))
       obj)))
 
-(defn bump-into [obj obj2]
-  (let [{:keys [x y w h d]} obj
-        {ox :x oy :y ow :w oh :h} obj2]
-    (case d
-      :w (assoc obj :x (+ ox ow 1))
-      :e (assoc obj :x (dec (- ox w)))
-      :n (assoc obj :y (+ oy oh 1))
-      :s (assoc obj :y (dec (- oy h)))
-      obj)))
-
 (defn bump-inside-container [obj container]
   (let [{:keys [x y w h d]} obj
         {cx :x cy :y cw :w ch :h} container]
@@ -55,12 +45,8 @@
       obj)))
 
 (defn pps->px [gamestate obj]
-  (let [prev (get-in gamestate [:timing :prev])
+  (* (:pps obj)
-        now (get-in gamestate [:timing :now])
+     (-> gamestate :timing :elapsed)))
-        secs (/ (- now prev) 1000)
-        secs (-> gamestate :timing :elapsed)
-        pps (:pps obj)]
-    (* pps secs)))
 
 (defn move-inside [obj container pxs]
   (let [moved (moved-object obj pxs)]

src/cljs/topdown2d/core.cljs

@@ -18,7 +18,10 @@
             ;; difference between prev and now in seconds
             :elapsed 0}
    ;; width and height of the canvas
-   :dimensions {:w (* 16 11 3)
+   :dimensions {;; 16px tile size
+                ;; 11 tiles wide, 9 high
+                ;; 3 times zoom
+                :w (* 16 11 3)
                 :h (* 16 9 3)}
    :input {:dir :?}
    ;; currently active scene
@@ -29,6 +32,8 @@
 
 (def reloaded (atom false))
 
+(defn nao [] (.now js/performance))
+
 (defn curr-fps
   "calculates the current fps using the elapsed time"
   [elapsed]
@@ -65,7 +70,7 @@
 (defn update-step
   "updates timing information and the current scene"
   [gamestate]
-  (let [now (.now js/performance)
+  (let [now (nao)
         secs (elapsed-seconds gamestate now)
         scene (curr-scene gamestate)
         continue? (continue-running? (:continue? gamestate))]
@@ -78,7 +83,7 @@
                 (if continue?
                   (run-scene-update $ scene)
                   scene))
-      (assoc-in $ [:timing :prev] (.now js/performance)))))
+      (assoc-in $ [:timing :prev] (nao)))))
 
 (defn draw-fps
   "draws the current fps"

src/cljs/topdown2d/demoscene.cljs

@@ -13,47 +13,47 @@
       (.then #(.json %))
       (.then #(reset! map-def (js->clj %))))
   (merge
-   scenestate
+    scenestate
-   {:map-def {:images {:pokelike (by-id "demoscene-tileset")}
+    {:map-def {:images {:pokelike (by-id "demoscene-tileset")}
-              :def nil
+               :def nil
-              :zoom 3}
+               :zoom 3}
-    :player {:x (/ (get-in gamestate [:dimensions :w]) 2)
+     :player {:x (/ (get-in gamestate [:dimensions :w]) 2)
-             :y (/ (get-in gamestate [:dimensions :h]) 2)
+              :y (/ (get-in gamestate [:dimensions :h]) 2)
-             :w 0 :h 0
+              :w 0 :h 0
-             :d :s
+              :d :s
-             :animation {:ids {:s 778 :n 778
+              :animation {:ids {:s 778 :n 778
-                               :e 819 :w 819}
+                                :e 819 :w 819}
-                         :last-cycle 0
+                          :last-cycle 0
-                         :curr-id 778
+                          :curr-id 778
-                         :tileset :pokelike
+                          :tileset :pokelike
-                         :tileset-def nil
+                          :tileset-def nil
-                         :image (by-id "demoscene-tileset")}}
+                          :image (by-id "demoscene-tileset")}}
-    :viewport {:keep-in {:x 0 :y 0
+     :viewport {:keep-in {:x 0 :y 0
-                         :w 0 :h 0}
+                          :w 0 :h 0}
-               :tileset :pokelike
+                :tileset :pokelike
-               :image (by-id "demoscene-tileset")
+                :image (by-id "demoscene-tileset")
-               :tileset-def nil
+                :tileset-def nil
-               :x 6 :y 9
+                :x 6 :y 9
-               :w (get-in gamestate [:dimensions :w])
+                :w (get-in gamestate [:dimensions :w])
-               :h (get-in gamestate [:dimensions :h])
+                :h (get-in gamestate [:dimensions :h])
-               :d :?
+                :d :?
-               ;; pixels per second
+                ;; pixels per second
-               :pps 150}}))
+                :pps 150}}))
 
 (defn update-player [gamestate player dir]
   (let [old-dir (:d player)
         new-dir (if (= :? dir) old-dir dir)]
     (as-> player p
-      (assoc p :d new-dir)
+          (assoc p :d new-dir)
-      (if (= :? dir)
+          (if (= :? dir)
-        (sprites/reset player)
+            (sprites/reset player)
-        (sprites/proc gamestate p)))))
+            (sprites/proc gamestate p)))))
 
 (defn update-viewport [gamestate viewport dir]
   (collision/move-inside
-   (assoc viewport :d dir)
+    (assoc viewport :d dir)
-   (:keep-in viewport)
+    (:keep-in viewport)
-   (collision/pps->px gamestate viewport)))
+    (collision/pps->px gamestate viewport)))
 
 (defn init-viewport [scenestate]
   (let [{loaded-def :def
@@ -90,10 +90,7 @@
   (if (and (not (-> scenestate :map-def :def))
            (some? @map-def))
     (let [loaded-def (walk/keywordize-keys @map-def)
-          zoom (get-in scenestate [:map-def :zoom])
+          zoom (get-in scenestate [:map-def :zoom])]
-          viewport (:viewport scenestate)
-          {mw :width mh :height
-           tw :tilewidth th :tileheight} loaded-def]
       (-> scenestate
           (assoc-in [:map-def :def] loaded-def)
           (update-in [:map-def :def]
@@ -108,12 +105,11 @@
         viewport (:viewport new-scenestate)
         dir (-> gamestate :input :dir)]
     (assoc new-scenestate
-           :player (update-player gamestate player dir)
+      :player (update-player gamestate player dir)
-           :viewport (update-viewport gamestate viewport dir))))
+      :viewport (update-viewport gamestate viewport dir))))
 
 (defn draw-scene [gamestate scenestate]
   (let [viewport (:viewport scenestate)
-        {:keys [x y w h background]} viewport
         ctx (:ctx gamestate)]
     (when (-> scenestate :map-def :def)
       (tileset/draw-viewport (:map-def scenestate)

src/cljs/topdown2d/input.cljs

@@ -6,19 +6,19 @@
   (get @keysdown (name code) false))
 
 (.addEventListener
- js/document
+  js/document
- "keydown"
+  "keydown"
- (fn [event]
+  (fn [event]
-   (swap! keysdown #(assoc % (.-code event) true))
+    (swap! keysdown #(assoc % (.-code event) true))
-   false))
+    false))
 
 (.addEventListener
- js/document
+  js/document
- "keyup"
+  "keyup"
- (fn [event]
+  (fn [event]
-   (swap! keysdown
+    (swap! keysdown
-          #(assoc % (.-code event) false))
+           #(assoc % (.-code event) false))
-   false))
+    false))
 
 (defn dir []
   (cond

src/cljs/topdown2d/sprites.cljs

@@ -39,7 +39,7 @@
          {:keys [image size cycle] :as sprite} :sprite} obj
         pos (pos-in-sprite sprite d)]
     (.drawImage
-     ctx
+      ctx
-     image
+      image
-     (:x pos) (:y pos) size size
+      (:x pos) (:y pos) size size
-     x y size size)))
+      x y size size)))

src/cljs/topdown2d/tileset.cljs

@@ -1,5 +1,4 @@
-(ns topdown2d.tileset
+(ns topdown2d.tileset)
-  (:require [topdown2d.collision :as coll]))
 
 (defn next-animation-cycle [animation curr-cycle]
   (let [curr-ix (.indexOf animation curr-cycle)
@@ -15,7 +14,7 @@
 
 (defn tick-animation [tileset-def anim-def now]
   (let [map-def (:def tileset-def)
-        {:keys [ids last-cycle curr-id tileset]} anim-def
+        {:keys [last-cycle curr-id tileset]} anim-def
         animation (->> (map-def->tileset map-def tileset)
                        :tiles
                        (filter #(= curr-id (:id %)))
@@ -32,7 +31,7 @@
              :curr-id (:tileid next-cycle))
       anim-def)))
 
-(defn ix->coords [ix width height]
+(defn ix->coords [ix width]
   (let [x (rem ix width)]
     [(dec x)
      (/ (- ix x) width)]))
@@ -40,8 +39,7 @@
 (defn layer->dest [tileset layer]
   (map-indexed
    (fn [ix tile]
-     (let [{:keys [width height]} layer
+     (let [[dxc dyc] (ix->coords ix (:width layer))
-           [dxc dyc] (ix->coords ix width height)
            {:keys [target-width target-height]} tileset]
        {:tile tile
         :x (* dxc target-width)
@@ -52,9 +50,8 @@
 
 (defn draw-tile [ctx tileset image tileid dest]
   (let [{:keys [tileheight tilewidth
-                tiles-x tiles-y
+                tiles-x target-width target-height]} tileset
-                target-width target-height]} tileset
+        [x y] (ix->coords tileid tiles-x)
-        [x y] (ix->coords tileid tiles-x tiles-y)
         sx (* x tilewidth)
         sy (* y tileheight)]
     (.drawImage ctx image
@@ -83,12 +80,9 @@
 
 (defn draw-viewport [map-def ctx viewport]
   (let [def (:def map-def)
-        {:keys [tileheight tilewidth
-                height width layers]} def
-        tileset-id (:tileset viewport)
         image (:image viewport)
         tileset (:tileset-def viewport)]
-    (doseq [layer layers]
+    (doseq [layer (:layers def)]
       (doseq [dest layer
               :let [dx (- (:x dest) (:x viewport))
                     dy (- (:y dest) (:y viewport))]]