Assets

(campaign 12 3)

{:effect (effect (gain :credit 3))
 :msg (msg "gain 3 [Credits]")
 :abilities [{:label "[Trash]: Install a non-agenda card from HQ"
              :effect (effect (trash card) (corp-install target nil))
              :msg (msg (corp-install-msg target))
              :prompt "Choose a non-agenda card to install from HQ"
              :priority true
              :req (req (not (:run @state)))
              :choices {:req #(and (not (is-type? % "Operation"))
                                   (not (is-type? % "Agenda"))
                                   (= (:zone %) [:hand])
                                   (= (:side %) "Corp"))}}]}

(advance-ambush 2 {:req (req (< 0 (:advance-counter (get-card state card) 0)))
                   :delayed-completion true
                   :effect
                   (req (let [agg (get-card state card)
                              n (:advance-counter agg 0)
                              ab (-> trash-program
                                     (assoc-in [:choices :max] n)
                                     (assoc :prompt (msg "Choose " n " program" (when (> n 1) "s") " to trash")
                                            :delayed-completion true
                                            :effect (effect (trash-cards eid targets nil))
                                            :msg (msg "trash " (join ", " (map :title targets)))))]
                          (continue-ability state side ab agg nil)))})

{:abilities [{:label "[Trash]: Shuffle all cards in HQ into R&D"
              :effect (req (trash state side card)
                           (do (show-wait-prompt state :corp "Runner to decide whether or not to prevent Alexa Belsky")
                               (resolve-ability
                                 state side
                                 {:prompt "How many credits?"
                                  :choices :credit :player :runner
                                  :msg (msg "shuffle " (- (count (:hand corp)) (quot target 2)) " card"
                                            (when-not (= 1 (- (count (:hand corp)) (quot target 2))) "s")
                                            " in HQ into R&D")
                                  :effect (req (if (pos? (quot target 2))
                                                 (do (doseq [c (take (- (count (:hand corp)) (quot target 2))
                                                                     (shuffle (:hand corp)))]
                                                       (move state :corp c :deck))
                                                     (shuffle! state :corp :deck)
                                                     (system-msg state :runner
                                                                 (str "pays " target " [Credits] to prevent "
                                                                      (quot target 2) " random card"
                                                                      (when (> (quot target 2) 1) "s")
                                                                      " in HQ from being shuffled into R&D")))
                                                 (shuffle-into-deck state :corp :hand))
                                               (clear-wait-prompt state :corp))} card nil)))}]}

{:events {:corp-install {:effect (effect (add-counter card :power 1))}}
 :abilities [{:cost [:click 1] :label "Gain 2 [Credits] for each counter on Alix T4LB07"
              :msg (msg "gain " (* 2 (get-in card [:counter :power] 0)) " [Credits]")
              :effect (effect (gain :credit (* 2 (get-in card [:counter :power] 0)))
                              (trash card))}]}

{:implementation "Card swapping is manual"
 :advanceable :always
 :abilities [{:label "Swap 1 card in HQ and Archives for each advancement token"
              :effect (effect (trash card))
              :msg (msg "swap " (:advance-counter card 0) " cards in HQ and Archives")}]}

(let [ability {:label "Place 1 advancement token on Anson Rose (start of turn)"
               :once :per-turn
               :effect (effect (add-prop card :advance-counter 1 {:placed true}))}]
  {:derezzed-events {:runner-turn-ends corp-rez-toast}
   :flags {:corp-phase-12 (req true)}
   :events {:corp-turn-begins ability
            :rez {:req (req (and (ice? target) (pos? (:advance-counter card 0))))
                  :delayed-completion true
                  :effect (req (let [ice (get-card state target)
                                     icename (:title ice)]
                                 (show-wait-prompt state :runner "Corp to use Anson Rose")
                                 (continue-ability state side
                                   {:optional
                                    {:prompt (msg "Move advancement tokens from Anson Rose to " icename "?")
                                     :yes-ability {:prompt "Choose how many advancement tokens to remove from Anson Rose"
                                                   :choices {:number (req (:advance-counter card))}
                                                   :effect (effect (clear-wait-prompt :runner)
                                                                   (add-prop :corp ice :advance-counter target {:placed true})
                                                                   (add-prop :corp card :advance-counter (- target) {:placed true})
                                                                   (system-msg (str "uses Anson Rose to move " target " advancement tokens to "
                                                                                    (card-str state ice))))}
                                     :no-ability {:effect (effect (clear-wait-prompt :runner))}}}
                                  card nil)))}}
   :abilities [ability]})

{:events {:successful-trace {:msg "gain 1 [Credit] and force the Runner to lose 1 [Credit]"
                             :effect (effect (gain :credit 1)
                                             (lose :runner :credit 1))}}}

(let [ability {:req (req unprotected)
               :delayed-completion true
               :label "Do 1 net damage (start of turn)"
               :once :per-turn
               :msg "do 1 net damage"
               :effect (effect (damage eid :net 1 {:card card}))}]
  {:derezzed-events {:runner-turn-ends corp-rez-toast}
   :events {:corp-turn-begins ability}
   :abilities [ability]})

{:effect (effect (lock-zone (:cid card) :runner :discard))
 :leave-play (effect (release-zone (:cid card) :runner :discard))}

{:events {:pre-rez
          {:req (req (and (ice? target) (has-subtype? target "Bioroid")))
           :effect (effect (rez-cost-bonus (- (:click runner))))}}}

{:implementation "Removes 1 bad publicity rather than prevent it"
 :abilities [{:label "Trace 3 - Avoid taking a bad publicity"
              :trace {:base 3 :msg "avoid taking a bad publicity"
                      :effect (effect (lose :bad-publicity 1))}}]}

{:abilities [{:cost [:click 1]
              :req (req (and (< (:credit runner) 6)
                             (< 0 (count (filter #(is-type? % "Operation") (:discard corp))))))
              :label "Play an operation from Archives ignoring all costs and remove it from the game"
              :prompt "Choose an operation to play"
              :msg (msg "play " (:title target) " from Archives ignoring all costs and remove it from the game")
              :choices (req (cancellable (filter #(is-type? % "Operation") (:discard corp)) :sorted))
              :effect (effect (play-instant nil target {:ignore-cost true}) (move target :rfg))}]}

{:abilities [{:cost [:click 1] :effect (effect (gain :credit 2)) :msg "gain 2 [Credits]"}]}

(advance-ambush 3 {:req (req (< 0 (:advance-counter (get-card state card) 0)))
                   :msg (msg "do " (:advance-counter (get-card state card) 0) " brain damage")
                   :delayed-completion true
                   :effect (effect (damage eid :brain (:advance-counter (get-card state card) 0) {:card card}))})

{:effect (effect (lose :runner :hand-size-modification 2))
 :leave-play (effect (gain :runner :hand-size-modification 2))
 :trash-effect {:when-inactive true
                :req (req (:access @state))
                :msg "add it to the Runner's score area as an agenda worth 2 agenda points"
                :effect (effect (as-agenda :runner card 2))}}

{:abilities [{:label "Add 1 power counter"
              :effect (effect (add-counter card :power 1)
                              (system-msg (str "adds 1 power counter to Chief Slee")))}
             {:counter-cost [:power 5] :cost [:click 1]
              :delayed-completion true
              :msg "do 5 meat damage"
              :effect (effect (damage eid :meat 5 {:card card}))}]}

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :flags {:corp-phase-12 (req (> (:credit corp) 0))}
 :abilities [{:label "Move up to 3 [Credit] from credit pool to C.I. Fund"
              :prompt "Choose how many [Credit] to move" :once :per-turn
              :choices {:number (req (min (:credit corp) 3))}
              :effect (effect (lose :credit target)
                              (add-counter card :credit target))
              :msg (msg "move " target " [Credit] to C.I. Fund")}
             {:label "Take all credits from C.I. Fund"
              :cost [:credit 2]
              :msg (msg "trash it and gain " (get-in card [:counter :credit] 0) " [Credits]")
              :effect (effect (gain :credit (get-in card [:counter :credit] 0))
                              (trash card {:cause :ability-cost}))}]
 :events {:corp-turn-begins {:req (req (>= (get-in card [:counter :credit] 0) 6))
                             :effect (effect (add-counter card :credit 2)
                                             (system-msg (str "adds 2 [Credit] to C.I. Fund")))}}}

{:events {:runner-turn-begins
          {:prompt "Pay 1 [Credits] or take 1 tag" :choices ["Pay 1 [Credits]" "Take 1 tag"]
           :player :runner :msg "make the Runner pay 1 [Credits] or take 1 tag"
           :delayed-completion true
           :effect (req (if-not (and (= target "Pay 1 [Credits]")
                                     (pay state side card :credit 1)
                                     (effect-completed state side eid))
                          (do (tag-runner state side eid 1)
                              (system-msg state side "takes 1 tag"))
                          (system-msg state side "pays 1 [Credits]")))}}}

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :flags {:corp-phase-12 (req (and (some #(is-type? % "Operation") (:discard corp))
                                  unprotected))}
 :abilities [{:label "Add 1 operation from Archives to HQ"
              :prompt "Choose an operation in Archives to add to HQ" :show-discard true
              :choices {:req #(and (is-type? % "Operation")
                                   (= (:zone %) [:discard]))}
              :effect (effect (move target :hand)) :once :per-turn
              :msg (msg "add " (if (:seen target) (:title target) "a facedown card") " to HQ")}]}

(let [ability {:req (req unprotected)
               :label "Gain 3 [Credits] (start of turn)"
               :once :per-turn
               :msg "gain 3 [Credits]"
               :effect (effect (gain :credit 3))}]
  {:derezzed-events {:runner-turn-ends corp-rez-toast}
   :events {:corp-turn-begins ability}
   :abilities [ability]})

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :flags {:corp-phase-12
         (req (let [tokens (filter #(pos? (:advance-counter % 0)) (all-installed state :corp))
                    advanceable (filter #(can-be-advanced? %) (all-installed state :corp))]
                (when (and (not-empty tokens) (not-empty (clojure.set/difference (set advanceable) (set tokens))))
                  true)))}
 :once :per-turn
 :abilities [{:label "Move an advancement token between ICE"
              :choices {:req #(and (ice? %) (:advance-counter %))}
              :priority true
              :effect (req (let [fr target]
                             (resolve-ability
                               state side
                               {:priority true
                                :prompt "Move to where?"
                                :choices {:req #(and (ice? %)
                                                     (not= (:cid fr) (:cid %))
                                                     (can-be-advanced? %))}
                                :effect (effect (add-prop :corp target :advance-counter 1)
                                                (add-prop :corp fr :advance-counter -1)
                                                (system-msg (str "uses Constellation Protocol to move an advancement token from "
                                                                 (card-str state fr) " to " (card-str state target))))} card nil)
                             card nil))}]}

{:advanceable :always
 :abilities [{:label "Trash a connection" :cost [:click 1] :req (req (>= (:advance-counter card) 2))
              :choices {:req #(has-subtype? % "Connection")}
              :msg (msg "to trash " (:title target)) :effect (effect (trash card) (trash target))}
             {:cost [:click 1] :req (req (>= (:advance-counter card) 2))
              :delayed-completion true
              :msg "do 2 meat damage"
              :effect (effect (trash card) (damage eid :meat 2 {:card card}))}]}

{:additional-cost [:forfeit]
 :derezzed-events {:runner-turn-ends corp-rez-toast}
 ; not-empty doesn't work for the next line, because it does not return literal true; it returns the collection.
 ; flags need exact equality of value to work.
 :flags {:corp-phase-12 (req (and (pos? (count (filter #(card-is? % :type "Resource") (all-installed state :runner))))
                                  (:rezzed card)))}
 :abilities [{:label "Trash a resource"
              :prompt "Choose a resource to trash with Corporate Town"
              :choices {:req #(is-type? % "Resource")}
              :msg (msg "trash " (:title target))
              :effect (effect (trash target {:unpreventable true}))}]}

{:in-play [:hand-size-modification 4]}

{:events {:pre-corp-draw
          {:msg "draw additional cards"
           :once :per-turn
           :once-key :daily-business-show-draw-bonus
           :req (req (first-event? state side :pre-corp-draw))
           :effect (req (let [dbs (count (filter #(and (= "06086" (:code %)) (rezzed? %)) (all-installed state :corp)))]
                          (draw-bonus state side dbs)))}
          :post-corp-draw
          {:once :per-turn
           :once-key :daily-business-show-put-bottom
           :delayed-completion true
           :effect (req (let [dbs (count (filter #(and (= "06086" (:code %)) (rezzed? %)) (all-installed state :corp)))
                              drawn (get-in @state [:corp :register :most-recent-drawn])]
                          (continue-ability
                            state side
                            {:prompt (str "Choose " dbs " card" (when (> dbs 1) "s") " to add to the bottom of R&D")
                             :msg (msg "add " dbs " card" (when (> dbs 1) "s") " to the bottom of R&D")
                             :choices {:max dbs
                                       :req #(some (fn [c] (= (:cid c) (:cid %))) drawn)}
                             :effect (req (doseq [c targets] (move state side c :deck)))} card targets)))}}}

{:events {:successful-run-ends {:req (req tagged)
                                :msg "do 2 meat damage"
                                :delayed-completion true
                                :effect (effect (damage eid :meat 2 {:card card}))}}}

{:recurring 2}

{:in-play [:click 1 :click-per-turn 1]
 :trash-effect {:when-inactive true
                :req (req (:access @state))
                :msg "add it to the Runner's score area as an agenda worth 2 agenda points"
                :effect (effect (as-agenda :runner card 2))}}

{:abilities [{:cost [:click 2]
              :msg "add 1 power counter"
              :effect (effect (add-counter card :power 1))}]
 :events {:pre-install {:req (req (and (not (zero? (get-in  card [:counter :power])))
                                       (not (get-in @state [:per-turn (:cid card)]))))
                        :effect (effect (install-cost-bonus [:credit (get-in card [:counter :power])]))}
          :runner-install {:silent (req true)
                           :req (req (and (not (zero? (get-in card [:counter :power])))
                                          (not (get-in @state [:per-turn (:cid card)]))))
                           :msg (msg "increase the install cost of " (:title target) " by " (get-in card [:counter :power]) " [Credits]")
                           :effect (req (swap! state assoc-in [:per-turn (:cid card)] true))}}}

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :flags {:corp-phase-12 (req (some #(and (can-be-advanced? %) (in-server? %)) (all-installed state :corp)))}
 :abilities [{:cost [:credit 1] :label "Place 1 advancement token on a card that can be advanced in a server"
              :choices {:req #(and (can-be-advanced? %)
                                   (installed? %)
                                   (in-server? %))} ; should be *in* a server
              :effect (effect (add-prop target :advance-counter 1 {:placed true})) :once :per-turn
              :msg (msg "place 1 advancement token on " (card-str state target))}]}

(letfn [(ice-count [state]
          (count (get-in (:corp @state) [:servers (last (:server (:run @state))) :ices])))]
  (installed-access-trigger 3 {:msg (msg "do " (ice-count state) " brain damage")
                               :delayed-completion true
                               :effect (effect (damage eid :brain (ice-count state)
                                                       {:card card}))}))

{:effect (effect (lose :bad-publicity 1)) :msg "remove 1 bad publicity"
 :abilities [{:cost [:click 1] :label "Trash a location"
              :msg (msg "trash " (:title target) " and take 1 bad publicity")
              :choices {:req #(has-subtype? % "Location")}
              :effect (effect (trash card) (trash target) (gain :bad-publicity 1))}]}

{:abilities [{:cost [:click 3] :choices {:req #(not (:rezzed %))}
              :label "Rez a card at no cost" :msg (msg "rez " (:title target) " at no cost")
              :effect (effect (rez target {:ignore-cost :all-costs}))}]}

{:events {:pre-trash {:req (req (installed? target))
                      :effect (effect (trash-cost-bonus 1))}}}

(campaign 16 2)

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :flags {:corp-phase-12 (req (some #(not (rezzed? %)) (all-installed state :corp)))}
 :abilities [{:choices {:req (complement rezzed?)}
              :label "Rez a card, lowering the cost by 1 [Credits]"
              :msg (msg "rez " (:title target))
              :effect (effect (rez-cost-bonus -1)
                              (rez target {:no-warning true})
                              (update! (assoc card :ebc-rezzed (:cid target))))}
             {:prompt "Choose an asset to add to HQ"
              :msg (msg "add " (:title target) " to HQ")
              :activatemsg "searches R&D for an asset"
              :choices (req (cancellable (filter #(is-type? % "Asset")
                                                 (:deck corp))
                                         :sorted))
              :cost [:credit 1]
              :label "Search R&D for an asset"
              :effect (effect (trash card)
                              (shuffle! :deck)
                              (move target :hand))}]
 ; A card rezzed by Executive Bootcamp is ineligible to receive the turn-begins event for this turn.
 :suppress {:corp-turn-begins {:req (req (= (:cid target) (:ebc-rezzed (get-card state card))))}}
 :events {:corp-turn-ends {:req (req (:ebc-rezzed card))
                           :effect (effect (update! (dissoc card :ebc-rezzed)))}}}

{:abilities [{:prompt "Choose an executive, sysop, or character to add to HQ"
              :msg (msg "add " (:title target) " to HQ and shuffle R&D")
              :activatemsg "searches R&D for an executive, sysop, or character"
              :choices (req (cancellable (filter #(or (has-subtype? % "Executive")
                                                      (has-subtype? % "Sysop")
                                                      (has-subtype? % "Character"))
                                                 (:deck corp))
                                         :sorted))
              :cost [:click 1]
              :label "Search R&D for an executive, sysop, or character"
              :effect (effect (move target :hand) (shuffle! :deck))}]}

{:advanceable :always
 :abilities [{:label "Remove 1 bad publicity for each advancement token on Exposé"
              :msg (msg "remove " (:advance-counter card) " bad publicity")
              :effect (effect (trash card) (lose :bad-publicity (:advance-counter card)))}]}

{:events {:access {:req (req (is-type? target "Agenda"))
                   :msg "add it to their score area as an agenda worth 1 agenda point"
                   :effect (effect (as-agenda :corp card 1))}}}

{:can-host (req (and (or (is-type? target "Asset") (is-type? target "Agenda"))
                     (> 2 (count (:hosted card)))))
 :trash-cost-bonus (req (* 3 (count (:hosted card))))
 :abilities [{:label "Install an asset or agenda on Full Immersion RecStudio"
              :req (req (< (count (:hosted card)) 2))
              :cost [:click 1]
              :prompt "Choose an asset or agenda to install"
              :choices {:req #(and (or (is-type? % "Asset") (is-type? % "Agenda"))
                                   (in-hand? %)
                                   (= (:side %) "Corp"))}
              :msg "install and host an asset or agenda"
              :effect (req (corp-install state side target card))}]}

{:events {:psi-game {:req (req (not= (first targets) (second targets)))
                     :delayed-completion true
                     :msg "do 1 meat damage"
                     :effect (effect (damage eid :meat 1 {:card card}))}}}

{:msg "prevent the Runner from drawing more than 2 cards during their turn"
 :effect (req (max-draw state :runner 2)
              (when (= 0 (remaining-draws state :runner))
                (prevent-draw state :runner)))
 :events {:runner-turn-begins {:effect (effect (max-draw :runner 2))}}
 :leave-play (req (swap! state update-in [:runner :register] dissoc :max-draw :cannot-draw))}

(advance-ambush 0 {:delayed-completion true
                   :req (req (< 0 (:advance-counter (get-card state card) 0)))
                   :msg (msg "give the Runner " (:advance-counter (get-card state card) 0) " tag"
                             (when (> (:advance-counter (get-card state card) 0) 1) "s"))
                   :effect (effect (tag-runner :runner eid (:advance-counter (get-card state card) 0)))})

{:advanceable :always
 :abilities [{:label "Gain 4 [Credits] for each advancement token on GRNDL Refinery"
              :cost [:click 1] :msg (msg "gain " (* 4 (get card :advance-counter 0)) " [Credits]")
              :effect (effect (trash card) (gain :credit (* 4 (get card :advance-counter 0))))}]}

{:advanceable :while-unrezzed
 :abilities [{:label "Gain [Click]" :once :per-turn :msg "gain [Click]"
              :cost [:click 1] :advance-counter-cost 1 :effect (effect (gain :click 2))}]}

{:events {:runner-trash {:delayed-completion true
                         :req (req (some #(card-is? % :side :corp) targets))
                         :msg (msg (str "do " (count (filter #(card-is? % :side :corp) targets))
                                        " net damage"))
                         :effect (effect (damage eid :net (count (filter #(card-is? % :side :corp) targets))
                                                 {:card card}))}}
 :abilities [{:msg "do 1 net damage"
              :delayed-completion true
              :effect (effect (damage eid :net 1 {:card card}))}]}

{:events {:psi-bet-corp {:once :per-turn
                         :msg (msg "gain " target " [Credits]")
                         :effect (effect (gain :corp :credit target))}}}

(let [trash-ability (fn [type] {:req (req (seq (filter #(is-type? % type) (:hand runner))))
                                :prompt (str "Choose a " type " to trash")
                                :choices (req (filter #(is-type? % type) (:hand runner)))
                                :effect (effect (trash target))
                                :msg (msg " trash " (:title target) " from the Runner's Grip")})
      choose-ability {:label "Trash 1 card in the Runner's Grip of a named type"
                      :once :per-turn
                      :req (req (seq (:hand runner)))
                      :prompt "Choose a card type"
                      :choices ["Event" "Hardware" "Program" "Resource"]
                      :msg (msg "reveal " (join ", " (map :title (:hand runner))) " and trash a " target)
                      :effect (effect (resolve-ability (trash-ability target) card nil))}]
  {:additional-cost [:forfeit]
   :flags {:corp-phase-12 (constantly true)}
   :derezzed-events {:runner-turn-ends corp-rez-toast}
   :abilities [choose-ability]})

(let [iuse {:req (req (not= (:faction target) (:faction (:identity corp))))
            :msg "gain 1 [Credits]"
            :effect (effect (gain :credit 1))}]
  {:events {:play-operation iuse :rez iuse}})

{:abilities [{:cost [:click 1] :label "Add an installed card to HQ"
              :choices {:req installed?}
              :msg (msg "move " (card-str state target) " to HQ")
              :effect (effect (move target :hand))}]}

{:abilities [{:counter-cost [:power 1]
              :label "Add strength to a rezzed ICE"
              :choices {:req #(and (ice? %) (:rezzed %))}
              :req (req (< 0 (get-in card [:counter :power] 0)))
              :msg (msg "add strength to a rezzed ICE")
              :effect (req (update! state side (update-in card [:it-targets (keyword (str (:cid target)))]
                                                          (fnil inc 0)))
                           (update-ice-strength state side target))}
             {:cost [:click 1]
              :msg "add 1 counter"
              :effect (effect (add-counter card :power 1))}]
 :events (let [it {:req (req (:it-targets card))
                   :effect (req (update! state side (dissoc card :it-targets))
                                (update-all-ice state side))}]
           {:pre-ice-strength {:req (req (get-in card [:it-targets (keyword (str (:cid target)))]))
                               :effect (effect (ice-strength-bonus
                                                 (* (get-in card [:it-targets (keyword (str (:cid target)))])
                                                    (inc (get-in card [:counter :power]))) target))}
            :runner-turn-ends it :corp-turn-ends it})}

{:abilities [{:cost [:click 1] :effect (effect (draw 2)) :msg "draw 2 cards"}
             {:label "Shuffle up to 3 cards from Archives into R&D"
              :activatemsg "removes Jackson Howard from the game"
              :effect (effect (rfg-and-shuffle-rd-effect card 3))}]}

{:implementation "Trigger is manual"
 :abilities [{:label "Gain [Click]"
              :msg "gain [Click]" :once :per-turn
              :effect (effect (gain :click 1))}]}

{:flags {:corp-phase-12 (req true)}
 :abilities [{:msg "look at the top card of the Runner's Stack"
               :effect (effect (prompt! card (str "The top card of the Runner's Stack is "
                                                  (:title (first (:deck runner)))) ["OK"] {}))}
             {:label "[Trash]: Trash the top card of the Runner's Stack"
              :msg (msg "trash " (:title (first (:deck runner))) " from the Runner's Stack")
              :effect (effect (mill :runner)
                              (trash card {:cause :ability-cost}))}]}

{:events {:rez {:effect (effect (add-counter card :power 1))}}
 :abilities [{:req (req (seq (filter #(and (is-type? % "Agenda")
                                           (>= (get-in card [:counter :power] 0)
                                               (:agendapoints %)))
                                     (:hand corp))))
              :label "X power counters: Reveal an agenda worth X points from HQ"
              :effect (req (let [c (get-in card [:counter :power])]
                             (resolve-ability
                               state side
                               {:prompt "Choose an agenda in HQ to reveal"
                                :choices {:req #(and (is-type? % "Agenda")
                                                     (>= c (:agendapoints %)))}
                                :msg (msg "reveal " (:title target) " from HQ")
                                :effect (req (let [title (:title target)
                                                   pts (:agendapoints target)]
                                               (register-turn-flag! state side
                                                 card :can-steal
                                                 (fn [state side card]
                                                   (if (= (:title card) title)
                                                     ((constantly false)
                                                      (toast state :runner "Cannot steal due to Lakshmi Smartfabrics." "warning"))
                                                     true)))
                                               (add-counter state side card :power (- pts))))} card nil)))}]}

(campaign 6 2)

{:abilities [{:prompt "Choose an ICE"
              :msg (msg "adds " (:title target) " to HQ")
              :choices (req (cancellable (filter ice? (:deck corp)) :sorted))
              :label "Search R&D for a piece of ICE"
              :cost [:click 1 :credit 1]
              :effect (effect (shuffle! :deck)
                              (move target :hand))}]}

{:effect (effect (draw 3))
 :msg (msg "draw 3 cards")
 :abilities [{:label "Remove a tag to search R&D for an operation"
              :prompt "Choose an operation to put on top of R&D"
              :cost [:click 1]
              :choices (req (let [ops (filter #(is-type? % "Operation") (:deck corp))]
                              (if (empty? ops) ["No Operation in R&D"] ops)))
              :req (req (pos? (get-in @state [:runner :tag])))
              :effect (req (if (not= target "No Operation found")
                             (let [c (move state :corp target :play-area)]
                               (shuffle! state :corp :deck)
                               (move state :corp c :deck {:front true})
                               (system-msg state side (str "uses Lily Lockwell to put " (:title c) " on top of R&D")))
                             (do (shuffle! state :corp :deck)
                                 (system-msg state side (str "uses Lily Lockwell, but did not find an Operation in R&D"))))
                           (lose state :runner :tag 1))}]}

{:events {:agenda-counter-spent {:effect (effect (gain :credit 1))
                                 :msg "gain 1 [Credits]"}}
 :abilities [{:label "Trash to gain 2 [Credits]"
              :msg "gain 2 [Credits]"
              :effect (effect (gain :credit 2) (trash card))}
             {:label "Spend an agenda counter to gain 2 [Credits]"
              :effect (req (resolve-ability
                             state side
                             {:prompt "Select an agenda with a counter"
                              :choices {:req #(and (is-type? % "Agenda")
                                                   (pos? (get-in % [:counter :agenda] 0)))}
                              :effect (req (add-counter state side target :agenda -1)
                                           (gain state :corp :credit 2)
                                           (trigger-event state side :agenda-counter-spent card))
                              :msg (msg "spend an agenda token on " (:title target) " and gain 2 [Credits]")}
                             card nil))}]}

(let [ability {:msg "gain 1 [Credits]"
               :label "Gain 1 [Credits] (start of turn)"
               :once :per-turn
               :counter-cost [:credit 1]
               :effect (effect (gain :credit 1))}]
{:abilities [ability
             {:cost [:click 1]
              :msg "store 3 [Credits]"
              :effect (effect (add-counter card :credit 3))}]
 :events {:corp-turn-begins ability}})

{:abilities [{:cost [:click 3] :effect (effect (gain :credit 7)) :msg "gain 7 [Credits]"}]}

(let [ability {:msg "gain 1 [Credits]"
               :label "Gain 1 [Credits] (start of turn)"
               :once :per-turn
               :effect (effect (gain :credit 1))}]
  {:effect (effect (gain :runner :hand-size-modification 1))
   :leave-play (effect (lose :runner :hand-size-modification 1))
   :derezzed-events {:runner-turn-ends corp-rez-toast}
   :events {:corp-turn-begins ability}
   :abilities [ability]})

{:recurring 2}

{:abilities [{:label "Search R&D for an Alliance card"
              :cost [:click 1]
              :prompt "Choose an Alliance card to play or install"
              :choices (req (cancellable (filter #(and (has-subtype? % "Alliance")
                                                       (if (is-type? % "Operation")
                                                         (<= (:cost %) (:credit corp)) true)) (:deck corp)) :sorted))
              :msg (msg "reveal " (:title target) " from R&D and "
                        (if (= (:type target) "Operation") "play " "install ") " it")
              :effect (req (shuffle! state side :deck)
                           (if (= (:type target) "Operation")
                             (play-instant state side target)
                             (corp-install state side target nil nil)))}]}

{:derezzed-events {:runner-turn-ends corp-rez-toast}
 :events {:corp-turn-begins {:effect (effect (add-prop card :advance-counter 1 {:placed true}))}}
 :abilities [{:cost [:credit 2]
              :req (req (and (> (get card :advance-counter 0) 0)
                             (some #(rezzed? %) (all-installed state :corp))))
              :label "Move an advancement token to a faceup card"
              :prompt "Choose a faceup card"
              :choices {:req #(rezzed? %)}
              :msg (msg "move an advancement token to " (card-str state target))
              :effect (effect (add-prop card :advance-counter -1 {:placed true})
                              (add-prop target :advance-counter 1 {:placed true}))}]}

{:flags {:corp-phase-12 (req (pos? (count (get-in @state [:corp :discard]))))}
 :abilities [{:label "Shuffle cards in Archives into R&D"
              :prompt (msg (let [mus (count (filter #(and (= "10019" (:code %)) (rezzed? %)) (all-installed state :corp)))]
                             (str "Choose " (if (< 1 mus) (str mus " cards") "a card")
                                  " in Archives to shuffle into R&D")))
              :choices {:req #(and (card-is? % :side :corp) (= (:zone %) [:discard]))
                        :max (req (count (filter #(and (= "10019" (:code %)) (rezzed? %)) (all-installed state :corp))))}
              :show-discard true
              :priority 1
              :once :per-turn
              :once-key :museum-of-history
              :msg (msg "shuffle "
                        (let [seen (filter :seen targets)]
                          (str (join ", " (map :title seen))
                               (let [n (count (filter #(not (:seen %)) targets))]
                                 (when (pos? n)
                                   (str (when-not (empty? seen) " and ") n " card"
                                        (when (> n 1) "s"))))))
                        " into R&D")
              :effect (req (doseq [c targets] (move state side c :deck))
                           (shuffle! state side :deck))}]}

(let [ability {:msg "gain 1 [Credits]"
               :label "Gain 1 [Credits] (start of turn)"
               :once :per-turn
               :effect (effect (gain :credit 1))}]
  {:derezzed-events {:runner-turn-ends corp-rez-toast}
   :events {:corp-turn-begins ability}
   :abilities [ability
               {:label "Place 1 power counter" :cost [:credit 1]
                :effect (effect (add-counter card :power 1)
                                (system-msg (str "places 1 power counter on NASX")))}
               {:label "Place 2 power counters" :cost [:credit 2]
                :effect (effect (add-counter card :power 2)
                                (system-msg (str "places 2 power counters on NASX")))}
               {:label "[Trash] and gain 2 [Credits] for each power counter" :cost [:click 1]
                :msg (msg "gain " (* 2 (get-in card [:counter :power])) " [Credits]")
                :effect (effect (gain :credit (* 2 (get-in card [:counter :power])))
                                (trash card))}]})

{:recurring (effect (set-prop card :rec-counter (:link runner)))
 :effect (effect (set-prop card :rec-counter (:link runner)))}

{:access {:msg (msg "force the Runner take 2 tags or add it to their score area as an agenda worth -1 agenda point")
          :delayed-completion true
          :effect (effect (continue-ability
                            {:player :runner
                             :delayed-completion true
                             :prompt "Take 2 tags or add News Team to your score area as an agenda worth -1 agenda point?"
                             :choices ["Take 2 tags" "Add News Team to score area"]
                             :effect (req (if (= target "Add News Team to score area")
                                            (do (system-msg state :runner (str "adds News Team to their score area as an agenda worth -1 agenda point"))
                                                (as-trashed-agenda state :runner card -1 {:force true})
                                                (effect-completed state side eid))
                                            (do (system-msg state :runner (str "takes 2 tags from News Team"))
                                                (tag-runner state :runner eid 2))))}
                            card targets))}}