Events

{:effect (effect (run :hq {:req (req (= target :hq))
                           :replace-access
                           {:msg (msg "force the Corp to lose " (min 5 (:credit corp))
                                      " [Credits], gain " (* 2 (min 5 (:credit corp)))
                                      " [Credits] and take 2 tags")
                            :delayed-completion true
                            :effect (req (when-completed (tag-runner state :runner 2)
                                                         (do (gain state :runner :credit (* 2 (min 5 (:credit corp))))
                                                             (lose state :corp :credit (min 5 (:credit corp)))
                                                             (effect-completed state side eid))))}} card))}

{:msg "gain [Click][Click][Click] and suffer 1 brain damage"
 :effect (effect (gain :click 3) (damage eid :brain 1 {:unpreventable true :card card}))}

{:events {:agenda-stolen
          {:trace {:base 0
                   :msg (msg (str "Runner gains " (+ (:agenda-point runner) (:agenda-point corp)) " [Credits]"))
                   :unsuccessful {:effect (effect (gain :runner :credit
                                                        (+ (:agenda-point runner) (:agenda-point corp))))
                                  :msg (msg (str "gain " (+ (:agenda-point runner) (:agenda-point corp)) " [Credits]"))}}}}}

{:req (req (and (some #{:hq} (:successful-run runner-reg))
                (some #{:rd} (:successful-run runner-reg))
                (some #{:archives} (:successful-run runner-reg))))
                        ;; trash cards from right to left
                        ;; otherwise, auto-killing servers would move the cards to the next server
                        ;; so they could no longer be trashed in the same loop
 :msg "trash all installed Corp cards and turn all installed Runner cards facedown"
 :effect (req (let [allcorp (->> (all-installed state :corp)
                                 (sort-by #(vec (:zone %)))
                                 (reverse))]
                (doseq [c allcorp]
                  (trash state side c)))
              ;; do hosted cards first so they don't get trashed twice
              (doseq [c (all-installed state :runner)]
                (when (or (= ["onhost"] (get c :zone)) (= '(:onhost) (get c :zone)))
                  (move state side c [:rig :facedown])
                  (if (:memoryunits c)
                    (gain state :runner :memory (:memoryunits c)))))
              (doseq [c (all-installed state :runner)]
                (when (not (or (= ["onhost"] (get c :zone)) (= '(:onhost) (get c :zone))))
                  (move state side c [:rig :facedown])
                  (if (:memoryunits c)
                    (gain state :runner :memory (:memoryunits c))))))}

{:req (req has-bad-pub) :prompt "Choose a server" :choices (req runnable-servers)
 :msg "prevent ICE from being rezzed during this run"
 :effect (effect (register-run-flag!
                   card
                   :can-rez
                   (fn [state side card]
                     (if (ice? card)
                       ((constantly false) (system-msg state side (str "is prevented from rezzing ICE on this run by Blackmail")))
                       true)))
                 (run target nil card))}

{:prompt "How many [Credits]?" :choices :credit
 :msg (msg "increase the rez cost of the 1st unrezzed ICE approached by " target " [Credits]")
 :effect (effect (resolve-ability {:prompt "Choose a server" :choices (req runnable-servers)
                                   :effect (effect (run target nil card))} card nil))}

{:msg (msg "gain " (count (filter #(has-subtype? % "Connection") (all-installed state :runner)))
           " [Credits]")
 :effect (effect (gain :credit (count (filter #(has-subtype? % "Connection")
                                              (all-installed state :runner)))))}

{:prompt "Choose a resource to install from your Grip"
 :choices {:req #(and (is-type? % "Resource")
                      (in-hand? %))}
 :effect (effect (install-cost-bonus [:credit -3]) (runner-install target))}

(letfn [(cbi-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 (cbi-choice original '() (count original) original)
                                            card nil)))})
        (cbi-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 (cbi-choice (remove-once #(not= target %) remaining)
                                                                     chosen n original) card nil)
                            (continue-ability state side (cbi-final chosen original) card nil))))})]
  {:delayed-completion true
   :effect (effect (run :hq {:replace-access
                             {:msg "force the Corp to add all cards in HQ to the top of R&D"
                              :delayed-completion true
                              :effect (req (show-wait-prompt state :runner "Corp to add all cards in HQ to the top of R&D")
                                           (let [from (:hand corp)]
                                             (if (pos? (count from))
                                               (continue-ability state :corp (cbi-choice from '() (count from) from) card nil)
                                               (do (clear-wait-prompt state :runner)
                                                   (effect-completed state side eid card)))))}} card))})

{:effect (effect (run :rd
                      {:replace-access
                       {:delayed-completion true
                        :prompt "Choose a program to install"
                        :msg (msg "install " (:title target) " and take 1 tag")
                        :choices (req (filter #(is-type? % "Program") (:deck runner)))
                        :effect (effect (trigger-event :searched-stack nil)
                                        (shuffle! :deck)
                                        (install-cost-bonus [:credit (* -3 (count (get-in corp [:servers :rd :ices])))])
                                        (runner-install target)
                                        (tag-runner eid 1) )}} card))}

(let [end-effect {:prompt "Choose a program that was used during the run to trash "
                  :choices {:req #(card-is? % :type "Program")}
                  :msg (msg "trash" (:title target))
                  :effect (effect (trash target {:unpreventable true}))}]
  {:delayed-completion true
   :prompt "Choose a server"
   :recurring 4
   :choices (req runnable-servers)
   :effect (req (let [c (move state side (assoc card :zone '(:discard)) :play-area {:force true})]
                  (card-init state side c false)
                  (game.core/run state side (make-eid state) target
                                 {:end-run {:delayed-completion true
                                            :effect (effect (trash c)
                                                            (continue-ability end-effect card nil))}}
                                 c)))})

{:msg "give the Corp 1 additional bad publicity"
 :effect (req (swap! state update-in [:corp :has-bad-pub] inc))
 :leave-play (req (swap! state update-in [:corp :has-bad-pub] dec))}

{:prompt "Choose a server" :choices (req runnable-servers)
 :effect (effect (run target nil card)
                 (register-events (:events (card-def card))
                                  (assoc card :zone '(:discard))))
 :events {:pre-access-card
          {:once :per-run
           :delayed-completion true
           :req (req (not= (:type target) "Agenda"))
           :effect (req (let [c target
                              cost (:cost c)
                              title (:title c)]
                          (if (can-pay? state :corp nil :credit cost)
                            (do (show-wait-prompt state :runner "Corp to decide whether or not to prevent the trash")
                                (continue-ability state :corp
                                  {:optional
                                   {:delayed-completion true
                                    :prompt (msg "Spend " cost " [Credits] to prevent the trash of " title "?")
                                    :player :corp
                                    :yes-ability {:effect (req (lose state :corp :credit cost)
                                                               (system-msg state :corp (str "spends " cost " [Credits] to prevent "
                                                                                            title " from being trashed at no cost"))
                                                               (clear-wait-prompt state :runner))}
                                    :no-ability {:msg (msg "trash " title " at no cost")
                                                 :effect (effect (clear-wait-prompt :runner)
                                                                 (resolve-trash-no-cost c))}}}
                                 card nil))
                            (do (resolve-trash-no-cost state side c)
                                (system-msg state side (str "uses Credit Crash to trash " title " at no cost"))
                                (effect-completed state side eid)))))}
          :run-ends {:effect (effect (unregister-events card))}}}

{:prompt "Choose a server" :choices (req runnable-servers)
 :delayed-completion true
 :effect (req (let [serv target]
                (continue-ability
                  state :corp
                  {:optional
                   {:prompt (msg "Rez a piece of ICE protecting " serv "?")
                    :yes-ability {:prompt (msg "Choose a piece of " serv " ICE to rez") :player :corp
                                  :choices {:req #(and (not (:rezzed %))
                                                       (= (last (:zone %)) :ices))}
                                  :effect (req (rez state :corp target nil))}
                    :no-ability {:effect (effect (game.core/run eid serv nil card))
                                 :msg (msg "make a run on " serv " during which no ICE can be rezzed")}}}
                 card nil)))}

{:delayed-completion true
 :effect (req (register-events state side (:events (card-def card))
                               (assoc card :zone '(:discard)))
              (when-completed (game.core/run state side :rd nil card)
                              (let [card (get-card state (assoc card :zone '(:discard)))]
                                (unregister-events state side card)
                                (if (:run-again card)
                                  (game.core/run state side eid :rd nil card)
                                  (effect-completed state side eid))
                                (update! state side (dissoc card :run-again)))))
 :events {:successful-run-ends {:optional {:req (req (= [:rd] (:server target)))
                                           :prompt "Make another run on R&D?"
                                           :yes-ability {:effect (effect (update! (assoc card :run-again true)))}}}}}

{:additional-cost [:click 3]
 :msg "gain 10 [Credits]" :effect (effect (gain :credit 10))}

{:prompt "Choose a card to add to Grip" :choices (req (cancellable (:discard runner) :sorted))
 :msg (msg "add " (:title target) " to their Grip")
 :effect (req (move state side target :hand)
              (when (has-subtype? target "Virus")
                (resolve-ability state side
                                 {:prompt "Choose a virus to add to Grip"
                                  :msg (msg "add " (:title target) " to their Grip")
                                  :choices (req (cancellable
                                                  (filter #(has-subtype? % "Virus") (:discard runner)) :sorted))
                                  :effect (effect (move target :hand))} card nil)))}

{:prompt "Choose a server" :choices ["HQ" "R&D"]
 :abilities [{:msg (msg "trash " (:title (:card (first (get-in @state [side :prompt])))) " at no cost")
              :effect (effect (trash-no-cost))}]
 :effect (effect (run target nil card)
                 (prompt! card (str "Click Demolition Run in the Temporary Zone to trash a card being accessed at no cost") ["OK"] {})
                 (resolve-ability
                   {:effect (req (let [c (move state side (last (:discard runner)) :play-area)]
                                   (card-init state side c false)
                                   (register-events state side
                                                    {:run-ends {:effect (effect (trash c))}} c)))}
                  card nil))
 :events {:run-ends nil}}

(let [all [{:effect (effect (gain :credit 3))
            :msg "gain 3 [Credits]"}
           {:effect (effect (draw 2))
            :msg "draw 2 cards"}
           {:effect (effect (lose :tag 1))
            :msg "remove 1 tag"}
           {:prompt "Select 1 piece of ice to expose"
            :msg "expose 1 ice and make a run"
            :choices {:req #(and (installed? %) (ice? %))}
            :delayed-completion true
            :effect (req (when-completed (expose state side target)
                                         (continue-ability
                                           state side
                                           {:prompt "Choose a server"
                                            :choices (req runnable-servers)
                                            :delayed-completion true
                                            :effect (effect (game.core/run eid target))}
                                           card nil)))}]
      choice (fn choice [abis]
               {:prompt "Choose an ability to resolve"
                :choices (map #(capitalize (:msg %)) abis)
                :delayed-completion true
                :effect (req (let [chosen (some #(when (= target (capitalize (:msg %))) %) abis)]
                               (when-completed
                                 (resolve-ability state side chosen card nil)
                                 (if (= (count abis) 4)
                                   (continue-ability state side (choice (remove-once #(not= % chosen) abis)) card nil)
                                   (effect-completed state side eid)))))})]
  {:delayed-completion true
   :effect (effect (continue-ability (choice all) card nil))})

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

{:prompt "Choose a server" :choices (req runnable-servers)
 :effect (effect (run target {:end-run {:req (req (:successful run)) :msg " gain 5 [Credits]"
                                        :effect (effect (gain :runner :credit 5))}} card))}

{:choices {:req #(let [topmost (get-nested-host %)]
                  (and (is-remote? (second (:zone topmost)))
                       (= (last (:zone topmost)) :content)
                       (not (:rezzed %))))}
 :delayed-completion true
 :effect (req (when-completed (expose state side target) ;; would be nice if this could return a value on completion
                              (if async-result ;; expose was successful
                                (if (#{"Asset" "Upgrade"} (:type target))
                                  (do (system-msg state :runner (str "uses Drive By to trash " (:title target)))
                                      (trash state side (assoc target :seen true))
                                      (effect-completed state side eid))
                                  (effect-completed state side eid))
                                (effect-completed state side eid))))}

{:prompt "Choose a server"
 :choices (req runnable-servers)
 :msg (msg "make a run on " target " and gain [Click]")
 :effect (effect (gain :click 1) (run target nil card))}

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

{:req (req (some #{:hq} (:successful-run runner-reg)))
 :msg (msg "derez " (:title target))
 :choices {:req #(and (ice? %)
                      (rezzed? %))}
 :effect (effect (derez target))}

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

{:req (req (and (some #{:hq} (:successful-run runner-reg))
                (some #{:rd} (:successful-run runner-reg))
                (some #{:archives} (:successful-run runner-reg))))
 :effect (req (swap! state assoc-in [:runner :extra-turn] true)
              (move state side (first (:play-area runner)) :rfg))
 :msg "take an additional turn after this one"}

{:req (req (:successful-run runner-reg))
 :effect (req (let [runtgt (first (flatten (turn-events state side :run)))
                    serv (zone->name runtgt)]
                (resolve-ability state side
                  {:prompt (msg "Choose an unrezzed piece of ICE protecting " serv " that you passed on your last run")
                   :choices {:req #(and (ice? %)
                                        (not (rezzed? %))
                                        (= runtgt (second (:zone %))))}
                   :msg (msg "trash " (card-str state target))
                   :effect (effect (trash target))}
                 card nil)))}

(letfn [(es [] {:prompt "Select two pieces of ICE to swap positions"
                :choices {:req #(and (installed? %) (ice? %)) :max 2}
                :effect (req (if (= (count targets) 2)
                               (do (swap-ice state side (first targets) (second targets))
                                   (resolve-ability state side (es) card nil))
                               (system-msg state side "has finished rearranging ICE")))})]
  {:effect (effect (run :hq {:replace-access
                             {:msg "rearrange installed ICE"
                              :effect (effect (resolve-ability (es) card nil))}} card))})

{:effect (req (let [topcard (first (:deck runner))
                    caninst (or (is-type? topcard "Hardware")
                                (is-type? topcard "Program")
                                (is-type? topcard "Resource"))]
                (if caninst
                  (resolve-ability
                    state side
                    {:optional {:prompt (msg "Install " (:title topcard) "?")
                                :yes-ability {:effect (effect (install-cost-bonus [:credit -10])
                                                              (runner-install topcard))}
                                :no-ability {:effect (effect (trash topcard {:unpreventable true})
                                                             (system-msg (str "reveals and trashes "
                                                                              (:title topcard))))}}} card nil)
                  (do (trash state side topcard {:unpreventable true})
                      (system-msg state side (str "reveals and trashes " (:title topcard)))))))}

{:msg (msg "draw 1 card and gain "
           (count (filter #(= (:title %) "Exclusive Party") (:discard runner)))
           " [Credits]")
 :effect (effect (draw) (gain :credit (count (filter #(= (:title %) "Exclusive Party") (:discard runner)))))}

{:msg (msg "reveal cards in HQ: " (join ", " (map :title (:hand corp))))}

{:prompt "Choose a server" :choices (req runnable-servers)
 :effect (effect (run target
                    {:replace-access
                     {:prompt "Advancements to remove from a card in or protecting this server?"
                      :choices ["0", "1", "2", "3"]
                      :effect (req (let [c (Integer/parseInt target)]
                                     (resolve-ability
                                       state side
                                       {:choices {:req #(and (contains? % :advance-counter)
                                                             (= (:server run) (vec (rest (butlast (:zone %))))))}
                                       :msg (msg "remove " c " advancements from "
                                             (card-str state target))
                                       :effect (req (add-prop state :corp target :advance-counter (- c))
                                                    (swap! state update-in [:runner :prompt] rest)
                                                    (handle-end-run state side))}
                                      card nil)))}} card))}

{:prompt "Choose a card to add to your Grip" :choices (req (take 4 (:deck runner)))
 :msg "look at the top 4 cards of their Stack and add 1 of them to their Grip"
 :effect (effect (move target :hand) (shuffle! :deck))}

{:effect (effect (run :hq {:req (req (= target :hq))
                           :replace-access
                           {:delayed-completion true
                            :mandatory true
                            :msg "force the Corp to trash the top card of R&D"
                            :effect (req (mill state :corp)
                                         (let [n (count (filter #(= (:title card) (:title %)) (:hand runner)))]
                                           (if (> n 0)
                                             (continue-ability state side
                                               {:prompt "Reveal how many copies of Fear the Masses?"
                                                :choices {:number (req n)}
                                                :effect (req (when (> target 0)
                                                               (mill state :corp target)
                                                               (system-msg state side
                                                                           (str "reveals " target " copies of Fear the Masses,"
                                                                                " forcing the Corp to trash " target " cards"
                                                                                " from the top of R&D"))))}
                                              card nil)
                                             (effect-completed state side eid card))))}} card))}

{:implementation "Bypass is manual"
 :effect (effect (run :hq nil card) (register-events (:events (card-def card))
                                                     (assoc card :zone '(:discard))))
 :events {:successful-run {:msg "access 0 cards"
                           :effect (effect (max-access 0))}
          :run-ends {:effect (effect (unregister-events card))}}}

{:msg "make each player draw 3 cards"
 :effect (effect (draw 3) (draw :corp 3))}

{:choices {:req #(and (ice? %)
                      (not (rezzed? %)))}
 :effect (req (let [ice target
                    serv (zone->name (second (:zone ice)))
                    icepos (ice-index state ice)]
                (resolve-ability
                  state :corp
                  {:prompt (msg "Rez " (:title ice) " at position " icepos
                                " of " serv " or trash it?") :choices ["Rez" "Trash"]
                   :effect (effect (resolve-ability
                                     (if (and (= target "Rez") (<= (rez-cost state :corp ice) (:credit corp)))
                                       {:msg (msg "force the rez of " (:title ice))
                                        :effect (effect (rez :corp ice))}
                                       {:msg (msg "trash the ICE at position " icepos " of " serv)
                                        :effect (effect (trash :corp ice))})
                                     card nil))}
                  card nil)))}

{:implementation "Ice trash is manual"
 :prompt "Choose a server"
 :choices (req runnable-servers)
 :effect (effect (run target nil card))}

{:prompt "Choose an agenda to forfeit"
 :choices (req (:scored runner))
 :effect (effect (forfeit target) (gain :corp :bad-publicity 1))
 :msg (msg "forfeit " (:title target) " and give the Corp 1 bad publicity")}

{:delayed-completion true
 :events {:runner-shuffle-deck nil}
 :effect
 (req (let [topten (take 10 (:deck runner))]
        (prompt! state :runner card (str "The top 10 cards of the Stack are "
                                         (join ", " (map :title topten))) ["OK"] {})
        (continue-ability
          state side
          {:prompt "Install a program?"
           :choices (conj (vec (sort-by :title (filter #(and (is-type? % "Program")
                                                             (can-pay? state side nil
                                                                       (modified-install-cost state side % [:credit -5])))
                                                       topten))) "No install")
           :delayed-completion true
           :effect (req (if (not= target "No install")
                          (do (register-events state side
                                               {:runner-shuffle-deck
                                                {:effect (effect (update! (assoc card :shuffle-occurred true)))}}
                                               (assoc card :zone '(:discard)))
                              (install-cost-bonus state side [:credit -5])
                              (let [to-trash (remove #(= (:cid %) (:cid target)) topten)]
                                (when-completed (runner-install state side target nil)
                                                (let [card (get-card state (assoc card :zone '(:discard)))]
                                                  (if (not (:shuffle-occurred card))
                                                    (do (system-msg state side (str "trashes " (join ", " (map :title to-trash))))
                                                        (doseq [c to-trash] (trash state side c {:unpreventable true}))
                                                        (effect-completed state side eid))
                                                    (do (system-msg state side "does not have to trash cards because the stack was shuffled")
                                                        (effect-completed state side eid)))))))
                          (do (doseq [c topten] (trash state side c {:unpreventable true}))
                              (system-msg state side (str "trashes " (join ", " (map :title topten)))))))} card nil)))}

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

{:choices {:max 5
           :req #(and (is-type? % "Program")
                      (in-hand? %))}
 :msg (msg "trash " (join ", " (map :title targets)) " and gain "
           (* 2 (count targets)) " [Credits]")
 :effect (req (doseq [c targets]
                (trash state side c {:unpreventable true}))
              (gain state side :credit (* 2 (count targets))))}

{:msg (msg "draw " (- (hand-size state :runner) (count (:hand runner))) " cards")
 :effect (effect (draw (- (hand-size state :runner) (count (:hand runner)))))}

{:flags {:psi-prevent-spend (req 2)}}

{:implementation "Does not prevent rez if HQ is empty"
 :events {:rez {:req (req (and (not (ice? target)) (< 0 (count (:hand corp)))))
                ;; FIXME the above condition is just a bandaid, proper fix would be preventing the rez altogether
                :msg "force the Corp to trash 1 card from HQ at random"
                :effect (effect (trash (first (shuffle (:hand corp)))))}}}

{:prompt "Choose a server"
 :choices (req (let [unrezzed-ice #(seq (filter (complement rezzed?) (:ices (second %))))
                     bad-zones (keys (filter (complement unrezzed-ice) (get-in @state [:corp :servers])))]
                 (zones->sorted-names (remove (set bad-zones) (get-runnable-zones @state)))))
 :effect (effect (run target {:end-run {:req (req (:successful run)) :msg " gain 12 [Credits]"
                                        :effect (effect (gain :runner :credit 12))}} card))}

{:prompt "Choose a Connection"
 :choices (req (cancellable (filter #(has-subtype? % "Connection") (:deck runner)) :sorted))
 :msg (msg "add " (:title target) " to their Grip and shuffle their Stack")
 :effect (req (let [connection target]
                (trigger-event state side :searched-stack nil)
                (resolve-ability
                  state side
                  {:prompt (str "Install " (:title connection) "?")
                   :choices ["Yes" "No"]
                   :effect (req (let [d target]
                                  (resolve-ability state side
                                    {:effect (req (shuffle! state side :deck)
                                                  (if (= "Yes" d)
                                                    (runner-install state side connection)
                                                    (move state side connection :hand)))} card nil)))}
                  card nil)))}

{:effect (effect (draw 3))
 :trash-effect {:when-inactive true
                :req (req (#{:meat :net} target))
                :effect (effect (draw :runner 3)) :msg "draw 3 cards"}}

{:effect (effect (run :archives nil card)
                 (register-events (:events (card-def card)) (assoc card :zone '(:discard))))
 :events {:pre-access
          {:delayed-completion true
           :req (req (and (= target :archives)
                          ;; don't prompt unless there's at least 1 rezzed ICE matching one in Archives
                          (not-empty (clojure.set/intersection
                                       (into #{} (map :title (filter #(ice? %) (:discard corp))))
                                       (into #{} (map :title (filter #(rezzed? %) (all-installed state :corp))))))))
           :effect (req (continue-ability state side
                          {:delayed-completion true
                           :prompt "Choose a piece of ICE in Archives"
                           :choices (req (filter ice? (:discard corp)))
                           :effect (req (let [icename (:title target)]
                                          (continue-ability state side
                                            {:delayed-completion true
                                             :prompt (msg "Choose a rezzed copy of " icename " to trash")
                                             :choices {:req #(and (ice? %)
                                                                  (rezzed? %)
                                                                  (= (:title %) icename))}
                                             :msg (msg "trash " (card-str state target))
                                             :effect (req (trash state :corp target)
                                                          (unregister-events state side card)
                                                          (effect-completed state side eid))} card nil)))}
                         card nil))}}}

(let [cards-to-draw (fn [ts] (* (count ts) (if (some #(and (not (facedown? %)) (has-subtype? % "Directive")) ts) 2 1)))]
  {:choices {:max 5 :req #(and (:installed %) (= (:side %) "Runner"))}
   :effect (effect (trash-cards targets) (draw :runner (cards-to-draw targets)))
   :msg (msg "trash " (count targets) " card" (when (not= 1(count targets)) "s") " and draw " (cards-to-draw targets) " cards")})

{:delayed-completion true
 :effect (effect (run :rd
                      {:replace-access
                       {:msg "rearrange the top 5 cards of R&D"
                        :delayed-completion true
                        :effect (req (show-wait-prompt state :corp "Runner 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 :corp from '()
                                                                                      (count from) from) card nil)
                                         (do (clear-wait-prompt state :corp)
                                             (effect-completed state side eid card)))))}} card))}

{:prompt "Gain 2 [Credits] or expose a card?" :choices ["Gain 2 [Credits]" "Expose a card"]
 :effect (effect (continue-ability (if (= target "Expose a card")
                                     {:choices {:req installed?}
                                      :delayed-completion true
                                      :effect (effect (expose eid target))}
                                      {:msg "gain 2 [Credits]" :effect (effect (gain :credit 2))})
                                   card nil))}

(letfn [(access-pile [cards pile]
          {:prompt "Select a card to access. You must access all cards."
           :choices [(str "Card from pile " pile)]
           :effect (req (system-msg state side (str "accesses " (:title (first cards))))
                        (when-completed
                          (handle-access state side [(first cards)])
                          (do (if (< 1 (count cards))
                                (continue-ability state side (access-pile (next cards) pile) card nil)
                                (effect-completed state side eid card)))))})
        (which-pile [p1 p2]
          {:prompt "Choose a pile to access"
           :choices [(str "Pile 1 (" (count p1) " cards)") (str "Pile 2 (" (count p2) " cards)")]
           :effect (req (let [choice (if (.startsWith target "Pile 1") 1 2)]
                          (clear-wait-prompt state :corp)
                          (continue-ability state side
                             (access-pile (if (= 1 choice) p1 p2) choice)
                             card nil)))})]
  (let [access-effect
        {:delayed-completion true
         :mandatory true
         :effect (req (if (< 1 (count (:hand corp)))
                        (do (show-wait-prompt state :runner "Corp to create two piles")
                            (continue-ability
                              state :corp
                              {:prompt (msg "Select up to " (dec (count (:hand corp))) " cards for the first pile")
                               :choices {:req #(and (in-hand? %) (card-is? % :side :corp))
                                         :max (req (dec (count (:hand corp))))}
                               :effect (effect (clear-wait-prompt :runner)
                                               (show-wait-prompt :corp "Runner to choose a pile")
                                               (continue-ability
                                                 :runner
                                                 (which-pile (shuffle targets)
                                                             (shuffle (vec (clojure.set/difference
                                                                             (set (:hand corp)) (set targets)))))
                                                 card nil))
                               } card nil))
                        (effect-completed state side eid card)))}]
    {:effect (effect (run :hq {:req (req (= target :hq))
                               :replace-access access-effect}
                          card))}))

{:effect (req (doseq [c (take 4 (get-in @state [:runner :deck]))]
                (if (is-type? c "Program")
                  (do (trash state side c) (gain state side :credit 1)
                      (system-msg state side (str "trashes " (:title c) " and gains 1 [Credits]")))
                  (do (move state side c :hand)
                      (system-msg state side (str "adds " (:title c) " to Grip"))))))}

{:prompt "Choose a server"
 :choices (req runnable-servers)
 :delayed-completion true
 :effect (effect (run target nil card)
                 (continue-ability
                   {:prompt "Choose an icebreaker"
                    :choices {:req #(and (installed? %) (has-subtype? % "Icebreaker"))}
                    :effect (effect (pump target 2 :all-run))}
                   card nil))}

{:implementation "Bypass is manual"
 :prompt "Choose a server"
 :choices (req runnable-servers)
 :effect (effect (run target nil card))}

(let [ab (effect (register-turn-flag!
                  card :can-rez
                  (fn [state side card]
                    (if (and (= (:active-player @state) :runner) (not (ice? card)))
                      ((constantly false)
                       (toast state :corp "Cannot rez non-ICE on the Runner's turn due to Interdiction"))
                      true))))]
  {:msg "prevent the Corp from rezzing non-ICE cards on the Runner's turn"
   :effect ab
   :events {:runner-turn-begins {:effect ab}}
   :leave-play (req (clear-all-flags-for-card! state side card))})

{:msg "reduce the Corp's maximum hand size by 1 for each bad publicity"
 :effect (req (lose state :corp :hand-size-modification (:bad-publicity corp))
              (add-watch state :itin
                (fn [k ref old new]
                  (let [bpnew (get-in new [:corp :bad-publicity])
                        bpold (get-in old [:corp :bad-publicity])]
                    (when (> bpnew bpold)
                      (lose state :corp :hand-size-modification (- bpnew bpold)))
                    (when (< bpnew bpold)
                      (gain state :corp :hand-size-modification (- bpold bpnew)))))))
 :leave-play (req (remove-watch state :itin)
                  (gain state :corp :hand-size-modification (:bad-publicity corp)))}

{:implementation "Ice trash is manual"
 :prompt "Choose a server"
 :choices (req runnable-servers)
 :effect (effect (run target nil card))}

{:req (req (:stole-agenda runner-reg)) :prompt "Choose a server" :choices (req servers)
 :msg (msg "force the Corp to trash an ICE protecting " target)
 :effect (req (let [serv (next (server->zone state target))
                    servname target]
                (resolve-ability
                  state :corp
                  {:prompt (msg "Choose a piece of ICE in " target " to trash")
                   :choices {:req #(and (= (last (:zone %)) :ices)
                                        (= serv (rest (butlast (:zone %)))))}
                   :effect (req (trash state :corp target)
                                (system-msg state side (str "trashes "
                                 (card-str state target))))}
                 card nil)))}