Icebreakers

(deva "Aghora")

(auto-icebreaker ["All"]
                 {:abilities [{:cost [:credit 1]
                               :req (req (= (:position run) (count run-ices)))
                               :msg "break 1 subroutine on the outermost ICE protecting this server"}
                              (strength-pump 1 1)]})

(central-breaker "Sentry"
                 (break-sub 1 1 "sentry")
                 (strength-pump 2 3))

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 2 1 "barrier")
                              (strength-pump 1 1)
                              {:label "Add barrier to HQ"
                               :req (req (and (has-subtype? current-ice "Barrier")
                                              (rezzed? current-ice)))
                               :msg (msg "add " (:title current-ice) " to HQ after breaking all its subroutines")
                               :effect (req (let [c current-ice]
                                              (move state :corp c :hand nil)
                                              (continue state side nil)))}]})

{:prompt "How many power counters?"
 :choices :credit
 :msg (msg "add " target " power counters")
 :effect (effect (add-counter card :power target))
 :abilities [(break-sub 1 1)]
 :strength-bonus (req (get-in card [:counter :power] 0))
 :events {:counter-added {:req (req (= :cid target) (:cid card))
                          :effect (effect (update-breaker-strength card))}}}

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 2 1 "barrier")
                              (strength-pump 2 3)]})

(let [host-click {:cost [:click 1]
                  :label "Install a non-AI icebreaker on Baba Yaga"
                  :prompt "Choose a non-AI icebreaker in your Grip to install on Baba Yaga"
                  :choices {:req #(and (has-subtype? % "Icebreaker")
                                       (not (has-subtype? % "AI"))
                                       (in-hand? %))}
                  :effect (effect (runner-install target {:host-card card}))}
      host-free {:label "Host an installed non-AI icebreaker on Baba Yaga"
                 :prompt "Choose an installed non-AI icebreaker to host on Baba Yaga"
                 :choices {:req #(and (has-subtype? % "Icebreaker")
                                      (not (has-subtype? % "AI"))
                                      (installed? %))}
                 :effect (req (when (host state side card target)
                                (gain :memory (:memoryunits target))))}
      gain-abis (req (let [new-abis (mapcat (fn [c] (map-indexed #(assoc %2 :dynamic :copy, :source (:title c)
                                                                            :index %1, :label (make-label %2))
                                                                 (filter #(not= :manual-state (:ability-type %))
                                                                         (:abilities (card-def c)))))
                                            (:hosted card))]
                       (update! state :runner (assoc card :abilities (concat new-abis [host-click host-free])))))]
{:abilities [host-click host-free]
 :hosted-gained gain-abis
 :hosted-lost gain-abis})

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 2 2 "barrier")
                              (strength-pump 1 1 :all-run)]})

{:implementation "Stealth credit restriction not enforced"
 :abilities [(break-sub 1 1 "barrier")
             {:cost [:credit 1]
              :msg "break up to 3 barrier subroutines (using a stealth [Credits])"}
             (strength-pump 2 1)
             {:cost [:credit 2]
              :msg "add 2 strength (using at least 1 stealth [Credits])"
              :effect (effect (pump card 2)) :pump 2}]}

(conspiracy "Black Orchestra" "Code Gate"
            [{:cost [:credit 3]
              :effect (effect (pump card 2)) :pump 2
              :msg "add 2 strength and break up to 2 subroutines"}])

{:abilities [(break-sub 1 1 "barrier")
             {:cost [:credit 3]
              :msg "add 4 strength (using at least 1 stealth [Credits])"
              :effect (effect (pump card 4 :all-run)) :pump 4}]}

(auto-icebreaker ["All"]
                 {:implementation "Adding non-virus program to top of Stack is manual"
                  :abilities [(break-sub 1 2 "ICE")
                              (strength-pump 2 1)]})

(central-breaker "Barrier"
                 (break-sub 2 3 "barrier")
                 (strength-pump 2 4))

(cerberus "Sentry")

(cerberus "Code Gate")

(cerberus "Barrier")

{:prompt "Choose one subtype"
 :choices ["Barrier" "Code Gate" "Sentry"]
 :msg (msg "choose " target)
 :effect (effect (update! (assoc card :subtype-target target)))
 :events {:runner-turn-ends {:msg "add itself to Grip" :effect (effect (move card :hand))}}
 :abilities [{:cost [:credit 1] :msg (msg "break 1 " (:subtype-target card) " subroutine")}]}

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 1 1 "barrier")
                              (strength-pump 1 1)]})

(cloud-icebreaker
  (auto-icebreaker ["Sentry"]
                   {:abilities [(break-sub 2 1 "sentry")
                                (strength-pump 1 1)]}))

(break-and-enter "Code Gate")

(auto-icebreaker ["All"]
                 {:abilities [(break-sub 1 1 "ICE" (effect (update! (assoc card :crypsis-broke true))))
                              (strength-pump 1 1)
                              {:cost [:click 1]
                               :msg "place 1 virus counter"
                               :effect (effect (add-counter card :virus 1))}]
                  :events (let [encounter-ends-effect {:req (req (:crypsis-broke card))
                                                       :effect (req ((:effect breaker-auto-pump) state side eid card targets)
                                                                    (if (pos? (get-in card [:counter :virus] 0))
                                                                      (add-counter state side card :virus -1)
                                                                      (trash state side card {:cause :self-trash}))
                                                                    (update! state side (dissoc (get-card state card) :crypsis-broke)))}]
                            {:pass-ice encounter-ends-effect
                             :run-ends encounter-ends-effect})})

(auto-icebreaker ["Code Gate"]
                 {:prompt "Choose a server where this copy of Cyber-Cypher can be used:"
                  :msg (msg "target " target)
                  :choices (req servers)
                  :effect (effect (update! (assoc card :server-target target)))
                  :leave-play (effect (update! (dissoc card :server-target)))
                  :abilities [(break-sub 1 1 "code gate")
                              (strength-pump 1 1)]})

(auto-icebreaker ["Sentry"]
                 {:implementation "Stealth credit restriction not enforced"
                  :abilities [(break-sub 1 1 "sentry")
                              (strength-pump 1 5)]})

(auto-icebreaker ["All"]
                 {:implementation "Stealth credit restriction not enforced"
                  :abilities [{:cost [:credit 2]
                               :msg "break all ICE subroutines (using stealth [Credits])"}
                              (strength-pump 1 1)]})

{:flags {:runner-phase-12 (req true)}
 :events {:purge {:effect (effect (update-breaker-strength card))}}
 :abilities [(break-sub 2 1 "ICE")
             {:label "Place 1 virus counter (start of turn)"
              :cost [:credit 1]
              :msg "place 1 virus counter"
              :req (req (:runner-phase-12 @state))
              :effect (effect (add-counter card :virus 1)
                              (update-breaker-strength card))}]
 :strength-bonus (req (or (get-virus-counters state side card) 0))}

{:prevent {:damage [:net]}
 :abilities [{:msg "break any number of AP subroutines"
              :effect (effect (trash card {:cause :ability-cost}))}
             {:msg "prevent any amount of net damage"
              :effect (effect (trash card {:cause :ability-cost})
                              (damage-prevent :net Integer/MAX_VALUE))}]}

(auto-icebreaker ["All"]
                 {:abilities [{:cost [:credit 1]
                               :msg "break ICE subroutine and access 0 cards this run"
                               :effect (effect (max-access 0))}
                              (strength-pump 1 1)]})

{:abilities [{:label "Trash 1 installed card to break 1 \"End the run.\" subroutine"
              :prompt "Choose a card to trash for Endless Hunger"
              :choices {:req #(and (= (:side %) "Runner") (:installed %))}
              :msg (msg "trash " (:title target)
                        " and break 1 \"[Subroutine] End the run.\" subroutine")
              :effect (effect (trash target {:unpreventable true}))}]}

(auto-icebreaker ["Sentry"]
                 {:abilities [(break-sub 0 1 "sentry" (effect (update! (assoc card :faerie-used true))))
                              (strength-pump 1 1)]
                  :events {:pass-ice {:req (req (:faerie-used card))
                                      :effect (effect (trash (dissoc card :faerie-used)))}}})

{:abilities [{:label "Trash 1 card from Grip to break 1 subroutine"
              :prompt "Choose a card from your grip to trash for Faust"
              :choices {:req in-hand?}
              :msg (msg "trash " (:title target) " and break 1 subroutine")
              :effect (effect (trash target {:unpreventable true}))}
             {:label "Trash 1 card from Grip to add 2 strength"
              :prompt "Choose a card from your grip to trash for Faust"
              :choices {:req in-hand?}
              :msg (msg "trash " (:title target) " and add 2 strength")
              :effect (effect (trash target {:unpreventable true}) (pump card 2))}]}

{:implementation "Stealth credit restriction not enforced"
 :abilities [(break-sub 1 1 "sentry")
             {:label (str "X [Credits]: +X strength for the remainder of the run (using at least 1 stealth [Credits])")
              :choices :credit
              :prompt "How many credits?"
              :effect (effect (pump card target :all-run))
              :msg (msg "increase strength by " target " for the remainder of the run")}]}

(auto-icebreaker ["Sentry"]
                 {:prompt "Choose a piece of ICE to target for bypassing"
                  :choices {:req ice?}
                  :leave-play (req (remove-icon state side card))
                  :effect (req (let [ice target
                                     serv (zone->name (second (:zone ice)))]
                                 (add-icon state side card ice "F" "blue")
                                 (system-msg state side
                                             (str "chooses " (card-str state ice)
                                                  " for Femme Fatale's bypass ability"))))
                  :abilities [(break-sub 1 1 "sentry")
                              (strength-pump 2 1)]})

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 2 2 "code gate")
                              (strength-pump 1 1)]})

(auto-icebreaker ["Sentry"]
                 {:abilities [(break-sub 1 1 "sentry")
                              (strength-pump 1 1)]})

(auto-icebreaker ["Sentry"]
                 {:abilities [(break-sub 2 2 "sentry")
                              (strength-pump 2 4)
                              {:label "Derez a sentry and return Golden to your Grip"
                               :cost [:credit 2]
                               :req (req (and (rezzed? current-ice) (has-subtype? current-ice "Sentry")))
                               :msg (msg "derez " (:title current-ice) " and return Golden to their Grip")
                               :effect (effect (derez current-ice)
                                               (move card :hand))}]})

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 1 1 "code gate")
                              (strength-pump 1 1 :all-run)]})

(auto-icebreaker ["Tracer"]
                 {:abilities [(break-sub 1 1 "tracer")
                              (strength-pump 2 3)]})

(global-sec-breaker "Barrier")

(global-sec-breaker "Sentry")

(global-sec-breaker "Code Gate")

{:abilities [(break-sub 1 1 "code gate")
             {:cost [:credit 2]
              :msg "add 4 strength (using at least 1 stealth [Credits])"
              :effect (effect (pump card 4 :all-run)) :pump 4}]}

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 1 1 "barrier")
                              (strength-pump 2 1 :all-run)]})

{:abilities [{:cost [:click 1] :label "Host Knight on a piece of ICE"
              :effect (req (let [k (get-card state card)
                                 hosted (ice? (:host k))
                                 icepos (ice-index state (get-card state (:host k)))]
                             (resolve-ability state side
                              {:prompt (msg "Host Knight on a piece of ICE" (when hosted " not before or after the current host ICE"))
                               :choices {:req #(if hosted
                                                 (and (or (when (= (:zone %) (:zone (:host k)))
                                                            (not= 1 (abs (- (ice-index state %) icepos))))
                                                          (not= (:zone %) (:zone (:host k))))
                                                      (ice? %)
                                                      (installed? %)
                                                      (not (some (fn [c] (has? c :subtype "Caïssa")) (:hosted %))))
                                                 (and (ice? %)
                                                      (installed? %)
                                                      (not (some (fn [c] (has? c :subtype "Caïssa")) (:hosted %)))))}
                               :msg (msg "host it on " (card-str state target))
                               :effect (effect (host target card))} card nil)))}
             {:cost [:credit 2] :msg "break 1 subroutine on the host ICE"}]}

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 3 3 "code gate")
                              (strength-pump 3 5)]})

{:abilities [(break-sub 1 0 "barrier")]}

{:abilities [(break-sub 1 1 "sentry")]}

(auto-icebreaker ["Sentry"]
                 {:implementation "Usage restriction is not implemented"
                  :abilities [(break-sub 1 2 "sentry")
                              (strength-pump 2 2)]})

(conspiracy "MKUltra" "Sentry"
            [{:cost [:credit 3]
              :effect (effect (pump card 2)) :pump 2
              :msg "add 2 strength and break up to 2 subroutines"}])

{:implementation "Adding power counter is manual"
 :abilities [{:label "Place 1 power counter on Nfr"
              :msg "place 1 power counter on it"
              :ability-type :manual-state
              :effect (effect (add-counter card :power 1)
                              (update-breaker-strength card))}
             (break-sub 1 1 "barrier")]
 :strength-bonus (req (get-in card [:counter :power] 0))}

(auto-icebreaker ["Sentry"]
                 {:abilities [(break-sub 1 1 "sentry")
                              (strength-pump 3 5)]})

(auto-icebreaker ["All"]
                 {:abilities [{:cost [:credit 1] :req (req (= 1 (:position run)))
                               :msg "break 1 subroutine on the innermost ICE protecting this server"}
                              (strength-pump 1 1)]})

(auto-icebreaker ["All"]
                 {:effect (effect (add-counter card :power (:memory runner)))
                  :abilities [{:counter-cost [:power 1]
                               :msg "break 1 subroutine"}
                              (strength-pump 1 1)]})

(conspiracy "Paperclip" "Barrier"
            [{:label (str "X [Credits]: +X strength, break X subroutines")
              :choices :credit
              :prompt "How many credits?"
              :effect (effect (pump card target))
              :msg (msg "increase strength by " target " and break " target " barrier subroutine"
                        (when (not= target 1) "s"))}])

(central-breaker "Code Gate"
                 (break-sub 1 1 "code gate")
                 (strength-pump 2 2))

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 2 1 "code gate")
                              (strength-pump 2 3)]})

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 1 1 "code gate")
                              (strength-pump 3 3)
                              {:label "Derez a code gate and return Peregrine to your Grip"
                               :cost [:credit 2]
                               :req (req (and (rezzed? current-ice) (has-subtype? current-ice "Code Gate")))
                               :msg (msg "derez " (:title current-ice) " and return Peregrine to their Grip")
                               :effect (effect (derez current-ice)
                                               (move card :hand))}]})

(auto-icebreaker ["Sentry"]
                 {:abilities [(break-sub 1 1 "sentry")
                              (strength-pump 2 1 :all-run)]})

(auto-icebreaker ["Code Gate"]
                 {:implementation "Stealth credit restriction not enforced"
                  :abilities [(break-sub 1 1 "code gate")
                              (strength-pump 1 3)]})

(deva "Sadyojata")

{:abilities [{:cost [:credit 2] :req (req (or (has-subtype? current-ice "Barrier")
                                              (has-subtype? current-ice "Code Gate")))
              :msg "break 1 code gate or barrier subroutine"}]
 :effect (req (add-watch state (keyword (str "sage" (:cid card)))
                         (fn [k ref old new]
                           (when (not= (get-in old [:runner :memory]) (get-in new [:runner :memory]))
                             (update-breaker-strength ref side card))))
              (update-breaker-strength state side card))
 :leave-play (req (remove-watch state (keyword (str "sage" (:cid card)))))
 :strength-bonus (req (:memory runner))}

(auto-icebreaker ["Barrier"]
                 {:abilities [(break-sub 1 1 "barrier")
                              (strength-pump 2 2)
                              {:label "Derez a barrier and return Saker to your Grip"
                               :cost [:credit 2]
                               :req (req (and (rezzed? current-ice) (has-subtype? current-ice "Barrier")))
                               :msg (msg "derez " (:title current-ice) " and return Saker to their Grip")
                               :effect (effect (derez current-ice)
                                               (move card :hand))}]})

(auto-icebreaker ["Barrier"]
                 {:abilities [{:cost [:credit 1] :msg "break 1 barrier subroutine"
                               :effect (effect (pump card 1 :all-run))}
                              (strength-pump 1 1)]})

(auto-icebreaker ["Destroyer"]
                 {:abilities [{:label "[Trash]: Break any number of destroyer subroutines"
                               :msg "break any number of destroyer subroutines"
                               :effect (effect (trash card {:cause :ability-cost}))}
                              (strength-pump 1 2)]})

(break-and-enter "Sentry")

(break-and-enter "Barrier")

{:abilities [(break-sub 1 1 "code gate")
             {:cost [:credit 2] :msg "place 1 power counter"
              :effect (effect (add-counter card :power 1)
                              (update-breaker-strength card))}]
 :strength-bonus (req (get-in card [:counter :power] 0))}

{:implementation "Adding power counter is manual"
 :abilities [{:label "Place 1 power counter on Sūnya"
              :ability-type :manual-state
              :effect (effect (add-counter card :power 1)
                              (system-msg (str "places 1 power counter on Sūnya"))
                              (update-breaker-strength card))}
             (break-sub 2 1 "sentry")]
 :strength-bonus (req (get-in card [:counter :power] 0))}

(auto-icebreaker ["Sentry"]
                 {:implementation "Stealth credit restriction not enforced"
                  :abilities [(break-sub 1 0 "sentry")
                              (strength-pump 1 7)]})

(auto-icebreaker ["Code Gate"]
                 {:abilities [(break-sub 1 1 "code gate")
                              (strength-pump 1 1)]})

(deva "Vamadeva")

(auto-icebreaker ["All"]
                 {:abilities [{:cost [:credit 3]
                               :msg "break 1 subroutine on ICE with 0 or less strength"}
                              {:cost [:credit 1]
                               :label "Give -1 strength to current ice"
                               :req (req current-ice)
                               :msg (msg "give -1 strength to " (:title current-ice))
                               :effect (effect (update! (update-in card [:wyrm-count] (fnil inc 0)))
                                               (update-ice-strength current-ice))}
                              (strength-pump 1 1)]
                  :events (let [auto-pump (fn [state side eid card targets]
                                            ((:effect breaker-auto-pump) state side eid card targets))
                                wy {:effect (effect (update! (dissoc card :wyrm-count))
                                                    (auto-pump eid card targets))}]
                            {:pre-ice-strength {:req (req (and (= (:cid target) (:cid current-ice))
                                                               (:wyrm-count card)))
                                                :effect (effect (ice-strength-bonus (- (:wyrm-count (get-card state card))) target)
                                                                (auto-pump eid card targets))}
                             :pass-ice wy
                             :run-ends wy})})

{:abilities [(break-sub 0 1 "code gate")]}

(cloud-icebreaker
  (auto-icebreaker ["Code Gate"]
                   {:abilities [(break-sub 1 1 "code gate")
                                (strength-pump 1 1)]}))