Removed earmuffs from the global variables

master
Abhinav Sarkar 2013-10-16 22:23:45 +05:30
parent c4f1ae4d39
commit 786280d310
1 changed files with 55 additions and 55 deletions

View File

@ -5,7 +5,7 @@
(:require-macros [frpong.core :refer (go go-loop rd wt)])) (:require-macros [frpong.core :refer (go go-loop rd wt)]))
;; * `signal` creates a new signal ;; * `signal` creates a new signal
;; * `keyboard`, `ticks` and `dom-events` create signals for keydown events, browser animation ticks and ;; * `keyboard`, `ticks` and `dom-events` create signals for keydown events, browser animation ticks and
;; JS DOM events repectively ;; JS DOM events repectively
;; * `mult` creates a mult(iple) of a signal which can then be tapped using `tap` to create a copy of the ;; * `mult` creates a mult(iple) of a signal which can then be tapped using `tap` to create a copy of the
;; original signal ;; original signal
@ -38,8 +38,8 @@
;; d: paddle positions | | ;; d: paddle positions | |
;; s: game state +------------------------------------------------------+ ;; s: game state +------------------------------------------------------+
;; ;;
;; All signals except the signal e are at the rate of the signal b. The signal e is at the rate ;; All signals except the signal e are at the rate of the signal b. The signal e is at the rate
;; at which the keyboard issues events. The signal b is at the rate at which the browser supplies ;; at which the keyboard issues events. The signal b is at the rate at which the browser supplies
;; animation frames. ;; animation frames.
(defn abs [x] (.abs js/Math x)) (defn abs [x] (.abs js/Math x))
@ -54,77 +54,77 @@
(defn sin [x] (.sin js/Math x)) (defn sin [x] (.sin js/Math x))
;; Global settings ;; Global settings
(def *width* (- (.-scrollWidth (.-body js/document)) 20)) (def width (- (.-scrollWidth (.-body js/document)) 20))
(def *height* (- (.-scrollHeight (.-body js/document)) 130)) (def height (- (.-scrollHeight (.-body js/document)) 130))
(def *center* [(/ *width* 2 ) (/ *height* 2)]) (def center [(/ width 2 ) (/ height 2)])
(def *padding* 5) (def padding 5)
(def *paddle-size* 100) (def paddle-size 100)
(def *ball-radius* 8) (def ball-radius 8)
(def *ball-speed* 0.6) (def ball-speed 0.6)
(def *init-vel-deg-lim* [35 55]) (def init-vel-deg-lim [35 55])
(def *perturb-factor* 0.05) (def perturb-factor 0.05)
(def *init-mass-radius* 0) (def init-mass-radius 0)
(def *paddle-width* 10) (def paddle-width 10)
(def *paddle-step* 8) (def paddle-step 8)
(def *max-paddle-y* (- *height* *paddle-size*)) (def max-paddle-y (- height paddle-size))
(def *ef-paddle-width* (+ *paddle-width* *padding*)) (def ef-paddle-width (+ paddle-width padding))
(def *init-paddle-pos* (/ (- *height* *paddle-size*) 2)) (def init-paddle-pos (/ (- height paddle-size) 2))
(def *gravity* (atom 0.005)) (def gravity (atom 0.005))
(def *gravity-step* 0.005) (def gravity-step 0.005)
(defn mass-radius [] (defn mass-radius []
(+ *init-mass-radius* (* (deref *gravity*) 1000))) (+ init-mass-radius (* (deref gravity) 1000)))
(defn setup-gravity-controls (defn setup-gravity-controls
"Sets up keyboard controls for changing gravity." "Sets up keyboard controls for changing gravity."
[] []
(let [keydowns (first (dom-events :keydown)) (let [keydowns (first (dom-events :keydown))
actions { 37 #(- % *gravity-step*) 39 #(+ % *gravity-step*) } actions { 37 #(- % gravity-step) 39 #(+ % gravity-step) }
mass-el (dom/by-id "mass")] mass-el (dom/by-id "mass")]
(go-loop (go-loop
(let [k (:keyCode (rd keydowns))] (let [k (:keyCode (rd keydowns))]
(when (contains? actions k) (when (contains? actions k)
(do (swap! *gravity* #(max 0 (min 0.1 ((actions k) %)))) (do (swap! gravity #(max 0 (min 0.1 ((actions k) %))))
(dom/set-attr! mass-el "r" (mass-radius)))))))) (dom/set-attr! mass-el "r" (mass-radius))))))))
(defn layout-game (defn layout-game
"Lays out the game screen." "Lays out the game screen."
[] []
(doto (dom/by-id "canvas") (doto (dom/by-id "canvas")
(dom/set-style! "width" (str *width* "px")) (dom/set-style! "width" (str width "px"))
(dom/set-style! "height" (str *height* "px"))) (dom/set-style! "height" (str height "px")))
(doto (dom/by-id "ball") (doto (dom/by-id "ball")
(dom/set-attr! "r" *ball-radius*) (dom/set-attr! "r" ball-radius)
(dom/set-attr! "cx" (first *center*)) (dom/set-attr! "cx" (first center))
(dom/set-attr! "cy" (second *center*))) (dom/set-attr! "cy" (second center)))
(doto (dom/by-id "mass") (doto (dom/by-id "mass")
(dom/set-attr! "r" (mass-radius)) (dom/set-attr! "r" (mass-radius))
(dom/set-attr! "cx" (first *center*)) (dom/set-attr! "cx" (first center))
(dom/set-attr! "cy" (second *center*))) (dom/set-attr! "cy" (second center)))
(doto (dom/by-id "score") (doto (dom/by-id "score")
(dom/set-attr! "x" (first *center*)) (dom/set-attr! "x" (first center))
(dom/set-attr! "y" (- *height* 50))) (dom/set-attr! "y" (- height 50)))
(doseq [id ["lpaddle" "rpaddle"]] (doseq [id ["lpaddle" "rpaddle"]]
(doto (dom/by-id id) (doto (dom/by-id id)
(dom/set-attr! "width" *paddle-width*) (dom/set-attr! "width" paddle-width)
(dom/set-attr! "height" *paddle-size*) (dom/set-attr! "height" paddle-size)
(dom/set-attr! "y" (/ (- *height* *paddle-size*) 2)))) (dom/set-attr! "y" (/ (- height paddle-size) 2))))
(dom/set-attr! (dom/by-id "lpaddle") "x" 0) (dom/set-attr! (dom/by-id "lpaddle") "x" 0)
(dom/set-attr! (dom/by-id "rpaddle") "x" (- *width* *paddle-width*))) (dom/set-attr! (dom/by-id "rpaddle") "x" (- width paddle-width)))
(defn initial-velocity (defn initial-velocity
"Calculates a random initial ball velocity, randomly in any four quadrants, between "Calculates a random initial ball velocity, randomly in any four quadrants, between
the limits of degrees specified by *init-vel-deg-lim*." the limits of degrees specified by init-vel-deg-lim."
[] []
(let [[l h] *init-vel-deg-lim* (let [[l h] init-vel-deg-lim
sgn #(if (< % 0.5) -1 1) sgn #(if (< % 0.5) -1 1)
deg (+ l (* (- h l) (rand))) deg (+ l (* (- h l) (rand)))
rad (deg->rad deg)] rad (deg->rad deg)]
(map #(* *ball-speed* %) (map #(* ball-speed %)
[(* (sgn (rand)) (sin rad)) (* (sgn (rand)) (cos rad))]))) [(* (sgn (rand)) (sin rad)) (* (sgn (rand)) (cos rad))])))
(defn start-game (defn start-game
@ -141,9 +141,9 @@
;; start the game by setting the initial values of the signals ;; start the game by setting the initial values of the signals
(go (go
(wt pos *center*) (wt pos center)
(wt vel init-vel) (wt vel init-vel)
(wt pd-pos [*init-paddle-pos* *init-paddle-pos*]) (wt pd-pos [init-paddle-pos init-paddle-pos])
(wt game-state [:moving 0])))) (wt game-state [:moving 0]))))
(defn start-on-space [] (defn start-on-space []
@ -181,7 +181,7 @@
(defn ticker (defn ticker
"Ticker component. "Ticker component.
Reads ticks generated by the browser from the `br-ticks` signal and outputs them to the Reads ticks generated by the browser from the `br-ticks` signal and outputs them to the
`game-ticks` signal as long as the `game-state` signal is not :gameover. `game-ticks` signal as long as the `game-state` signal is not :gameover.
Once the `game-state` signal is :gameover, stops the game by calling the `stop-game` function. Once the `game-state` signal is :gameover, stops the game by calling the `stop-game` function.
Each tick is the number of milliseconds since the last tick was generated." Each tick is the number of milliseconds since the last tick was generated."
@ -197,8 +197,8 @@
"Calculates acceleration due to gravitation for the ball caused by the mass placed at the "Calculates acceleration due to gravitation for the ball caused by the mass placed at the
center of the board." center of the board."
[[x y]] [[x y]]
(let [grav (deref *gravity*) (let [grav (deref gravity)
[cx cy] *center* [cx cy] center
x-dist (- cx x) x-dist (- cx x)
y-dist (- cy y) y-dist (- cy y)
distance (sqrt (+ (sq x-dist) (sq y-dist))) distance (sqrt (+ (sq x-dist) (sq y-dist)))
@ -240,27 +240,27 @@
ks (rd keys) ks (rd keys)
move (fn [pos up down] move (fn [pos up down]
(cond (cond
(contains? ks up) (max (- pos *paddle-step*) 0) (contains? ks up) (max (- pos paddle-step) 0)
(contains? ks down) (min (+ pos *paddle-step*) *max-paddle-y*) (contains? ks down) (min (+ pos paddle-step) max-paddle-y)
:else pos))] :else pos))]
(wt pos-out [(move lpos :w :s) (move rpos :up :down)])))) (wt pos-out [(move lpos :w :s) (move rpos :up :down)]))))
(defn in-y-range? [y paddle-y] (defn in-y-range? [y paddle-y]
(and (> y (- paddle-y *padding*)) (< y (+ paddle-y *paddle-size* *padding*)))) (and (> y (- paddle-y padding)) (< y (+ paddle-y paddle-size padding))))
(defn detect-x-collision [x y lpaddle-y rpaddle-y] (defn detect-x-collision [x y lpaddle-y rpaddle-y]
(cond (cond
(< x *ef-paddle-width*) (< x ef-paddle-width)
(if (in-y-range? y lpaddle-y) :collision-left :gameover) (if (in-y-range? y lpaddle-y) :collision-left :gameover)
(> x (- *width* *ef-paddle-width*)) (> x (- width ef-paddle-width))
(if (in-y-range? y rpaddle-y) :collision-right :gameover) (if (in-y-range? y rpaddle-y) :collision-right :gameover)
:else :moving)) :else :moving))
(defn detect-y-collision [y] (defn detect-y-collision [y]
(cond (cond
(< y *padding*) :collision-left (< y padding) :collision-left
(> y (- *height* *padding*)) :collision-right (> y (- height padding)) :collision-right
:else :moving)) :else :moving))
(defn collision? [state] (defn collision? [state]
(or (= state :collision-left) (= state :collision-right))) (or (= state :collision-left) (= state :collision-right)))
@ -272,7 +272,7 @@
:moving vel :moving vel
:gameover 0)) :gameover 0))
(defn perturb [v] (* v (+ 1 (* (rand) *perturb-factor*)))) (defn perturb [v] (* v (+ 1 (* (rand) perturb-factor))))
(defn collision-detector [ticks pos vel-in acc pd-pos game-state-in game-state vel-out] (defn collision-detector [ticks pos vel-in acc pd-pos game-state-in game-state vel-out]
"Collision Detector component. "Collision Detector component.
@ -300,8 +300,8 @@
y-collision (collision? y-state) y-collision (collision? y-state)
;; calculate next velocity and game state ;; calculate next velocity and game state
vel-xn (min *ball-speed* (+ (adjust-vel x-state vel-x) (* gx tick))) vel-xn (min ball-speed (+ (adjust-vel x-state vel-x) (* gx tick)))
vel-yn (min *ball-speed* (+ (adjust-vel y-state vel-y) (* gy tick))) vel-yn (min ball-speed (+ (adjust-vel y-state vel-y) (* gy tick)))
state-n (cond state-n (cond
(= x-state :gameover) :gameover (= x-state :gameover) :gameover
(or x-collision y-collision) :collision (or x-collision y-collision) :collision