core.clj

 (ns chickenz.core
   (:require [bukkure.logging :as log]
             [bukkure.bukkit :as bk]
             [bukkure.items :as i]
             [bukkure.events :as ev]
             [bukkure.entity :as ent]
             [bukkure.world :as world])
   (:import [org.bukkit ChatColor]
            [org.bukkit.inventory.meta ItemMeta]))

(defonce plugin (atom nil))

(defn player-by-name 
  "Get a player by name"
  [name]
  (.. (bk/server) (getPlayer name)))

(defn me
  "Get's me!"
  []
  (player-by-name "SevereOverfl0w"))

(defn give-item
  [player item]
  (.setItemInHand player item))

(defn give-item-inv
  [player item index]
  (.setItem (.getInventory player) index item))


(defn get-item-meta
  [item]
  (.getItemMeta item))

(def gun-lore ["Shoot deadly"
               "chicken bombs"
               "from this gun"])
(def gun-name (str "Chicken Gun" ChatColor/RESET))

(defn create-gun-meta
  [item]
  (let [meta (get-item-meta item)]
    (.setLore meta (java.util.ArrayList. gun-lore))
    (.setDisplayName meta gun-name)
    meta))

(defn create-gun
  []
  (let [not-quite-a-gun (i/item-stack :bow)
        gun-meta (create-gun-meta not-quite-a-gun)]
    (.setItemMeta not-quite-a-gun gun-meta)
    (.addEnchantment not-quite-a-gun org.bukkit.enchantments.Enchantment/ARROW_INFINITE 1)
    not-quite-a-gun))

(defn give-gun
  [player]
  (give-item player (create-gun))
  (give-item-inv player (i/item-stack :arrow) 1))

(defn gun?
  [might-be-a-gun]
  (let [meta (get-item-meta might-be-a-gun)
        lore (into [] (.getLore meta))]
    (or (some (into #{} gun-lore) lore)
        (= (.getDisplayName meta) gun-name))))

(defn shooting?
  [ev]
  (let [action (.getAction ev)]
  (or (= action org.bukkit.event.block.Action/RIGHT_CLICK_AIR)
      (= action org.bukkit.event.block.Action/RIGHT_CLICK_BLOCK))))

(defonce launched-eggs (atom #{}))

(defn launch-egg
  [plr & [velocity]]
  (let [egg (.launchProjectile plr org.bukkit.entity.Egg)
        vel (or velocity (.getVelocity egg))
        eid (.getEntityId egg)]
    (.multiply vel 0.2)
    (.setVelocity egg vel)
    (swap! launched-eggs conj eid)
    egg))

(defn shoot-gun
  [ev]
  (let [player (cast org.bukkit.entity.Player (.getEntity ev))
        in-hand (.. player getInventory getItemInHand)]
  (when (gun? in-hand)
    (.setProjectile ev (launch-egg player (.getVelocity (.getProjectile ev)))))))
    

(defonce bomb-chickens (atom #{}))

(defn boom-chicken
  [chicken]
  (let [eid (.getEntityId chicken)]
    (when-not (.isDead chicken)
        (.setHealth chicken 0)
        (world/explode (.getLocation chicken) 4))))

(defn bomb-chicken-die
  [ev]
  (let [drops (.getDrops ev)]
    (.clear drops)
    (.setDroppedExp ev 0)
    (swap! bomb-chickens disj (.getEntityId (.getEntity ev)))))

(defn create-killer-chicken
  ([loc] (create-killer-chicken loc 1))
  ([loc secs]
  (let [chicken (ent/spawn-entity loc :chicken)]
    (.setCustomName chicken "Bomb")
    (swap! bomb-chickens conj (.getEntityId chicken))
    (bk/delayed-task @plugin #(boom-chicken chicken) (bk/seconds-to-ticks secs)))))

(defn egg-land
  [ev]
  (let [egg (.getEgg ev)
        eid (.getEntityId egg)
        eggLoc (.getLocation egg)]
    (when (some #{eid} @launched-eggs)
      (swap! launched-eggs disj eid)
      (.setHatching ev false)
      (create-killer-chicken eggLoc))))


(defonce fountainTask (atom nil))
(defn start-killer-fountain
  [loc]
  (if-not @fountainTask
    (let [task-id (bk/repeated-task @plugin #(create-killer-chicken loc 3) 0 5)]
      (reset! fountainTask task-id)
    )
    (log/info "Fountain already running!")))

(defn stop-killer-fountain
  []
  (if @fountainTask
    (do
      (bk/cancel-task @fountainTask)
      (reset! fountainTask nil))
    (log/info "No fountain running")))

(defn events
  []
  [(ev/event "entity.entity-shoot-bow" #'shoot-gun)
   (ev/event "player.player-egg-throw" #'egg-land)
   (ev/event "entity.entity-death" #'bomb-chicken-die)])

(defn start
  []
  (ev/register-eventlist @plugin (events)))

(defn stop
  []
  (doseq [hl (org.bukkit.event.HandlerList/getHandlerLists)]
    (.unregister hl @plugin)))

(defn on-enable [plugin-instance]
  (log/info "Starting your new bukkure plugin!")
  (reset! plugin plugin-instance)
  (start))

(defn on-disable [plugin]
  (log/info "Stopping your new bukkure plugin!"))