Fixed trace disappearing.

Author: ForNeVeR

src/hyperspace/game.clj

@@ -24,20 +24,9 @@
         {point :center
          power :power
          angle :heading} player
-        bullet (make-bullet point (make-vector-radial power angle))
-        trace (make-trace bullet)]
+        bullet (make-bullet point (make-vector-radial power angle))]
     (assoc world
-      :bullets (conj (:bullets world) bullet)
-      :traces  (conj (:traces world) trace))))
-
-(defn move-bullet
-  [bullet planets]
-  (let [acceleration (get-acceleration bullet planets)
-        {position :center
-         velocity :velocity} bullet]
-    (assoc bullet
-      :center   (move-point position velocity)
-      :velocity (vector-sum velocity acceleration))))
+      :bullets (conj (:bullets world) bullet))))
 
 (defn destroy-bullet?
   [bullet planets]
@@ -49,21 +38,27 @@
                 planet-radius))
           planets)))
 
+(defn update-bullet
+  [bullet planets]
+  (if (= (:status bullet) :dead)
+    bullet
+    (let [acceleration (get-acceleration bullet planets)
+          {position :center
+           velocity :velocity
+           traces :traces} bullet]
+      (assoc bullet
+        :center   (move-point position velocity)
+        :velocity (vector-sum velocity acceleration)
+        :status   (if (destroy-bullet? bullet planets) :dead :alive)
+        :traces   (conj traces position)))))
+
 (defn update-world
   "Simulates few steps for world."
   [world time]
   (let [{bullets :bullets
-         planets :planets
-         traces  :traces} world]
-    (if (<= time 0)
+         planets :planets} world]
+    (if (< time 0)
       world
-      (recur
-        (assoc world
-          :bullets (doall
-                     (map #(move-bullet % planets)
-                       (filter #(not (destroy-bullet? % planets))
-                               bullets)))
-          :traces (doall
-                    (map #(update-trace %1 %2)
-                      traces bullets)))
-        (- time 1)))))
+      (recur (assoc world
+               :bullets (doall (map #(update-bullet % planets) bullets)))
+             (- time 1)))))

src/hyperspace/ui.clj

@@ -10,7 +10,6 @@
            (hyperspace.world Bullet
                              Planet
                              Player
-                             Trace
                              World)))
 
 (declare start-ui)
@@ -134,10 +133,10 @@
         display-y (:y display-point)]
     (draw-ellipse display-x display-y (normalize-x 5) (normalize-y 5) 30)))
 
-(defmethod render Trace
-  [trace]
+(defn draw-traces
+  [bullet]
   (GL11/glColor3f 1 1 0)
-  (doseq [point (:points trace)]
+  (doseq [point (:traces bullet)]
     (let [center (space-point-to-display point)
           {center-x :x center-y :y} center
           x1 (- center-x (normalize-x 1))
@@ -170,22 +169,22 @@
 
 (defmethod render Bullet
   [bullet]
-  (GL11/glColor3f 1 0 0)
-  (let [center (space-point-to-display (:center bullet))
-        {center-x :x center-y :y} center
-        x1 (- center-x (normalize-x 7))
-        y1 (- center-y (normalize-y 7))
-        x2 (+ center-x (normalize-x 7))
-        y2 (+ center-y (normalize-y 7))]
-    (GL11/glRectf x1 y1 x2 y2)))
+  (draw-traces bullet)
+  (when (= (:status bullet) :alive)
+    (GL11/glColor3f 1 0 0)
+    (let [center (space-point-to-display (:center bullet))
+          {center-x :x center-y :y} center
+          x1 (- center-x (normalize-x 7))
+          y1 (- center-y (normalize-y 7))
+          x2 (+ center-x (normalize-x 7))
+          y2 (+ center-y (normalize-y 7))]
+      (GL11/glRectf x1 y1 x2 y2))))
 
 (defmethod render World
   [{planets :planets
     players :players
-    bullets :bullets
-    traces  :traces}]
-  (doseq [object (concat traces
-                         planets
+    bullets :bullets}]
+  (doseq [object (concat planets
                          players
                          bullets)]
     (render object)))

src/hyperspace/world.clj

@@ -4,28 +4,20 @@
 
 (defrecord Planet [center radius mass])
 (defrecord Player [center heading power name])
-(defrecord Bullet [center velocity])
-(defrecord Trace [points])
+(defrecord Bullet [center velocity status traces])
 
-(defrecord World [planets players bullets traces])
+(defrecord World [planets players bullets])
 
 (def make-planet ->Planet)
 (def make-player ->Player)
-(def make-bullet ->Bullet)
 
-(defn make-trace
-  [bullet]
-  (->Trace (list (:center bullet))))
-
-(defn update-trace
-  [trace bullet]
-  (assoc trace
-    :points (conj (:points trace)
-                  (:center bullet))))
+(defn make-bullet
+  [center velocity]
+  (->Bullet center velocity :alive []))
 
 (defn make-world
   [planets players]
-  (->World planets players [] []))
+  (->World planets players []))
 
 (def min-x 100)
 (def max-x 700)

test/hyperspace/test/cases.clj

@@ -6,5 +6,5 @@
   []
   (let [players [(make-player (make-point 100 100) 0 0 "player-1")
                  (make-player (make-point 200 200) 0 0 "player-2")]
-        planet (make-planet (make-point 0 0) 10 100)]
+        planet (make-planet (make-point 0 0) 100 100e12)]
     (make-world [planet] players)))

test/hyperspace/test/game.clj

@@ -9,17 +9,21 @@
 
 ;; Helper functions:
 
-(defn bullet-count
+(defn alive-bullet-count
   [world]
-  (count (:bullets world)))
+  (count (filter #(= (:status %) :alive) (:bullets world))))
 
-(defn player-count
+(defn dead-bullets-count
   [world]
-  (count (:players world)))
+  (count (filter #(= (:status %) :dead) (:bullets world))))
 
 (defn trace-count
+  [bullet]
+  (count (:traces bullet)))
+
+(defn alive-player-count
   [world]
-  (count (:traces world)))
+  (count (:players world)))
 
 ;; Simple tests:
 
@@ -44,24 +48,39 @@
   (let [world1 (get-test-world)
         world2 (fire world1 "player-1")
         world3 (fire world2 "player-2")]
-    (is (= (bullet-count world1) 0))
-    (is (= (bullet-count world2) 1))
-    (is (= (bullet-count world3) 2))))
+    (is (= (alive-bullet-count world1) 0))
+    (is (= (alive-bullet-count world2) 1))
+    (is (= (alive-bullet-count world3) 2))))
 
 (deftest bullet-move-test
   (let [planet1 (make-planet (make-point 0 0) 1 100)
         planet2 (make-planet (make-point 0 5) 1 200)
         planets [planet1 planet2]
-        bullet (make-bullet (make-point 5 5) (make-vector 1 1))
-        acceleration (get-acceleration bullet planets)
-        new-velocity (vector-sum (:velocity bullet) acceleration)
-        new-bullet (move-bullet bullet planets)]
-    (is (almost= (:x (:center new-bullet)) 6))
-    (is (almost= (:y (:center new-bullet)) 6))
-    (is (almost= (:x (:velocity new-bullet))
-                 (:x new-velocity)))
-    (is (almost= (:y (:velocity new-bullet))
-                 (:y new-velocity)))))
+        bullet1 (make-bullet (make-point 5 5) (make-vector 1 1))
+        bullet2 (update-bullet bullet1 planets)
+
+        acceleration (get-acceleration bullet1 planets)
+        new-velocity (vector-sum (:velocity bullet1) acceleration)]
+    (is (points-almost= (:center bullet2)
+                        (make-point 6 6)))
+    (is (vectors-almost= (:velocity bullet2)
+                         new-velocity))))
+
+(deftest trace-test
+  (let [planet (make-planet (make-point 1 5) 5 100)
+        bullet1 (make-bullet (make-point 1 30) (make-vector 1 1))
+        bullet2 (update-bullet bullet1 [planet])
+        bullet3 (update-bullet bullet2 [planet])]
+    (is (= (trace-count bullet1) 0))
+    (is (= (trace-count bullet2) 1))
+    (is (= (trace-count bullet3) 2))
+
+    (is (points-almost= (first (:traces bullet2))
+                        (:center bullet1)))
+    (is (points-almost= (first (:traces bullet3))
+                        (:center bullet1)))
+    (is (points-almost= (last (:traces bullet3))
+                        (:center bullet2)))))
 
 (deftest bullet-destroy-test
   (let [planet (make-planet (make-point 0 0) 5 100)
@@ -72,28 +91,17 @@
 
 ;; Complex tests:
 
-(deftest simple-trace-test
-  (let [world1 (get-test-world)
-        world2 (fire world1 "player-1")
-        bullet1 (first (:bullets world2))
-        world3 (update-world world2 1)
-        bullet2 (first (:bullets world3))
-        trace (first (:traces world3))]
-      (is (= (first (:points trace))
-             (:center bullet1)))))
-
-(deftest trace-test
+(deftest complex-firing-test
   (let [world1 (get-test-world)
         world2 (fire world1 "player-1")
-        world3 (update-world world2 10000)
-        world4 (update-world (fire world3 "player-1") 10000)]
-    (is (= (bullet-count world3) 0))
-    (is (= (trace-count world3) 1))
+        world3 (update-world world2 10000)]
+    (is (= (alive-bullet-count world2) 1))
+    (is (= (dead-bullets-count world2) 0))
 
-    (is (= (bullet-count world4) 0))
-    (is (= (trace-count world4) 2))))
+    (is (= (alive-bullet-count world3) 0))
+    (is (= (dead-bullets-count world3) 1))))
 
 (deftest kill-test
   (let [world1 (get-test-world)
         world2 (update-world (fire world1 "player-2") 10000)]
-    (is (= (player-count world2) 1))))
+    (is (= (alive-player-count world2) 1))))

test/hyperspace/test/utils.clj

@@ -5,3 +5,13 @@
   (< (Math/abs (- a b)) eps))
 
 (def almost= (partial compare-with-eps 1e-6))
+
+(defn points-almost=
+  [p1 p2]
+  (and (almost= (:x p1) (:x p2))
+       (almost= (:y p1) (:y p2))))
+
+(defn vectors-almost=
+  [v1 v2]
+  ;; Vector is almost the same as point, so we can reuse points-amlost= function here.
+  (points-almost= v1 v2))

test/hyperspace/test/world.clj

@@ -23,17 +23,9 @@
   (let [bullet (make-bullet (make-point 10 20)
                             (make-vector 0 1))]
     (is (= (:center bullet) (make-point 10 20)))
-    (is (= (:velocity bullet) (make-vector 0 1)))))
-
-(deftest trace-test
-  (let [bullet1 (make-bullet (make-point 1 0) (make-vector 0 0))
-        bullet2 (make-bullet (make-point 10 20) (make-vector 0 0))
-        trace1 (make-trace bullet1)
-        trace2 (update-trace trace1 bullet2)]
-    (is (= (:points trace1) [(make-point 1 0)]))
-    (is (= (set (:points trace2))
-           (set [(make-point 1 0)
-                 (make-point 10 20)])))))
+    (is (= (:velocity bullet) (make-vector 0 1)))
+    (is (= (:status bullet) :alive))
+    (is (= (:traces bullet) []))))
 
 (deftest world-test
   (let [planet1 (make-planet (make-point 1 0) 7000 10000)