Operations

{:req (req (pos? (count (:scored corp))))
 :delayed-completion true
 :additional-cost [:forfeit]
 :effect (req (continue-ability
                state side
                {:prompt "Choose an agenda in your score area to trigger its \"when scored\" ability"
                 :choices {:req #(and (is-type? % "Agenda")
                                      (is-scored? state :corp %))}
                 :msg (msg "trigger the \"when scored\" ability of " (:title target))
                 :delayed-completion true
                 ;dissoc :end-turn for Breaking News
                 :effect (effect (continue-ability (dissoc (card-def target) :end-turn) target nil))}
                card nil))}

(letfn [(ad [i n adcard]
          {:prompt "Select an operation to play"
           :choices {:req #(and (= (:side %) "Corp")
                                (is-type? % "Operation")
                                (= (:zone %) [:play-area]))}
           :msg (msg "play " (:title target))
           :delayed-completion true
           :effect (req (when-completed (play-instant state side target {:no-additional-cost true})
                                        (if (and (not (get-in @state [:corp :register :terminal])) (< i n))
                                          (continue-ability state side (ad (inc i) n adcard) adcard nil)
                                          (effect-completed state side eid))))})]
  {:delayed-completion true
   :effect (req (let [n (count (filter #(is-type? % "Operation")
                                       (take 3 (:deck corp))))]
                  (continue-ability state side
                                    {:msg "look at the top 3 cards of R&D"
                                     :delayed-completion true
                                     :effect (req (doseq [c (take 3 (:deck corp))]
                                                    (move state side c :play-area))
                                                  (continue-ability state side (ad 1 n card) card nil))}
                                    card nil)))})

(let [abhelp (fn ab [n total]
               {:prompt "Select an advertisement to install and rez" :show-discard true
                :delayed-completion true
                :choices {:req #(and (= (:side %) "Corp")
                                     (has-subtype? % "Advertisement")
                                     (or (in-hand? %)
                                         (= (:zone %) [:discard])))}
                :effect (req (when-completed
                               (corp-install state side target nil {:install-state :rezzed})
                               (if (< n total)
                                 (continue-ability state side (ab (inc n) total) card nil)
                                 (effect-completed state side eid))))})]
  {:prompt "How many advertisements?"
   :delayed-completion true
   :choices :credit
   :msg (msg "install and rez " target " advertisements")
   :effect (effect (continue-ability (abhelp 1 target) card nil))})

{:req (req (:scored-agenda corp-reg)) :prompt "Choose a card"
 :choices (req (cancellable (:deck corp) :sorted))
 :effect (final-effect (move target :hand) (shuffle! :deck))
 :msg "search R&D for a card and add it to HQ"}

{:delayed-completion false
 :prompt "Choose a server" :choices ["Archives" "R&D" "HQ"]
 :effect (req (let [serv target]
                (show-wait-prompt state :corp (str "Runner to decide on running " target))
                (continue-ability
                  state side
                  {:optional
                   {:prompt (msg "Make a run on " serv "?") :player :runner
                    :yes-ability {:msg (msg "let the Runner make a run on " serv)
                                  :effect (effect (clear-wait-prompt :corp)
                                                  (game.core/run eid serv nil card))}
                    :no-ability {:effect (effect (clear-wait-prompt :corp)
                                                 (as-agenda :corp (some #(when (= (:cid card) (:cid %)) %) (:discard corp)) 1))
                                 :msg "add it to their score area as an agenda worth 1 agenda point"}}}
                 card nil)))}

{:msg "draw 3 cards"
 :effect (effect (draw 3))}

{:effect (req (let [cid (:cid card)]
                (resolve-ability state side
                  {:prompt "Choose a card from Archives to add to HQ" :show-discard true
                   :choices {:req #(and (not= (:cid %) cid)
                                        (= (:side %) "Corp")
                                        (= (:zone %) [:discard]))}
                   :effect (final-effect (move target :hand)
                                         (system-msg (str "adds " (if (:seen target) (:title target) "an unseen card") " to HQ")))}
                 card nil)))}

{:delayed-completion true
 :req (req (not-empty (:discard runner)))
 :prompt "Name a card to remove all copies in the Heap from the game"
 :choices (req (cancellable (:discard runner) :sorted))
 :msg (msg "remove all copies of " (:title target) " in the Heap from the game")
 :effect (req (doseq [c (filter #(= (:title target) (:title %)) (:discard runner))]
                (move state :runner c :rfg))
              (effect-completed state side eid card))}

{:prompt "Choose an installed card in a server to trash"
 :choices {:req #(and (= (last (:zone %)) :content)
                      (is-remote? (second (:zone %))))}
 :effect (final-effect (gain :credit (* 3 (get target :advance-counter 0))) (trash target))
 :msg (msg "trash " (card-str state target) " and gain "
           (* 3 (get target :advance-counter 0)) " [Credits]")}

{:implementation "Any required program trashing is manual"
 :req (req tagged)
 :msg "force the Runner to lose 2[mu] until the end of the turn"
 :effect (req (lose state :runner :memory 2)
              (when (< (:memory runner) 0)
               (system-msg state :runner "must trash programs to free up [mu]")))
 :end-turn {:effect (req (gain state :runner :memory 2)
                         (system-msg state :runner "regains 2[mu]"))}}

{:msg "gain 3 [Credits]"
 :effect (effect (gain :credit 3))}

{:delayed-completion true
 :req (req (not-empty (all-installed state :runner)))
 :effect (req (let [t (:tag runner)]
                (continue-ability state side
                  {:prompt (msg "Choose a Runner card with an install cost of " t " or less to trash")
                   :choices {:req #(and (installed? %)
                                        (<= (:cost %) t))}
                   :msg (msg "trash " (:title target))
                   :effect (effect (trash target))}
                 card nil)))}

{:req (req tagged)
 :msg "give the Runner 2 tags"
 :delayed-completion true
 :effect (effect (tag-runner :runner eid 2))}

{:implementation "Derez is manual"
 :choices {:req #(and (ice? %)
                      (has-subtype? % "Bioroid")
                      (not (rezzed? %)))}
 :msg (msg "rez " (card-str state target {:visible true}) " at no cost")
 :effect (final-effect (rez target {:ignore-cost :all-costs})
                       (host (get-card state target) (assoc card :zone [:discard] :seen true)))}

{:msg "gain [Click][Click]"
 :effect (effect (gain :click 2))}

{:msg "gain 5 [Credits] and draw 2 cards"
 :effect (effect (gain :credit 5) (draw 2))}

{:req (req (> (:tag runner) 1))
 :delayed-completion true
 :msg "do 7 meat damage"
 :effect (effect (damage eid :meat 7 {:card card}))}

{:choices {:req #(and (is-type? % "Agenda")
                      (in-hand? %))}
 :delayed-completion true
 :effect (req (let [agenda target]
                (continue-ability
                  state side {:prompt (str "Choose a server to install " (:title agenda))
                              :choices (server-list state agenda)
                              :effect (req (corp-install state side agenda target {:install-state :face-up})
                                           ; find where the agenda ended up and host on it
                                           (let [agenda (some #(when (= (:cid %) (:cid agenda)) %)
                                                              (all-installed state :corp))]
                                             ; the operation ends up in :discard when it is played; to host it,
                                             ; we need (host) to look for it in discard.
                                             (host state side agenda (assoc card :zone [:discard]
                                                                                 :seen true :installed true))
                                             (system-msg state side (str "hosts Casting Call on " (:title agenda)))))}
                  card nil)))
 :events {:access {:req (req (= (:cid target) (:cid (:host card))))
                   :delayed-completion true
                   :effect (effect (tag-runner :runner eid 2)) :msg "give the Runner 2 tags"}}}

{:choices {:max 5
           :req #(and (= (:side %) "Corp")
                      (in-hand? %))}
 :msg (msg "reveal " (join ", " (map :title targets)) " and gain " (* 2 (count targets)) " [Credits]")
 :effect (final-effect (gain :credit (* 2 (count targets))))}

{:req (req (:successful-run runner-reg))
 :psi {:not-equal {:player :runner :prompt "Take 1 tag or 1 brain damage?"
                   :choices ["1 tag" "1 brain damage"] :msg (msg "give the Runner " target)
                   :delayed-completion true
                   :effect (req (if (= target "1 tag")
                                  (tag-runner state side eid 1)
                                  (damage state side eid :brain 1 {:card card})))}}}

{:msg "disable the Runner's identity"
 :effect (effect (disable-identity :runner))
 :leave-play (effect (enable-identity :runner))}

{:events {:agenda-scored {:msg "add it to their score area as an agenda worth 1 agenda point"
                          :effect (effect (as-agenda :corp card 1))}}}

{:req (req tagged)
 :msg (msg "force the Runner to lose all " (:credit runner) " [Credits]")
 :effect (effect (lose :runner :credit :all))}

{:msg (msg "gain " (or (:advance-counter target) 0) " [Credits]")
 :choices {:req ice?}
 :effect (final-effect (gain :credit (or (:advance-counter target) 0)))}

{:prompt  "Choose an Operation from R&D to play"
 :choices (req (cancellable
          (filter #(and (is-type? % "Operation")
                        (<= (:cost %) (:credit corp)))
                   (:deck corp))
          :sorted))
 :effect  (effect (shuffle! :deck)
                  (system-msg "shuffles their deck")
                  (play-instant target))
 :msg (msg "search R&D for " (:title target) " and play it")}

{:msg "shuffle all cards in HQ into R&D and draw 5 cards"
 :effect (effect (shuffle-into-deck :hand) (draw 5))}

{:msg "purge virus counters"
 :effect (effect (purge))}

{:prompt "Choose a faceup card"
 :choices {:req rezzed?}
 :msg (msg "place 3 advancement tokens on " (card-str state target))
 :effect (req (add-prop state :corp target :advance-counter 3 {:placed true})
              (effect-completed state side eid card)
              (let [tgtcid (:cid target)]
                (register-turn-flag! state side
                  target :can-score
                  (fn [state side card]
                    (if (and (= (:cid card) tgtcid)
                             (>= (:advance-counter card) (or (:current-cost card) (:advancementcost card))))
                      ((constantly false) (toast state :corp "Cannot score due to Dedication Ceremony." "warning"))
                      true)))))}

{:events {:pre-damage {:req (req (= target :brain)) :msg "do 1 additional brain damage"
                       :once :per-turn :effect (effect (damage-bonus :brain 1))}}}

{:msg (msg "gain " (count (filter #(not (empty? %)) (map #(:content (second %)) (get-remotes @state))))
           " [Credits]")
 :effect (effect (gain :credit (count (filter #(not (empty? %)) (map #(:content (second %)) (get-remotes @state))))))}

{:events {:runner-turn-begins
          {:trace {:base 1 :msg (msg (if tagged "do 1 meat damage" "give the Runner 1 tag"))
                   :label "Do 1 meat damage if Runner is tagged, or give the Runner 1 tag"
                   :delayed-completion true
                   :effect (req (if tagged
                                  (damage state side eid :meat 1 {:card card})
                                  (tag-runner state :runner eid 1)))}}}}

{:req (req (->> (get-in @state [:corp :hand])
                (filter #(not (= (:cid %) (:cid card))))
                (count)
                (pos?)))
 :msg (msg "trash all cards in HQ and draw 5 cards")
 :effect (effect (trash-cards (get-in @state [:corp :hand]))
                 (draw 5))}

{:msg "reduce the Runner's maximum hand size by 1"
 :effect (effect (lose :runner :hand-size-modification 1))
 :leave-play (effect (gain :runner :hand-size-modification 1))}

{:trace {:base 3
         :label "Trash a card not matching the faction of the Runner's identity"
         :delayed-completion true
         :effect (req (let [f (:faction (:identity runner))]
                        (continue-ability
                          state side
                          {:prompt "Choose an installed card not matching the faction of the Runner's identity"
                           :choices {:req #(and (installed? %) (not= f (:faction %)) (card-is? % :side :runner))}
                           :msg (msg "trash " (:title target))
                           :effect (effect (trash target))}
                         card nil)))}}

(letfn [(add-effect [state side card]
          (update! state side (assoc card :elp-activated true))
          (click-run-cost-bonus state side [:click 1]))
        (remove-effect [state side card]
          (click-run-cost-bonus state side [:click -1])
          (update! state side (dissoc card :elp-activated)))]
  {:effect (req (when (and (= :runner (:active-player @state))
                           (not (:made-click-run runner-reg)))
                  (add-effect state side card)
                  (system-msg state side (str "uses Enhanced Login Protocol to add an additional cost of [Click]"
                                              " to make the first run not through a card ability this turn"))))
   :events {:runner-turn-begins {:msg "add an additional cost of [Click] to make the first run not through a card ability this turn"
                                 :effect (effect (add-effect card))}
            :runner-turn-ends {:req (req (:elp-activated card))
                               :effect (effect (remove-effect card))}
            :run-ends {:req (req (and (:elp-activated card)
                                      (:made-click-run runner-reg)))
                       :effect (effect (remove-effect card))}}
   :leave-play (req (when (:elp-activated card)
                      (remove-effect state side card)))})

{:req (req (and tagged
                (seq (:scored runner))
                (seq (:scored corp))))
 :delayed-completion true
 :effect (req
           (continue-ability
             state side
             {:prompt "Choose a stolen agenda in the Runner's score area to swap"
              :choices {:req #(in-runner-scored? state side %)}
              :delayed-completion true
              :effect (req
                        (let [stolen target]
                          (continue-ability
                            state side
                            {:prompt (msg "Choose a scored agenda to swap for " (:title stolen))
                             :choices {:req #(in-corp-scored? state side %)}
                             :effect (req (let [scored target]
                                            (swap-agendas state side scored stolen)
                                            (system-msg state side (str "uses Exchange of Information to swap "
                                                                        (:title scored) " for " (:title stolen)))
                                            (effect-completed state side eid card)))}
                            card nil)))}
             card nil))}

{:prompt "Choose an Agenda"
 :choices (req (cancellable (filter #(is-type? % "Agenda") (:deck corp)) :sorted))
 :effect (effect (system-msg (str "adds " (:title target) " to HQ and shuffle R&D"))
                 (shuffle! :deck)
                 (move target :hand) )}

{:delayed-completion true
 :req (req (>= (:credit runner) 6))
 :effect (req (let [rcount (count (filter #(is-type? % "Resource") (all-installed state :runner)))]
                (if (pos? rcount)
                  (do (show-wait-prompt state :corp "Runner to trash a resource to prevent Financial Collapse")
                      (continue-ability
                        state side
                        {:prompt (msg "Trash a resource to prevent Financial Collapse?")
                         :choices ["Yes" "No"] :player :runner
                         :delayed-completion true
                         :effect (final-effect (continue-ability
                                                 (if (= target "Yes")
                                                   {:prompt "Choose a resource to trash" :player :runner
                                                    :choices {:req #(and (is-type? % "Resource") (installed? %))}
                                                    :effect (req (trash state side target {:unpreventable true})
                                                                 (system-msg state :runner
                                                                             (str "trashes " (:title target)
                                                                                  " to prevent Financial Collapse"))
                                                                 (clear-wait-prompt state :corp))}
                                                   {:effect (effect (lose :runner :credit (* rcount 2))
                                                                    (clear-wait-prompt :corp))
                                                    :msg (msg "make the Runner lose " (* rcount 2) " [Credits]")})
                                                card nil))} card nil))
                  (continue-ability
                    state side
                    {:effect (effect (lose :runner :credit (* rcount 2)))
                     :msg (msg "make the Runner lose " (* rcount 2) " [Credits]")} card nil))))}

{:trace {:base 7
         :prompt "Choose 1 card to trash"
         :not-distinct true
         :choices {:req #(and (installed? %)
                              (or (has-subtype? % "Virtual")
                                  (has-subtype? % "Link")))}
         :msg "trash 1 virtual resource or link"
         :effect (effect (trash target) (system-msg (str "trashes " (:title target))))}}

{:req (req tagged)
 :msg (msg "trash " (join ", " (map :title targets)))
 :choices {:max 2
           :req #(and (installed? %)
                      (is-type? % "Resource"))}
 :effect (final-effect (trash-cards :runner targets))}

(let [fhelper (fn fhp [n] {:prompt "Select a card in Archives to install with Friends in High Places"
                           :priority -1
                           :delayed-completion true
                           :show-discard true
                           :choices {:req #(and (= (:side %) "Corp")
                                                (not (is-type? % "Operation"))
                                                (in-discard? %))}
                           :effect (req (when-completed
                                          (corp-install state side target nil nil)
                                          (do (system-msg state side (str "uses Friends in High Places to "
                                                                          (corp-install-msg target)))
                                              (if (< n 2)
                                                (continue-ability state side (fhp (inc n)) card nil)
                                                (effect-completed state side eid card)))))})]
  {:delayed-completion true
   :effect (effect (continue-ability (fhelper 1) card nil))})

{:msg "gain 3 [Credits] and draw 1 card"
 :effect (effect (gain :credit 3) (draw))}

{:req (req (:made-run runner-reg))
 :trace {:base 4
         :delayed-completion true
         :msg "give the Runner 4 tags"
         :label "Give the Runner 4 tags"
         :effect (effect (tag-runner :runner eid 4))}}

(letfn [(hr-final [chosen original]
          {:prompt (str "The top cards of R&D will be " (clojure.string/join  ", " (map :title chosen)) ".")
           :choices ["Done" "Start over"]
           :delayed-completion true
           :effect (req (if (= target "Done")
                          (do (doseq [c (reverse chosen)] (move state :corp c :deck {:front true}))
                              (clear-wait-prompt state :runner)
                              (effect-completed state side eid card))
                          (continue-ability state side (hr-choice original '() 3 original)
                                            card nil)))})
        (hr-choice [remaining chosen n original]
          {:prompt "Choose a card to move next onto R&D"
           :choices remaining
           :delayed-completion true
           :effect (req (let [chosen (cons target chosen)]
                          (if (< (count chosen) n)
                            (continue-ability state side (hr-choice (remove-once #(not= target %) remaining)
                                                                     chosen n original) card nil)
                            (continue-ability state side (hr-final chosen original) card nil))))})]
  {:delayed-completion true
   :msg "trash the top card of R&D, draw 3 cards, and add 3 cards in HQ to the top of R&D"
   :effect (req (mill state :corp)
                (draw state side 3)
                (show-wait-prompt state :runner "Corp to add 3 cards in HQ to the top of R&D")
                (let [from (get-in @state [:corp :hand])]
                  (continue-ability state :corp (hr-choice from '() 3 from) card nil)))})

{:trace {:base 5
         :choices {:req #(and (installed? %)
                              (card-is? % :side :runner)
                              (not (has-subtype? % "Virtual")))}
         :msg "add an installed non-virtual card to the Runner's grip"
         :effect (effect (move :runner target :hand true))}}

{:msg "gain 9 [Credits]" :effect (effect (gain :credit 9))}

{:req (req (:installed-resource runner-reg))
 :trace {:base 2
         :choices {:req #(and (installed? %)
                              (is-type? % "Resource"))}
         :msg "add a Resource to the top of the Stack"
         :effect (effect (move :runner target :deck {:front true})
                         (system-msg (str "adds " (:title target) " to the top of the Stack")))
         :unsuccessful {:msg "take 1 bad publicity"
                        :effect (effect (gain :corp :bad-publicity 1))}}}

{:req (req (:trashed-card runner-reg))
 :trace {:base 2
         :label "Trash 2 installed non-program cards"
         :choices {:max 2
                   :req #(and (installed? %)
                              (= (:side %) "Runner")
                              (not (is-type? % "Program")))}
         :msg (msg "trash " (join ", " (map :title targets)))
         :effect (req (doseq [c targets]
                        (trash state side c)))
         :unsuccessful {:msg "take 1 bad publicity"
                        :effect (effect (gain :corp :bad-publicity 1))}}}

{:delayed-completion true
 :effect (effect (draw 3)
                 (continue-ability
                   {:prompt "Choose a card in HQ to put on top of R&D"
                    :choices {:req #(and (in-hand? %)
                                         (= (:side %) "Corp"))}
                    :msg "draw 3 cards and add 1 card from HQ to the top of R&D"
                    :effect (effect (move target :deck {:front true}))}
                   card nil))}

{:events {:runner-install {:player :runner
                           :choices {:req #(and (in-hand? %)
                                                (= (:side %) "Runner"))}
                           :prompt "Choose a card from your Grip to trash for Housekeeping" :once :per-turn
                           :msg (msg "force the Runner to trash " (:title target) " from their Grip")
                           :effect (effect (trash target {:unpreventable true}))}}}

{:prompt "Choose a card to install from Archives or HQ"
 :show-discard true
 :not-distinct true
 :choices {:req #(and (not (is-type? % "Operation"))
                      (= (:side %) "Corp")
                      (#{[:hand] [:discard]} (:zone %)))}
 :effect (final-effect (corp-install target nil {:no-install-cost true}))
 :msg (msg (corp-install-msg target))}

(letfn [(iop [x]
          {:delayed-completion true
           :req (req (pos? (count (filter #(or (is-type? % "Resource")
                                               (is-type? % "Event")) (:hand runner)))))
           :prompt "Choose a resource or event to trash"
           :msg (msg "trash " (:title target))
           :choices (req (cancellable
                           (filter #(or (is-type? % "Resource")
                                        (is-type? % "Event")) (:hand runner)) :sorted))
           :effect (req (trash state side target)
                        (if (pos? x)
                          (continue-ability state side (iop (dec x)) card nil)
                          (effect-completed state side eid card)))})]
  {:trace {:base 2 :msg "reveal the Runner's Grip and trash up to X resources or events"
           :effect (req (let [x (- target (second targets))]
                          (system-msg state :corp
                                      (str "reveals the Runner's Grip ( "
                                           (join ", " (map :title (:hand runner)))
                                           " ) and can trash up to " x " resources or events"))
                          (continue-ability state side (iop (dec x)) card nil)))
           :unsuccessful {:msg "take 1 bad publicity" :effect (effect (gain :corp :bad-publicity 1))}}})

{:effect (effect (update-all-ice))
 :events {:pre-ice-strength {:effect (effect (ice-strength-bonus 1 target))}}
 :leave-play (effect (update-all-ice))}

{:delayed-completion true
 :msg "gain 4 [Credits]"
 :effect (effect (gain :credit 4)
                 (continue-ability {:player :corp
                                    :prompt "Choose a card to install"
                                    :delayed-completion true
                                    :choices {:req #(and (= (:side %) "Corp")
                                                         (not (is-type? % "Operation"))
                                                         (in-hand? %))}
                                    :effect (effect (corp-install eid target nil nil))
                                    :msg (msg (corp-install-msg target))}
                                   card nil))}

{:delayed-completion true
 :effect (req (let [n (count (filter #(and (rezzed? %)
                                           (not (is-type? % "Agenda"))) (all-installed state :corp)))]
                (continue-ability state side
                  {:prompt "Choose any number of rezzed cards to trash"
                   :choices {:max n :req #(and (rezzed? %) (not (is-type? % "Agenda")))}
                   :msg (msg "trash " (join ", " (map :title targets)) " and gain " (* (count targets) 3) " [Credits]")
                   :effect (req (doseq [c targets]
                                  (trash state side c))
                                (gain state side :credit (* (count targets) 3)))}
                 card nil)))}

{:prompt "Choose a card"
 :choices (req (cancellable (:deck corp) :sorted))
 :delayed-completion true
 :effect (req (let [c (:title target)
                    cs (filter #(= (:title %) c) (:deck corp))]
                (continue-ability
                 state side
                 {:prompt "How many copies?"
                  :choices {:number (req (count cs))}
                  :msg (msg "add " target " cop" (if (= target 1) "y" "ies") " of " c " to HQ")
                  :effect (req (shuffle! state :corp :deck)
                               (doseq [c (take target cs)]
                                 (move state side c :hand)))}
                 card nil)))}

{:events {:successful-run {:interactive (req true)
                           :req (req (first-event? state side :successful-run))
                           :trace {:base 2 :msg "give the Runner 1 tag"
                                   :delayed-completion true
                                   :effect (effect (tag-runner :runner eid 1))}}}}

{:msg "gain 8 [Credits]. The Runner gains 3 [Credits]"
 :effect (effect (gain :credit 8) (gain :runner :credit 3))}

{:req (req (:stole-agenda runner-reg))
 :trace {:base 6
         :msg "give the Runner X tags"
         :label "Give the Runner X tags"
         :delayed-completion true
         :effect (effect (system-msg (str "gives the Runner " (- target (second targets)) " tags"))
                         (tag-runner :runner eid (- target (second targets))))}}

{:prompt "Choose a card to install from HQ"
 :choices {:req #(and (#{"Asset" "Agenda" "Upgrade"} (:type %))
                      (= (:side %) "Corp")
                      (in-hand? %))}
 :effect (req (corp-install state side (assoc target :advance-counter 3) "New remote")
              (effect-completed state side eid card)
              (let [tgtcid (:cid target)]
                (register-turn-flag! state side
                  card :can-rez
                  (fn [state side card]
                    (if (= (:cid card) tgtcid)
                      ((constantly false) (toast state :corp "Cannot rez due to Mushin No Shin." "warning"))
                      true)))
                (register-turn-flag! state side
                  card :can-score
                  (fn [state side card]
                    (if (and (= (:cid card) tgtcid)
                             (>= (:advance-counter card) (or (:current-cost card) (:advancementcost card))))
                      ((constantly false) (toast state :corp "Cannot score due to Mushin No Shin." "warning"))
                      true)))))}

{:req (req (seq (filter (every-pred rezzed? ice?) (all-installed state :corp))))
 :prompt "Choose a rezzed piece of ICE to trash"
 :choices {:req (every-pred rezzed? ice?)}
 :msg (msg "to trash " (:title target))
 :effect (req (let [i (ice-index state target)
                    [reveal r] (split-with (complement ice?) (get-in @state [:corp :deck]))
                    titles (->> (conj (vec reveal) (first r)) (filter identity) (map :title))]
                (trash state side target {:cause :ability-cost :keep-server-alive true})
                (when (seq titles)
                  (system-msg state side (str "reveals " (clojure.string/join ", " titles) " from R&D")))
                (if-let [ice (first r)]
                  (let [newice (assoc ice :zone (:zone target) :rezzed true)
                        ices (get-in @state (cons :corp (:zone target)))
                        newices (apply conj (subvec ices 0 i) newice (subvec ices i))]
                    (swap! state assoc-in (cons :corp (:zone target)) newices)
                    (swap! state update-in [:corp :deck] (fn [coll] (remove-once #(not= (:cid %) (:cid newice)) coll)))
                    (trigger-event state side :corp-install newice)
                    (card-init state side newice false)
                    (system-msg state side (str "uses Mutate to install and rez " (:title newice) " from R&D at no cost"))
                    (trigger-event state side :rez newice))
                  (system-msg state side (str "does not find any ICE to install from R&D")))
                (shuffle! state :corp :deck)
                (effect-completed state side eid card)))}

{:req (req (:made-run runner-reg))
 :msg "do 1 net damage"
 :effect (effect (damage eid :net 1 {:card card}))}

{:req (req (and (pos? (:tag runner))
                (< (:credit runner) 6)))
 :delayed-completion true
 :effect (effect (continue-ability
                   {:prompt "Choose an installed card to trash"
                    :choices {:req installed?}
                    :msg (msg "remove 1 Runner tag and trash " (:title target))
                    :effect (effect (lose :runner :tag 1)
                                    (trash target))}
                  card nil))}

{:implementation "Trashing ICE is manual"
 :choices {:req #(and (ice? %) (not (rezzed? %)) (= (last (:zone %)) :ices))}
 :msg (msg "rez " (:title target) " at no cost")
 :effect (final-effect (rez target {:ignore-cost :all-costs})
                       (host (get-card state target) (assoc card :zone [:discard] :seen true)))}

{:choices {:req #(and (ice? %) (rezzed? %))}
 :msg (msg "give +2 strength to " (card-str state target))
 :effect (final-effect (host target (assoc card :zone [:discard] :seen true))
                       (update-ice-strength (get-card state target)))
 :events {:pre-ice-strength {:req (req (= (:cid target) (:cid (:host card))))
                             :effect (effect (ice-strength-bonus 2 target))}}}

{:events {:successful-run {:msg "gain 1 [Credits]" :effect (effect (gain :corp :credit 1))}}}

{:msg (msg "gain " (reduce (fn [c server]
                             (+ c (count (filter (fn [ice] (:rezzed ice)) (:ices server)))))
                           0 (flatten (seq (:servers corp))))
           " [Credits]")
 :effect (effect (gain :credit
                       (reduce (fn [c server]
                                 (+ c (count (filter (fn [ice] (:rezzed ice)) (:ices server)))))
                               0 (flatten (seq (:servers corp))))))}

{:trace {:base 2
         :msg "trash 1 piece of hardware"
         :delayed-completion true
         :effect (req (let [max-cost (- target (second targets))]
                        (continue-ability state side
                                          {:choices {:req #(and (is-type? % "Hardware")
                                                                (<= (:cost %) max-cost))}
                                           :msg (msg "trash " (:title target))
                                           :effect (effect (trash target))}
                                          card nil))
                      (system-msg state :corp (str "trashes 1 piece of hardware with install cost less than or equal to " (- target (second targets)))))}}

{:req (req (:made-run runner-reg))
 :prompt "Trash how many cards from the top R&D?"
 :choices {:number (req (count (:deck corp)))}
 :msg (msg "trash " target " cards from the top of R&D")
 :delayed-completion true
 :effect (req (mill state :corp target)
              (let [n target]
                (continue-ability state :runner
                                  {:prompt "Choose a Program or piece of Hardware to trash"
                                   :choices {:req #(and (#{"Hardware" "Program"} (:type %))
                                                        (<= (:cost %) n))}
                                   :msg (msg "trash " (:title target))
                                   :effect (effect (trash target))}
                                 card nil)))}

{:delayed-completion true
 :msg "rearrange the top 5 cards of R&D"
 :effect (req (show-wait-prompt state :runner "Corp to rearrange the top cards of R&D")
              (let [from (take 5 (:deck corp))]
                (if (pos? (count from))
                  (continue-ability state side (reorder-choice :corp :runner from '()
                                                               (count from) from) card nil)
                  (do (clear-wait-prompt state :runner)
                      (effect-completed state side eid card)))))}

{:events {:pre-steal-cost {:effect (effect (steal-cost-bonus [:credit 2]))}}}

{:msg "remove Preemptive Action from the game"
 :effect (effect (rfg-and-shuffle-rd-effect (first (:play-area corp)) 3))}