night farm

gistfile1.clj

(ns farm.core
  (:use 
    [arcadia.core]
    [hard.core] 
    [hard.physics]
    [hard.input]
    [tween.core :as tween]
    [hard.edit :only [active]]
    [farm.invaders :as invaders])
  (:import
    [UnityEngine Time]))


(declare bug-down)

(def farm (atom {}))
(def farmer (atom nil))
(def farmer-idle (atom true))
(def farmer-right-hand (atom false))
(def farm-time (atom 0))

(defn ->coord2d [go] (mapv int (->vec (->v3 go))))



(defn grown? []
  (let [[x y z] (->coord2d @farmer)]
    (if-let [tile (get @farm [x y])]
      (if (> (:growth tile) 50) true false) false)))

(defn throw-crop []
  (let [[x y z] (->coord2d @farmer)   
        j1 (tween/position (->v3 [0 0.25]) :+ 0.1)
        j2 (tween/position (->v3 [0 -0.25]) :+ 0.1)
        veg @farmer-right-hand
        vs (tween/scale (->v3 [5 5 5]) :+ 2)
        vp (tween/position (->v3 [0 20 0]) :+ 2  #(destroy! %))]
    (reset! farmer-right-hand false)
    (unparent veg)
    (set! (.isKinematic (->rigidbody2d veg)) false)
    (link! j1 j2)
    (j1 @farmer)
    (vs veg) (vp veg)))

(defn pick-crop []
    (let [[x y z] (->coord2d @farmer)
          crop (rand-nth ["turnip" "turnip" "eggplant"])]
      (destroy! (:go (get @farm [x y])))
      (let [turnip (clone! (resource crop) [(+ x 0.25) y 0])]
        (parent! turnip @farmer)
        (reset! farmer-right-hand turnip))
      (swap! farm conj
        {[x y] {:growth 0 :go (clone! (resource "dirt") [x y 0])}})))

(defn action []
  (when @farmer-idle
    (cond 
      @farmer-right-hand (throw-crop)
      (grown?) (pick-crop))))


(defn walk [[x y]]
  (when @farmer-idle
    (let [[tx ty _] (v+ [x y] (->coord2d @farmer))]
      (when (and (< tx 10) (< ty 3) (> tx -1) (> ty -1))
        (swap! farmer-idle not)
        (let [t (tween/position (->v3 [x y 0]) :+ 0.2 :pow3 
                  (fn [_] (swap! farmer-idle not)))]
        (t @farmer))))))

(defn update-farm [delta]
  (each @farm [[[x y] {:keys [growth go]}]]
    (when (< growth 50)
      (let [ng (+ growth delta)
            go2 (if (> ng 50) (clone! :dirt-green [x y 0]) go)]
        (swap! farm conj {[x y] {:growth ng :go go2}}) ))))

(defn update-level [c]
  (update-farm Time/deltaTime)
    (cond
      (key? "a") (walk [-1 0])
      (key? "d") (walk [1 0])
      (key? "w") (walk [0 1])
      (key? "s") (walk [0 -1])
      (key-down? "space") (action)))

(defn tick-clock [go]
  (set! (.text (component (find-name "clock(Clone)") "TextMesh")) 
    (str (swap! farm-time inc)))
  (when (< 2 (rand-int 30))
    (invaders/spawn-bug)))

(defn make-level []
  (clear-cloned)
  (reset! farmer (clone! :farmer))
  (let [menu (clone! :menu)
        cam (clone! :camera)
        clock (clone! :clock)
        sec (tween/scale (->v3 [0 0 0]) :+ 1.0 tick-clock)]
    (link! sec sec)
    (sec clock)
    (dorun
      (for [x (range 10)
            y (range 3)
            :let [d (clone! :dirt [x y 0])
                  growth (rand-int 50)]]
        (do (swap! farm conj {[x y] {:growth growth :go d}}))))))

(def b-p (tween/scale (->v3 [1.2 1.2 1.2]) 0.3 :pow3))
(def b-p2 (assoc b-p :target (->v3 [1 1 1])))
(def b-t (tween/text-color (color 0.5 1 0) 0.3 :pow3))
(def b-t2 (assoc b-t :target (color 1 1 1)))
(def b-t3 (assoc (assoc b-t :target (color 1 0 0)) :duration 0.2))

(def >dissapear (tween/scale (->v3 [0 0 0]) 0.2 #(destroy! %)))

(defn button-enter [c]
  (b-p (->go c))
  (b-t (child-named (->go c) "text")))

(defn button-exit [c]
  (b-p2 (->go c))
  (b-t2 (child-named (->go c) "text")))

(defn button-down [c]
  (b-t3 (child-named (->go c) "text")))

(defn restart-level [c]
  (make-level))


(def >spark (tween/scale (->v3 [0.2 0.2 0.2]) :+ 1.0 >dissapear))


(defn make-spark [v blood]
  (>spark (clone! (resource blood) v)))

(def points-up (tween/position (->v3 [0 2 0]) :+ 1.0 {:in :pow2}))
(def points-c (tween/text-color (color 0 0 0 0) 1.0 :pow3))
(def points-s (tween/scale (->v3 [0.5 0.5 0.5]) :+ 0.4 {:in :pow2}))
(def points-s2 (tween/scale (->v3 [0.5 0.5 0.5]) :+ 0.4 {:out :pow2}))

(defn make-points [v blood points]
  (let [colr (case blood "spark-blue" (color 0 0.8 0.9) "spark-red" (color 1 0.3 0) (color 1 1 0))
        start (tween/text-color colr 0.1)
        go (clone! (resource "points") (->v3 [-2 0 0]))]
        (link! start points-up >dissapear)
        (link! start points-c)
        (link! start points-s points-s2)
        (set! (.text (component go "TextMesh")) (str points))
        (start go)))


(def >die (tween/scale (->v3 [0 0 0]) 0.2 :pow4))

(defn turnip-enter [c collision] 
  (let [hit-go (.gameObject collision)]
    (when-let [bug (.GetComponent hit-go farm.invaders.Bug)]
      (mapv #(make-spark (.point %) (.blood bug))
        (.contacts collision))
      ;need to make a tween that handles the single-enemy hit results
      ((tween/scale (->v3 [0 0 0]) 0.2 (fn [_] (make-points (->v3 bug) (.blood bug) (.points bug)))) hit-go)
      (when (= (.name (->go c)) "turnip(Clone)") 
        (>dissapear (->go c))))))

(defn turnip-exit [c collision] )


(make-level)