             hinges)))
 
 (defn calculate-gravity-forces [nodes]
-    (zipmap (keys nodes) (repeat [0 (- gravity-strength)])))
+    (zipmap (keys nodes)
+        (map (fn [{m :mass}]
+            [0 (- (* gravity-strength m))])
+            (vals nodes))))
 
 (defn calculate-ground-forces [nodes]
     (zipmap (keys nodes)
         (map (fn [{[ x y ] :pos [ xv yv ] :vel }]
             (if (< y 0)
-                (vec* [(- xv) (+ (Math/max 0 (- yv)) (- y))] ground-strength)
+                (vec+
+                    (vec* [(- xv) (Math/max 0 (- yv))] ground-grip-strength)
+                    (vec* [0 (- y)] ground-rebound-strength))
                 [0 0])) (vals nodes))))
+
+(defn calculate-drag-forces [nodes]
+    (zipmap (keys nodes)
+        (map (fn [{v :vel m :mass}] (vec* v (- (* m drag-factor))))
+            (vals nodes))))
 
 (defn calculate-all-node-forces [{:keys [nodes springs hinges]}]
     (merge-with vec+
         (calculate-spring-forces nodes springs)
         (calculate-hinge-forces nodes hinges)
         (calculate-gravity-forces nodes)
-        (calculate-ground-forces nodes)))
+        (calculate-ground-forces nodes)
+        (calculate-drag-forces nodes)))
 
 (defn update-node-velocities [nodes forces time-step]
     (merge-with (fn [n f]
         (assoc n
-            :vel (vec+ (:vel n) (vec* f time-step))))
+            :vel (vec+ (:vel n) (vec* f (/ time-step (:mass n))))))
         nodes
         forces))
 

        game-state-ref (atom initial-game-state)
        input-state-ref (atom {:keys (set)})
        canvas (dom/createDom "div" {} "")
        button (dom/createDom "button" {} "Click!")
        tick-timer (goog.Timer. (Math/round (* 1000 tick-step)))
        render-timer (goog.Timer. (Math/round (* 1000 render-step)))
        ]

(defn rot-cw [[x y]] [y (- x)])
(defn rot-ccw [[x y]] [(- y) x])

(defn make-node [x y m] {:pos [x y] :vel [0 0] :mass m})
(defn make-spring [a b] {:node-a a :node-b b})
(defn make-hinge [a b c min-a max-a] {:node-a a :node-b b :node-c c :min-modifier-angle min-a :max-modifier-angle max-a})
(defn make-state [nodes springs hinges] {
