       (loop [i unit-count]
         (when (> i 0)
           (let [unit-id (read)
-                unit-type (read)
+                unit-type (nth unit-types (read))
                 player-id (read)
                 mass (read)
                 radius (read)

  "Test whether 'my-unit' is 'in' the 'other-unit'"
  (< (distance (:x my-unit) (:y my-unit) (:x other-unit) (:y other-unit)) (:radius other-unit)))

(defn compute-action [my-unit next-wreck]
  (cond
    (in my-unit next-wreck) "WAIT"
    true (str (:x next-wreck) " " (:y next-wreck) " 150")))

(defn -main [& args]
  (while true

                unit (Unit. unit-id unit-type player-id mass radius x y vx vy extra extra2)]
            (swap! units conj unit)
            (recur (dec i)))))
      (let [wrecks (filter #(= (:unit-type %) :wreck) @units)
            wrecks-with-water (filter #(> (:extra %) 0) wrecks)
            tankers (filter #(= (:unit-type %) :tanker) @units)
            reapers (filter #(= (:unit-type %) :reaper) @units)
            destroyers (filter #(= (:unit-type %) :destroyer) @units)
            enemy-reapers (filter #(not= (:player-id %) 0) reapers)
            enemy-destroyers (filter #(not= (:player-id %) 0) destroyers)
            my-reaper (first (filter #(= (:player-id %) 0) reapers))
            my-destroyer (first (filter #(= (:player-id %) 0) destroyers))
            next-wreck (first (sort-by #(distance (:x my-reaper) (:y my-reaper) (:x %) (:y %)) wrecks-with-water))
            next-tanker (first (sort-by #(distance (:x my-destroyer) (:y my-destroyer) (:x %) (:y %)) tankers))]
        (binding [*out* *err*] (println "wrecks : " (string/join " " (map #(into {} %) wrecks)))
                               (println "wrecks with water: " (string/join " " (map #(into {} %) wrecks-with-water)))
                               (println "tankers : " (string/join " " (map #(into {} %) tankers)))
                               (println "reapers : " (string/join " " (map #(into {} %) reapers)))
                               (println "destroyers : " (string/join " " (map #(into {} %) destroyers)))
                               (println "enemy reapers: " (string/join " " (map #(into {} %) enemy-reapers)))
                               (println "enemy destroyers: " (string/join " " (map #(into {} %) enemy-destroyers)))
                               (println "my reaper : " (string/join " " my-reaper))
                               (println "my-destroyer : " (string/join " " my-destroyer))
                               (println "next-wreck : " (string/join " " next-wreck))
                               (println "next-tanker : " (string/join " " next-tanker)))
        (println (compute-reaper-action my-reaper next-wreck))
        (println (compute-destroyer-action my-destroyer next-tanker))
        (println "WAIT")))))

      ; (binding [*out* *err*]
