Browse Source

Removed earmuffs from the global variables

master
Abhinav Sarkar 9 years ago
parent
commit
786280d310
  1. 110
      src/cljs/frpong/core.cljs

110
src/cljs/frpong/core.cljs

@ -5,7 +5,7 @@
(:require-macros [frpong.core :refer (go go-loop rd wt)]))
;; * `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
;; * `mult` creates a mult(iple) of a signal which can then be tapped using `tap` to create a copy of the
;; original signal
@ -38,8 +38,8 @@
;; d: paddle positions | |
;; s: game state +------------------------------------------------------+
;;
;; 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
;; 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
;; animation frames.
(defn abs [x] (.abs js/Math x))
@ -54,77 +54,77 @@
(defn sin [x] (.sin js/Math x))
;; Global settings
(def *width* (- (.-scrollWidth (.-body js/document)) 20))
(def *height* (- (.-scrollHeight (.-body js/document)) 130))
(def *center* [(/ *width* 2 ) (/ *height* 2)])
(def *padding* 5)
(def *paddle-size* 100)
(def width (- (.-scrollWidth (.-body js/document)) 20))
(def height (- (.-scrollHeight (.-body js/document)) 130))
(def center [(/ width 2 ) (/ height 2)])
(def padding 5)
(def paddle-size 100)
(def *ball-radius* 8)
(def *ball-speed* 0.6)
(def *init-vel-deg-lim* [35 55])
(def *perturb-factor* 0.05)
(def ball-radius 8)
(def ball-speed 0.6)
(def init-vel-deg-lim [35 55])
(def perturb-factor 0.05)
(def *init-mass-radius* 0)
(def init-mass-radius 0)
(def *paddle-width* 10)
(def *paddle-step* 8)
(def *max-paddle-y* (- *height* *paddle-size*))
(def *ef-paddle-width* (+ *paddle-width* *padding*))
(def *init-paddle-pos* (/ (- *height* *paddle-size*) 2))
(def paddle-width 10)
(def paddle-step 8)
(def max-paddle-y (- height paddle-size))
(def ef-paddle-width (+ paddle-width padding))
(def init-paddle-pos (/ (- height paddle-size) 2))
(def *gravity* (atom 0.005))
(def *gravity-step* 0.005)
(def gravity (atom 0.005))
(def gravity-step 0.005)
(defn mass-radius []
(+ *init-mass-radius* (* (deref *gravity*) 1000)))
(+ init-mass-radius (* (deref gravity) 1000)))
(defn setup-gravity-controls
"Sets up keyboard controls for changing gravity."
[]
(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")]
(go-loop
(let [k (:keyCode (rd keydowns))]
(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))))))))
(defn layout-game
"Lays out the game screen."
[]
(doto (dom/by-id "canvas")
(dom/set-style! "width" (str *width* "px"))
(dom/set-style! "height" (str *height* "px")))
(dom/set-style! "width" (str width "px"))
(dom/set-style! "height" (str height "px")))
(doto (dom/by-id "ball")
(dom/set-attr! "r" *ball-radius*)
(dom/set-attr! "cx" (first *center*))
(dom/set-attr! "cy" (second *center*)))
(dom/set-attr! "r" ball-radius)
(dom/set-attr! "cx" (first center))
(dom/set-attr! "cy" (second center)))
(doto (dom/by-id "mass")
(dom/set-attr! "r" (mass-radius))
(dom/set-attr! "cx" (first *center*))
(dom/set-attr! "cy" (second *center*)))
(dom/set-attr! "cx" (first center))
(dom/set-attr! "cy" (second center)))
(doto (dom/by-id "score")
(dom/set-attr! "x" (first *center*))
(dom/set-attr! "y" (- *height* 50)))
(dom/set-attr! "x" (first center))
(dom/set-attr! "y" (- height 50)))
(doseq [id ["lpaddle" "rpaddle"]]
(doto (dom/by-id id)
(dom/set-attr! "width" *paddle-width*)
(dom/set-attr! "height" *paddle-size*)
(dom/set-attr! "y" (/ (- *height* *paddle-size*) 2))))
(dom/set-attr! "width" paddle-width)
(dom/set-attr! "height" paddle-size)
(dom/set-attr! "y" (/ (- height paddle-size) 2))))
(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
"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)
deg (+ l (* (- h l) (rand)))
rad (deg->rad deg)]
(map #(* *ball-speed* %)
(map #(* ball-speed %)
[(* (sgn (rand)) (sin rad)) (* (sgn (rand)) (cos rad))])))
(defn start-game
@ -141,9 +141,9 @@
;; start the game by setting the initial values of the signals
(go
(wt pos *center*)
(wt pos center)
(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]))))
(defn start-on-space []
@ -181,7 +181,7 @@
(defn ticker
"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.
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."
@ -197,8 +197,8 @@
"Calculates acceleration due to gravitation for the ball caused by the mass placed at the
center of the board."
[[x y]]
(let [grav (deref *gravity*)
[cx cy] *center*
(let [grav (deref gravity)
[cx cy] center
x-dist (- cx x)
y-dist (- cy y)
distance (sqrt (+ (sq x-dist) (sq y-dist)))
@ -240,27 +240,27 @@
ks (rd keys)
move (fn [pos up down]
(cond
(contains? ks up) (max (- pos *paddle-step*) 0)
(contains? ks down) (min (+ pos *paddle-step*) *max-paddle-y*)
(contains? ks up) (max (- pos paddle-step) 0)
(contains? ks down) (min (+ pos paddle-step) max-paddle-y)
:else pos))]
(wt pos-out [(move lpos :w :s) (move rpos :up :down)]))))
(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]
(cond
(< x *ef-paddle-width*)
(< x ef-paddle-width)
(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)
:else :moving))
(defn detect-y-collision [y]
(cond
(< y *padding*) :collision-left
(> y (- *height* *padding*)) :collision-right
:else :moving))
(< y padding) :collision-left
(> y (- height padding)) :collision-right
:else :moving))
(defn collision? [state]
(or (= state :collision-left) (= state :collision-right)))
@ -272,7 +272,7 @@
:moving vel
: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]
"Collision Detector component.
@ -300,8 +300,8 @@
y-collision (collision? y-state)
;; calculate next velocity and game state
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-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)))
state-n (cond
(= x-state :gameover) :gameover
(or x-collision y-collision) :collision

Loading…
Cancel
Save