                   (not (and (has? card :subtype "Current")
                             (get-in @state [side :register :cannot-play-current])))
                   (not (and (has? card :subtype "Priority")
-                            (get-in @state [side :register :spent-click])))
-                  (pay state side card :credit (:cost card) extra-cost
-                       (when-not no-additional-cost additional-cost)))
-         (let [c (move state side (assoc card :seen true) :play-area)]
-           (system-msg state side (str "plays " title))
-           (trigger-event state side (if (= side :corp) :play-operation :play-event) c)
-           (if (has? c :subtype "Current")
-             (do (doseq [s [:corp :runner]]
-                   (when-let [current (first (get-in @state [s :current]))]
-                     (say state side {:user "__system__" :text (str (:title current) " is trashed.")})
-                     (trash state side current)))
-                 (let [moved-card (move state side (first (get-in @state [side :play-area])) :current)]
-                   (card-init state side moved-card)))
-             (do
-               (resolve-ability state side cdef card nil)
-               (move state side (first (get-in @state [side :play-area])) :discard))))))))
+                            (get-in @state [side :register :spent-click]))))
+         (when-let [cost-str (pay state side card :credit (:cost card) extra-cost
+                              (when-not no-additional-cost additional-cost))]
+           (let [c (move state side (assoc card :seen true) :play-area)]
+             (system-msg state side (if (= "" cost-str)
+                                     (str "plays " title)
+                                     (str "spends " cost-str " to play " title)))
+             (trigger-event state side (if (= side :corp) :play-operation :play-event) c)
+             (if (has? c :subtype "Current")
+               (do (doseq [s [:corp :runner]]
+                     (when-let [current (first (get-in @state [s :current]))]
+                       (say state side {:user "__system__" :text (str (:title current) " is trashed.")})
+                       (trash state side current)))
+                   (let [moved-card (move state side (first (get-in @state [side :play-area])) :current)]
+                     (card-init state side moved-card)))
+               (do
+                 (resolve-ability state side cdef card nil)
+                 (move state side (first (get-in @state [side :play-area])) :discard)))))))))
 
 (defn in-play? [state card]
   (let [dest (when (= (:side card) "Runner")

                 install-cost (if (and (= (:type c) "ICE") (not no-install-cost))
                                (count dest-zone) 0)
                 install-state (or install-state (:install-state cdef))]
             (when (and (not (and (has? c :subtype "Region")
                                  (some #(has? % :subtype "Region") dest-zone)))
                        (pay state side card extra-cost :credit install-cost))
               (when (#{"Asset" "Agenda"} (:type c))
                 (when-let [prev-card (some #(when (#{"Asset" "Agenda"} (:type %)) %) dest-zone)]
                   (system-msg state side (str "trashes " (if (:rezzed prev-card)
                                                            (:title prev-card) "a card") " in " server))
                   (trash state side prev-card {:keep-server-alive true})))
               (let [card-name (if (or (= :rezzed install-state) (= :face-up install-state) (:rezzed c))
                                 (:title card) "a card")]
                 (if (> install-cost 0)
                   (system-msg state side (str "pays " install-cost " [Credits] to install "
                                               card-name " in " server))
                   (system-msg state side (str "installs " card-name " in " server))))
               (let [moved-card (move state side c slot)]
                 (trigger-event state side :corp-install moved-card)
                 (when (= (:type c) "Agenda")
                   (update-advancement-cost state side moved-card))
                 (when (= install-state :rezzed)
                   (rez state side moved-card {:no-cost true}))
                 (when (= install-state :face-up)
                   (card-init state side (assoc (get-card state moved-card) :rezzed true) false)))))))))

(defn play [state side {:keys [card server]}]
  (case (:type card)

(defn init-trace [state side card {:keys [base] :as ability} boost]
  (trigger-event state side :pre-init-trace card)
  (let [bonus (or (get-in @state [:bonus :trace]) 0)
        base (if (fn? base) (base state side card nil) base)
        total (+ base boost bonus)]
    (system-msg state :corp (str "uses " (:title card)
                                 " to initiate a trace with strength " total
                                 " (" base
                                 (when (> bonus 0) (str " + " bonus " bonus"))
                                 " + " boost " [Credits])"))
    (swap! state update-in [:bonus] dissoc :trace)
    (show-prompt state :runner card (str "Boost link strength?") :credit #(resolve-trace state side %))
