Resources

(let [am {:effect (effect (add-counter card :power 2)
                          (system-msg :runner (str "places 2 power counters on Aaron Marrón")))}]
  {:abilities [{:counter-cost [:power 1]
                :msg "remove 1 tag and draw 1 card"
                :effect (effect (lose :tag 1) (draw))}]
   :events {:agenda-scored am :agenda-stolen am}})

{:in-play [:link 1]}

{:events
 {:corp-turn-begins {:req (req (= 0 (:tag runner)))
                     :msg "take 1 tag"
                     :delayed-completion true
                     :effect (effect (tag-runner :runner eid 1))}
  :runner-turn-begins {:req (req (not has-bad-pub))
                       :msg "give the Corp 1 bad publicity"
                       :effect (effect (gain :corp :bad-publicity 1))}}}

{:events {:runner-loss {:req (req (and (some #{:click} target)
                                       (let [click-losses (filter #(= :click %) (mapcat first (turn-events state side :runner-loss)))]
                                         (or (empty? click-losses)
                                             (and (= (count click-losses) 1)
                                                  (has-flag? state side :persistent :genetics-trigger-twice))))))
                        :msg "gain [Click]" :effect (effect (gain :runner :click 1))}}}

{:flags {:runner-phase-12 (req (>= 2 (count (all-installed state :runner))))}
 :abilities [{:effect (req (resolve-ability
                             state side
                             {:msg (msg "trash " (:title target) " and gain 3 [Credits]")
                              :choices {:req #(and (card-is? % :side :runner) (installed? %) (not (card-is? % :cid (:cid card))))}
                              :effect (effect (gain :credit 3) (trash target {:unpreventable true}))}
                             card nil))}]}

{:in-play [:click 1 :click-per-turn 1]
 :msg "give each player 1 additional [Click] to spend during their turn"
 :effect (effect (gain :corp :click-per-turn 1))
 :leave-play (effect (lose :corp :click-per-turn 1))}

{:flags {:runner-phase-12 (req (> (:credit runner) 0))}
 :abilities [{:label "Move up to 3 [Credit] from credit pool to Algo Trading"
              :prompt "Choose how many [Credit] to move" :once :per-turn
              :choices {:number (req (min (:credit runner) 3))}
              :effect (effect (lose :credit target)
                              (add-counter card :credit target))
              :msg (msg "move " target " [Credit] to Algo Trading")}
             {:label "Take all credits from Algo Trading"
              :cost [:click 1]
              :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 {:runner-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 Algo Trading")))}}}

{:implementation "Run requirement not enforced"
 :abilities [{:once :per-turn
              :cost [:click 2]
              :msg (msg "break 1 subroutine")}]}

{:abilities [{:cost [:click 1] :effect (effect (trash card {:cause :ability-cost}) (gain :click 2))
              :msg "gain [Click][Click]"}]}

{:prompt "How many power counters?"
 :choices :credit
 :msg (msg "add " target " power counters")
 :effect (effect (add-counter card :power target))
 :abilities [{:counter-cost [:power 1]
              :msg "look at the top card of Stack"
              :effect (req (when (zero? (get-in card [:counter :power] 0))
                             (trash state :runner card {:unpreventable true})))
              :optional {:prompt (msg "Add " (:title (first (:deck runner))) " to bottom of Stack?")
                         :yes-ability {:msg "add the top card of Stack to the bottom"
                                       :effect (req (move state side (first (:deck runner)) :deck))}}}]}

{:data {:counter {:credit 12}}
 :abilities [{:cost [:click 1]
              :counter-cost [:credit 2]
              :msg "gain 2 [Credits]"
              :effect (req (gain state :runner :credit 2)
                           (when (zero? (get-in card [:counter :credit] 0))
                             (trash state :runner card {:unpreventable true})))}]}

{:abilities [{:prompt "Choose a card to install"
              :msg (msg "install " (:title target))
              :cost [:forfeit]
              :choices (req (cancellable (filter #(not (is-type? % "Event")) (:deck runner)) :sorted))
              :effect (effect (trigger-event :searched-stack nil)
                              (shuffle! :deck)
                              (runner-install target))}]}

{:events {:successful-run {:req (req (and (= target :hq)
                                          (first-successful-run-on-server? state :hq)))
                           :msg "force the Corp to trash the top card of R&D"
                           :effect (effect (mill :corp))}}}

{:data {:counter {:credit 8}}
 :events {:successful-run
          {:silent (req true)
           :req (req (is-remote? (:server run)))
           :effect (req (let [bj card]
                          (when-not (:replace-access (get-in @state [:run :run-effect]))
                            (swap! state assoc-in [:run :run-effect :replace-access]
                                   {:effect (req (if (> (count (filter #(= (:title %) "Bank Job") (all-installed state :runner))) 1)
                                                   (resolve-ability state side
                                                     {:prompt "Choose a copy of Bank Job to use"
                                                      :choices {:req #(and installed? (= (:title %) "Bank Job"))}
                                                      :effect (req (let [c target
                                                                         creds (get-in c [:counter :credit])]
                                                                     (resolve-ability state side
                                                                       {:prompt "How many Bank Job credits?"
                                                                        :choices {:number (req (get-in c [:counter :credit]))}
                                                                        :msg (msg "gain " target " [Credits]")
                                                                        :effect (req (gain state side :credit target)
                                                                                     (set-prop state side c :counter {:credit (- creds target)})
                                                                                     (when (= target creds)
                                                                                       (trash state side c {:unpreventable true})))}
                                                                      card nil)))}
                                                    bj nil)
                                                   (resolve-ability state side
                                                     {:prompt "How many Bank Job credits?"
                                                      :choices {:counter :credit}
                                                      :msg (msg "gain " target " [Credits]")
                                                      :effect (req (gain state side :credit target)
                                                                   (when (= target (get-in card [:counter :credit]))
                                                                     (trash state side card {:unpreventable true})))}
                                                    bj nil)))}))))}}}

{:events
 {:runner-install
  {:interactive (req (and (is-type? target "Hardware")
                          (some #(= (:title %) (:title target)) (:hand runner))))
   :silent (req (not (and (is-type? target "Hardware")
                          (some #(= (:title %) (:title target)) (:hand runner)))))
   :delayed-completion true
   :req (req (and (is-type? target "Hardware") (= [:hand] (:previous-zone target))))
   :effect (req (let [hw (:title target)]
                  (continue-ability state side
                    {:optional {:req (req (some #(when (= (:title %) hw) %) (:hand runner)))
                                :prompt (msg "Install another copy of " hw "?")
                                :msg (msg "install another copy of " hw)
                                :yes-ability {:delayed-completion true
                                              :effect (req (if-let [c (some #(when (= (:title %) hw) %)
                                                                            (:hand runner))]
                                                             (runner-install state side eid c nil)))}}} card nil)))}}}

{:in-play [:hand-size-modification 5]
 :events {:runner-turn-begins {:msg "lose [Click]" :effect (effect (lose :click 1))}}}

(let [ability {:once :per-turn
               :label "Gain 1 [Credits], draw 1 card, or gain [Click] (start of turn)"
               :req (req (:runner-phase-12 @state))
               :effect (req (let [c (:credit corp)
                                  b (:title card)]
                              (cond
                                ;; gain 1 credit
                                (<= 5 c 9)
                                (do (gain state side :credit 1)
                                    (system-msg state side (str "uses " b " to gain 1 [Credits]")))
                                ;; draw 1 card
                                (<= 10 c 14)
                                (do (draw state side 1)
                                    (system-msg state side (str "uses " b " to draw 1 card")))
                                ;; gain 1 click
                                (<= 15 c)
                                (do (gain state side :click 1)
                                    (system-msg state side (str "uses " b " to gain [Click]"))))))}]
  {:flags {:drip-economy true}
   :abilities [ability]
   :events {:runner-turn-begins ability}})

{:abilities [{:cost [:click 2]
              :msg "draw 3 cards and shuffle 1 card from their Grip back into their Stack"
              :effect (effect (draw 3)
                              (resolve-ability
                                {:prompt "Choose a card in your Grip to shuffle back into your Stack"
                                 :choices {:req #(and (in-hand? %)
                                                      (= (:side %) "Runner"))}
                                 :effect (effect (move target :deck)
                                                 (shuffle! :deck))}
                               card nil))}]}

{:in-play [:hand-size-modification 1 :link 1]}

{:abilities [{:cost [:click 1]
              :label "Place 1 power counter"
              :msg "place 1 power counter on it"
              :effect (effect (add-counter card :power 1))}
             {:cost [:click 1]
              :label "Install a program from your Grip"
              :prompt "Choose a program to install from your Grip"
              :choices {:req #(and (is-type? % "Program") (in-hand? %))}
              :msg (msg "install " (:title target))
              :effect (req (install-cost-bonus state side [:credit (* -1 (get-in card [:counter :power] 0))])
                           (runner-install state side target)
                           (when (pos? (get-in card [:counter :power] 0))
                             (add-counter state side card :power -1)))}]}

{:events
 {:pre-damage {:req (req (has-subtype? (second targets) "Cybernetic"))
               :effect (effect (damage-prevent target Integer/MAX_VALUE))}}}

{:prevent {:damage [:meat]}
 :abilities [{:label "[Trash] and trash all cards in Grip to prevent all meat damage"
              :msg "trash all cards in their Grip and prevent all meat damage"
              :effect (req (trash state side card {:cause :ability-cost})
                           (doseq [c (:hand runner)]
                             (trash state side c {:unpreventable true}))
                           (damage-prevent state side :meat Integer/MAX_VALUE))}]
 :events {:runner-turn-ends
          {:req (req (pos? (:tag runner)))
           :msg "force the Corp to initiate a trace"
           :label "Trace 1 - If unsuccessful, Runner removes 1 tag"
           :trace {:base 1 :unsuccessful {:effect (effect (lose :runner :tag 1))
                                          :msg "remove 1 tag"}}}}}

{:recurring 1
 :events {:rez {:req (req (ice? target))
                :msg "gain 1 [Credits]"
                :effect (effect (gain :runner :credit 1))}}}

{:implementation "Does not restrict Runner to Asset / Upgrade just rezzed"
 :events {:rez {:req (req (and (#{"Asset" "Upgrade"} (:type target))
                               (can-pay? state :runner nil [:credit (rez-cost state :corp target)])))
                :effect (req (toast state :runner (str "Click Councilman to derez " (card-str state target {:visible true})
                                                       " that was just rezzed") "info")
                             (toast state :corp (str "Runner has the opportunity to derez with Councilman.") "error"))}}
 :abilities [{:prompt "Choose an asset or upgrade that was just rezzed"
              :choices {:req #(and (rezzed? %)
                                   (or (is-type? % "Asset") (is-type? % "Upgrade")))}
              :effect (req (let [c target
                                 creds (rez-cost state :corp c)]
                             (when (can-pay? state side nil [:credit creds])
                               (resolve-ability
                                 state :runner
                                 {:msg (msg "pay " creds " [Credit] and derez " (:title c) ". Councilman is trashed")
                                  :effect (req (lose state :runner :credit creds)
                                               (derez state :corp c)
                                               (register-turn-flag!
                                                 state side card :can-rez
                                                 (fn [state side card]
                                                   (if (= (:cid card) (:cid c))
                                                     ((constantly false)
                                                      (toast state :corp "Cannot rez the rest of this turn due to Councilman"))
                                                     true)))
                                               (trash state side card {:unpreventable true}))}
                                card nil))))}]}

{:prevent {:damage [:meat]}
 :recurring 2
 :abilities [{:label "Trash to prevent up to 3 meat damage"
              :msg "prevent up to 3 meat damage"
              :effect (effect (trash card {:cause :ability-cost}) (damage-prevent :meat 3))}]}

(let [ability {:once :per-turn
               :label "Take 2 [Credits] (start of turn)"
               :msg "gain 2 [Credits]"
               :req (req (:runner-phase-12 @state))
               :counter-cost [:credit 2]
               :effect (req (gain state :runner :credit 2)
                            (when (zero? (get-in card [:counter :credit] 0))
                              (trash state :runner card {:unpreventable true})))}]
{:data {:counter {:credit 8}}
 :flags {:drip-economy true}
 :abilities [ability]
 :events {:runner-turn-begins ability}})

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

(let [ability {:label "Gain 1 [Credits] (start of turn)"
               :msg "gain 1 [Credits]"
               :once :per-turn
               :req (req (and (>= (:memory runner) 2) (:runner-phase-12 @state)))
               :effect (effect (gain :credit 1))}]
 {:flags {:drip-economy true}
 :abilities [ability]
 :events {:runner-turn-begins ability}})

{:req (req (some #{:hq :rd :archives} (:successful-run runner-reg)))
 :abilities [{:req (req tagged) :cost [:click 1] :effect (effect (mill :corp))
              :msg "force the Corp to trash the top card of R&D"}]}

{:abilities [{:msg "prevent the corp from rezzing the outermost piece of ice during a run on any server this turn"
              :effect (effect
                        (register-turn-flag!
                          card :can-rez
                          (fn [state side card]
                            (if (and (ice? card)
                                     (= (count (get-in @state (concat [:corp :servers] (:server (:run @state)) [:ices])))
                                        (inc (ice-index state card))))
                              ((constantly false) (toast state :corp "Cannot rez any outermost ICE due to DDoS." "warning"))
                              true)))
                        (trash card {:cause :ability-cost}))}]}

{:prevent {:tag [:all]}
 :abilities [{:msg "avoid 1 tag" :effect (effect (tag-prevent 1) (trash card {:cause :ability-cost}))}]}

{:flags {:runner-phase-12 (req (>= 2 (count (all-installed state :runner))))}
 :abilities [{:prompt "Choose an installed card to make its text box blank for the remainder of the turn" :once :per-turn
              :choices {:req #(:installed %)}
              :msg (msg "make the text box of " (:title target) " blank for the remainder of the turn")
              :effect (req (let [c target]
                             (update! state side (dissoc target :events :abilities))
                             (deactivate state side target)
                             (register-events state side
                                              {:runner-turn-ends
                                               {:effect (effect (card-init (get-card state c))
                                                                (unregister-events card))}} card)))}]
 :events {:runner-turn-ends nil}}

{:flags {:runner-phase-12 (req (some #(card-flag? % :drip-economy true) (all-installed state :runner)))}
 :abilities [{:label "Lose 1 [Credits] (start of turn)"
              :msg (msg (if (= (get-in @state [:runner :credit]) 0) "lose 0 [Credits] (runner has no credits to lose)" "lose 1 [Credits]"))
              :req (req (:runner-phase-12 @state))
              :once :per-turn
              :effect (effect (lose :credit 1))}]
 :events {:corp-turn-begins {:msg (msg "draw " (if (= (count (get-in @state [:runner :deck])) 0)
                                                "0 cards (runner's stack is empty)"
                                                "1 card"))
                             :effect (effect (draw :runner 1))}
          :runner-turn-begins {:msg (msg "lose " (if (= (get-in @state [:runner :credit]) 0)
                                                          "0 [Credits] (runner has no credits to lose)"
                                                          "1 [Credits]"))
                               :once :per-turn
                               :effect (effect (lose :credit 1))}}}

{:abilities [{:cost [:click 4] :effect (effect (draw 10)) :msg "draw 10 cards"}]}

(let [ability {:msg "draw 2 cards"
               :once :per-turn
               :counter-cost [:power 1]
               :effect (req (draw state :runner 2)
                            (when (zero? (get-in card [:counter :power] 0))
                              (trash state :runner card {:unpreventable true})))}]
{:flags {:runner-turn-draw true
         :runner-phase-12 (req (< 1 (count (filter #(card-flag? % :runner-turn-draw true)
                                                   (cons (get-in @state [:runner :identity])
                                                         (all-installed state :runner))))))}
 :data {:counter {:power  3}}
 :events {:runner-turn-begins ability}
 :abilities [ability]})

{:abilities [{:effect (effect (trash card {:cause :ability-cost}) (draw :corp 2))
              :msg "force the Corp to draw 2 cards"}]
 :install-cost-bonus (req (if (and run (= (:server run) [:rd]) (zero? (:position run)))
                            [:credit -7 :click -1] nil))
 :effect (req (when (and run (= (:server run) [:rd]) (zero? (:position run)))
                (when-completed (register-successful-run state side (:server run))
                                (do (swap! state update-in [:runner :prompt] rest)
                                    (handle-end-run state side)))))}

(let [ability {:req (req (= 0 (count (:hand runner))))
               :msg "gain [Click]"
               :label "Gain [Click] (start of turn)"
               :once :per-turn
               :effect (effect (gain :click 1))}]
  {:events {:runner-turn-begins ability}
   :abilities [ability]})

{:events {:successful-run {:silent (req true)
                           :msg (msg "force the Corp to reveal " (:title (first (shuffle (:hand corp)))))
                           :req (req (genetics-trigger? state side :successful-run))}}}

{:prevent {:trash [:resource]}
 :abilities [{:label "[Trash]: Prevent another installed resource from being trashed"
              :effect (effect (trash-prevent :resource 1) (trash card {:unpreventable true :cause :ability-cost}))}
             {:label "[Trash]: Gain 2 [Credits]"
              :effect (effect (trash card {:cause :ability-cost}) (gain :credit 2)) :msg "gain 2 [Credits]"}]}

{:events {:agenda-scored {:msg "add it to their score area as an agenda worth 0 agenda points"
                          :req (req (installed? card))
                          :effect (effect (as-agenda :runner card 0))}}}

{:events {:purge {:msg "force the Corp to lose 2 [Credits] if able"
                  :effect (effect (pay :corp card :credit 2))}}}

{:abilities [{:req (req (and (empty? (:hosted card))
                             (is-type? (:card (first (get-in @state [side :prompt]))) "Agenda")))
              :label "Host an agenda being accessed"
              :effect (req (when-let [agenda (:card (first (get-in @state [side :prompt])))]
                             (host state side card (move state side agenda :play-area))
                             (close-access-prompt state side)
                             (effect-completed state side eid nil)
                             (when-not (:run @state)
                               (swap! state dissoc :access))))
              :msg (msg "host " (:title (:card (first (get-in @state [side :prompt])))) " instead of accessing it")}
             {:cost [:click 2] :label "Add hosted agenda to your score area"
              :req (req (not (empty? (:hosted card))))
              :effect (req (let [c (move state :runner (first (:hosted card)) :scored)]
                             (gain-agenda-point state :runner (get-agenda-points state :runner c))))
              :msg (msg (let [c (first (:hosted card))]
                          (str "add " (:title c) " to their score area and gain " (get-agenda-points state :runner c)
                               " agenda point" (when (> (get-agenda-points state :runner c) 1) "s"))))}]}

{:events {:post-runner-draw {:msg (msg "reveal that they drew: "
                                       (join ", " (map :title (get-in @state [:runner :register :most-recent-drawn]))))}
          :successful-run {:interactive (req true)
                           :optional
                           {:delayed-completion true
                            :req (req (first-event? state side :successful-run))
                            :prompt "Use Find the Truth to look at the top card of R&D?"
                            :yes-ability {:msg "look at the top card of R&D"
                                          :effect (req (prompt! state :runner card (str "The top card of R&D is "
                                                                                        (:title (first (:deck corp)))) ["OK"] {})
                                                       (effect-completed state side eid))}
                            :no-ability {:effect (req (effect-completed state side eid))}}}}}

{:abilities [{:cost [:credit 2]
              :req (req (not-empty (turn-events state side :damage)))
              :msg "draw 1 card"
              :effect (effect (draw))}]}

{:events {:agenda-scored
          {:delayed-completion true
           :interactive (req true)
           :msg (msg "access " (get-in @state [:runner :hq-access]) " card"
                     (when (< 1 (get-in @state [:runner :hq-access])) "s") " from HQ")
           :effect (req (when-completed
                          ; manually trigger the pre-access event to alert Nerve Agent.
                          (trigger-event-sync state side :pre-access :hq)
                          (let [from-hq (access-count state side :hq-access)]
                            (continue-ability
                              state :runner
                              (access-helper-hq
                                state from-hq
                                ; access-helper-hq uses a set to keep track of which cards have already
                                ; been accessed. by adding HQ root's contents to this set, we make the runner
                                ; unable to access those cards, as Gang Sign intends.
                                (set (get-in @state [:corp :servers :hq :content])))
                              card nil))))}}}

{:msg "make Genetics trigger a second time each turn"
 :effect (effect (register-persistent-flag! card :genetics-trigger-twice (constantly true)))
 :leave-play (effect (clear-persistent-flag! card :genetics-trigger-twice))}

{:data {:counter {:credit 3}}
 :abilities [{:counter-cost [:credit 1]
              :msg "gain 1 [Credits]"
              :req (req (:run @state))
              :effect (req (gain state side :credit 1)
                           (trigger-event state side :spent-stealth-credit card)
                           (when (zero? (get-in card [:counter :credit] 0))
                             (trash state :runner card {:unpreventable true})))}]}

{:req (req (> (:link runner) 1))
 :flags {:runner-phase-12 (req true)}
 :abilities [{:msg "lose [Click] and look at the top card of R&D"
              :once :per-turn
              :effect (effect (prompt! card (str "The top card of R&D is "
                                                 (:title (first (:deck corp)))) ["OK"] {}))}]
 :events {:runner-turn-begins {:req (req (get-in @state [:per-turn (:cid card)]))
                               :effect (effect (lose :click 1))}}}

{:events {:runner-turn-ends
          {:effect (req (let [ab (if (get-in @state [:runner :register :successful-run])
                                   {:effect (effect (gain :credit 1)) :msg "gain 1 [Credits]"}
                                   {:effect (effect (trash card)) :msg "trash Grifter"})]
                          (resolve-ability state side ab card targets)))}}}

{:events {:pre-damage
          {:req (req (or (= target :meat) (= target :net)))
           :msg (msg "prevent all " (if (= target :meat) "meat" "net") " damage")
           :effect (req (damage-prevent state side :meat Integer/MAX_VALUE)
                        (damage-prevent state side :net Integer/MAX_VALUE)
                        (if (< (:credit runner) 4)
                          (trash state side card)
                          (resolve-ability
                            state :runner
                            {:optional
                             {:prompt "Pay 4 [Credits] to prevent trashing Guru Davinder?"
                              :player :runner
                              :yes-ability {:effect (effect (lose :runner :credit 4)
                                                            (system-msg (str "pays 4 [Credits] to prevent Guru Davinder "
                                                                             "from being trashed")))}
                              :no-ability {:effect (effect (trash card))}}}
                           card nil)))}}}

{:abilities [{:msg "access all cards in Archives"
              :effect (req (trash state side card {:cause :ability-cost})
                           (swap! state update-in [:corp :discard] #(map (fn [c] (assoc c :seen true)) %))
                           (when (:run @state)
                             (swap! state update-in [:run :cards-accessed] (fnil #(+ % (count (:discard corp))) 0)))
                           (resolve-ability state :runner (choose-access (get-in @state [:corp :discard]) '(:archives)) card nil))}]
 :install-cost-bonus (req (if (and run (= (:server run) [:archives]) (= 0 (:position run)))
                            [:credit -7 :click -1] nil))
 :effect (req (when (and run (= (:server run) [:archives]) (= 0 (:position run)))
                (when-completed (register-successful-run state side (:server run))
                                (do (swap! state update-in [:runner :prompt] rest)
                                    (handle-end-run state side)))))}

(let [ability {:msg "gain 2 [Credits] and lose [Click]"
               :once :per-turn
               :effect (effect (lose :click 1) (gain :credit 2))}]
{:flags {:drip-economy true}
 :events {:runner-turn-begins ability}
 :abilities [ability]})

{:events {:agenda-scored {:msg (msg "gain " (get-agenda-points state :corp target) " [Credits]")
                          :effect (effect (gain :runner :credit (get-agenda-points state :corp target)))}
          :agenda-stolen {:msg (msg "gain " (get-agenda-points state :runner target) " [Credits]")
                          :effect (effect (gain :credit (get-agenda-points state :runner target)))}}}

{:abilities [{:label "Prevent a \"when encountered\" ability on a piece of ICE"
              :msg "prevent a \"when encountered\" ability on a piece of ICE"
              :once :per-turn}
              {:label "[Trash]: Install the top 3 cards of your Stack facedown"
               :msg "install the top 3 cards of their Stack facedown"
               :effect (req (trash state side card {:cause :ability-cost})
                            (doseq [c (take 3 (get-in @state [:runner :deck]))]
                              (runner-install state side c {:facedown true})))}]}

{:implementation "Credit use restriction is not enforced"
 :events {:rez {:req (req (ice? target))
                :msg "place 1 [Credits] on Ice Analyzer"
                :effect (effect (add-counter :runner card :credit 1))}}
 :abilities [{:counter-cost [:credit 1]
              :effect (effect (gain :credit 1))
              :msg "take 1 [Credits] to install programs"}]}

{:events {:pre-ice-strength
          {:req (req (and (= (:cid target) (:cid current-ice)) (:rezzed target)))
           :effect (effect (ice-strength-bonus -1 target))}}}

{:recurring 2}

{:req (req has-bad-pub)
 :abilities [{:cost [:click 4] :msg "give the Corp 1 bad publicity"
              :effect (effect (gain :corp :bad-publicity 1) (trash card {:cause :ability-cost}))}]}

(let [ability {:label "Make a run (start of turn)"
               :prompt "Choose a server to run with Jak Sinclair"
               :once :per-turn
               :choices (req runnable-servers)
               :msg (msg "make a run on " target " during which no programs can be used")
               :makes-run true
               :effect (effect (run target))}]
{:implementation "Doesn't prevent program use"
 :flags {:runner-phase-12 (req true)}
 :install-cost-bonus (req [:credit (* -1 (:link runner))])
 :events {:runner-turn-begins
           {:optional {:req (req (not (get-in @state [:per-turn (:cid card)])))
                       :prompt "Use Jak Sinclair to make a run?"
                       :yes-ability ability}}}
 :abilities [ability]})

{:events {:successful-run {:req (req (first-event? state side :successful-run))
                           :msg "draw 1 card" :once-key :john-masanori-draw
                           :effect (effect (draw))}
          :unsuccessful-run {:req (req (first-event? state side :unsuccessful-run))
                             :delayed-completion true
                             :msg "take 1 tag" :once-key :john-masanori-tag
                             :effect (effect (tag-runner :runner eid 1))}}}

(let [ability {:msg "gain [Click]"
               :once :per-turn
               :label "Gain [Click] (start of turn)"
               :effect (effect (gain :click 1))
               :end-turn {:delayed-completion true
                          :effect (effect (tag-runner eid 1))
                          :msg "gain 1 tag"}}]
{:events {:runner-turn-begins
          {:optional {:prompt "Use Joshua B. to gain [Click]?"
                      :once :per-turn
                      :yes-ability ability}}}
 :abilities [ability]})

{:abilities [{:cost [:click 1]
              :msg "store 3 [Credits]"
              :once :per-turn
              :effect (effect (add-counter card :credit 3))}
             {:cost [:click 1]
              :msg (msg "gain " (get-in card [:counter :credit] 0) " [Credits]")
              :once :per-turn
              :label "Take all credits"
              :effect (req (gain state side :credit (get-in card [:counter :credit] 0))
                           (add-counter state side card :credit (- (get-in card [:counter :credit] 0))))}]}

{:data {:counter {:credit 16}}
 :abilities [{:cost [:click 1]
              :counter-cost [:credit 4]
              :msg "gain 4 [Credits]"
              :effect (req (gain state :runner :credit 4)
                           (when (<= (get-in card [:counter :credit] 0) 0)
                             (trash state :runner card {:unpreventable true})))}]}

{:abilities [{:cost [:click 5 :forfeit]
              :msg "add it to their score area"
              :effect (req (if (not (empty? (:scored corp)))
                             (do (show-wait-prompt state :runner "Corp to decide whether or not to prevent Liberated Chela")
                                 (resolve-ability
                                   state side
                                   {:prompt (msg "Forfeit an agenda to prevent Liberated Chela from being added to Runner's score area?")
                                    :choices ["Yes" "No"] :player :corp
                                    :effect (final-effect (resolve-ability
                                                            (if (= target "Yes")
                                                              {:prompt "Choose an agenda to forfeit" :player :corp
                                                               :choices {:req #(in-corp-scored? state side %)}
                                                               :effect (effect (forfeit target)
                                                                               (move :runner card :rfg)
                                                                               (clear-wait-prompt :runner))}
                                                              {:effect (effect (as-agenda :runner card 2)
                                                                               (clear-wait-prompt :runner))
                                                               :msg "add it to their score area as an agenda worth 2 points"})
                                                           card nil))} card nil))
                             (resolve-ability
                               state side
                               {:effect (effect (as-agenda :runner card 2))
                                :msg "add it to their score area as an agenda worth 2 points"} card nil)))}]}

{:abilities [{:label "Install a non-virus program on London Library"
              :cost [:click 1]
              :prompt "Choose a non-virus program to install on London Library from your grip"
              :choices {:req #(and (is-type? % "Program")
                                   (not (has-subtype? % "Virus"))
                                   (in-hand? %))}
              :msg (msg "host " (:title target))
              :effect (effect (runner-install target {:host-card card :no-cost true}))}
             {:label "Add a program hosted on London Library to your Grip"
              :cost [:click 1]
              :choices {:req #(:host %)}
              :msg (msg "add " (:title target) " to their Grip")
              :effect (effect (move target :hand))}]
 :events {:runner-turn-ends {:effect (req (doseq [c (:hosted card)]
                                            (when (is-type? c "Program")
                                              (trash state side c))))}}}

(let [ability {:msg "look at the top card of their Stack"
               :label "Look at the top card of Stack (start of turn)"
               :once :per-turn
               :req (req (:runner-phase-12 @state))
               :effect (effect (prompt! card (str "The top card of your Stack is "
                                                  (:title (first (:deck runner)))) ["OK"] {}))}]
{:flags {:runner-turn-draw true
         :runner-phase-12 (req (some #(card-flag? % :runner-turn-draw true) (all-installed state :runner)))}
 :events {:runner-turn-begins ability}
 :abilities [ability]})

{:abilities [{:cost [:click 1]
              :msg (msg "draw 2 cards")
              :effect (req (draw state side 2)
                           (let [drawn (get-in @state [:runner :register :most-recent-drawn])]
                             (resolve-ability
                               state side
                               {:prompt (str "Choose 1 card to add to the bottom of the Stack")
                                :msg (msg "add 1 card to the bottom of the Stack")
                                :choices {:req #(and (in-hand? %)
                                                     (some (fn [c] (= (:cid c) (:cid %))) drawn))}
                                :effect (req (move state side target :deck))} card nil)))}]}

{:effect (req (resolve-ability
                state :corp
                {:prompt "Choose a card to derez"
                 :choices {:req #(and (= (:side %) "Corp") (:rezzed %))}
                 :effect (req (derez state side target))}
               card nil))
 :leave-play (req (resolve-ability
                    state :corp
                    {:prompt "Choose a card to rez, ignoring the rez cost"
                     :choices {:req #(not (:rezzed %))}
                     :effect (req (rez state side target {:ignore-cost :rez-cost})
                                  (system-msg state side (str "rezzes " (:title target) " at no cost")))}
                   card nil))
 :abilities [{:msg "draw 1 card"
              :effect (effect (trash card {:cause :ability-cost}) (draw))}]}

{:abilities [{:counter-cost [:credit 1]
              :msg "gain 1 [Credits]"
              :effect (effect (gain :credit 1)
                              (trigger-event :spent-stealth-credit card))}]
 :events {:spent-stealth-credit
          {:req (req (and (:run @state)
                          (has-subtype? target "Stealth")))
           :once :per-run
           :delayed-completion true
           :effect (effect (show-wait-prompt :corp "Runner to use Net Mercur")
                           (continue-ability
                             {:prompt "Place 1 [Credits] on Net Mercur or draw 1 card?"
                              :player :runner
                              :choices ["Place 1 [Credits]" "Draw 1 card"]
                              :effect (req (if (= target "Draw 1 card")
                                             (do (draw state side)
                                                 (clear-wait-prompt state :corp)
                                                 (system-msg state :runner (str "uses Net Mercur to draw 1 card")))
                                             (do (add-counter state :runner card :credit 1)
                                                 (clear-wait-prompt state :corp)
                                                 (system-msg state :runner (str "places 1 [Credits] on Net Mercur")))))}
                            card nil))}}}