Merge pull request #6422 from NoahTheDuke/nb/midnight-sun-spoilers

Week 1 Midnight Sun spoilers

Author: NoahTheDuke

src/clj/game/cards/agendas.clj

@@ -196,6 +196,12 @@
                                    :duration :end-of-run
                                    :value [:trash-from-hand 1]}))}]})
 
+(defcard "Artificial Cryptocrash"
+  {:on-score
+   {:async true
+    :msg "make the Runner lose 7 [Credits]"
+    :effect (effect (lose-credits :runner eid 7))}})
+
 (defcard "AstroScript Pilot Program"
   {:on-score {:effect (effect (add-counter card :agenda 1))
               :silent (req true)}
@@ -1057,6 +1063,17 @@
                              (do (system-msg state side "does not use Meteor Mining")
                                  (effect-completed state side eid))))}})
 
+(defcard "Midnight-3 Arcology"
+  {:on-score {:async true
+              :msg "Draw 3 cards and skip their discard step this turn"
+              :effect (effect
+                        (register-floating-effect
+                          card
+                          {:type :skip-discard
+                           :duration :end-of-turn
+                           :value true})
+                        (draw :corp eid 3))}})
+
 (defcard "NAPD Contract"
   {:steal-cost-bonus (req [:credit 4])
    :advancement-requirement (req (count-bad-pub state))})

src/clj/game/cards/assets.clj

@@ -1794,6 +1794,16 @@
                                                (effect-completed eid))})
                             card nil))}]})
 
+(defcard "Refuge Campaign"
+  (let [ability {:msg "gain 2 [Credits]"
+                 :label "Gain 2 [Credits] (start of turn)"
+                 :once :per-turn
+                 :async true
+                 :effect (effect (gain-credits eid 2))}]
+    {:derezzed-events [corp-rez-toast]
+     :events [(assoc ability :event :corp-turn-begins)]
+     :abilities [ability]}))
+
 (defcard "Regolith Mining License"
   {:data {:counter {:credit 15}}
    :events [(trash-on-empty :credit)]
@@ -2115,6 +2125,23 @@
                             (gain-credits state :corp eid 2)
                             (effect-completed state side eid)))}]})
 
+(defcard "Svyatogor Excavator"
+  (let [ability {:async true
+                 :label "trash a card to gain 3 [Credits]"
+                 :once :per-turn
+                 :req (req (>= (count (all-installed state :corp)) 2))
+                 :choices {:req (req (and (corp? target)
+                                          (installed? target)
+                                          (not (same-card? target card))))}
+                 :msg (msg "trash " (:title target) " and gain 3 [Credits]")
+                 :effect (req (wait-for (trash state side target {:unpreventable true :cause-card card})
+                                        (gain-credits state side eid 3)))}]
+    {:flags {:corp-phase-12 (req (>= (count (all-installed state :corp)) 2))}
+     :events [(assoc ability
+                     :event :corp-turn-begins
+                     :interactive (req true))]
+     :abilities [ability]}))
+
 (defcard "Synth DNA Modification"
   {:implementation "Manual fire once subroutine is broken"
    :abilities [{:msg "do 1 net damage"
@@ -2260,12 +2287,46 @@
                       moved-card nil)))}
     "Swap Toshiyuki Sakai with an agenda or asset from HQ?"))
 
+(defcard "Trieste Model Bioroids"
+  {:on-rez {:msg (msg "prevent " (card-str state target)
+                      " from being broken by runner card abilities")
+            :choices {:card #(and (ice? %)
+                                  (rezzed? %)
+                                  (has-subtype? % "Bioroid"))}
+            :effect (effect (add-icon card target "T" "red")
+                            (update! (assoc-in (get-card state card) [:special :trieste-target] target)))}
+   :leave-play (effect (remove-icon card))
+   :constant-effects [{:type :prevent-paid-ability
+                       :req (req
+                              (let [[break-card break-ability] targets]
+                                (and
+                                  (same-card? current-ice (get-in card [:special :trieste-target]))
+                                  (runner? break-card)
+                                  (or (not (identity? break-card))
+                                      (fake-identity? break-card))
+                                  (or (contains? break-ability :break)
+                                      (contains? break-ability :breaks)
+                                      (contains? break-ability :heap-breaker-break)
+                                      (contains? break-ability :break-cost)))))
+                       :value true}]})
+
 (defcard "Turtlebacks"
   {:events [{:event :server-created
              :msg "gain 1 [Credits]"
              :async true
              :effect (effect (gain-credits eid 1))}]})
 
+(defcard "Ubiquitous Vig"
+  (let [ability {:msg (msg "gain " (get-counters card :advancement)  " [Credits]")
+                 :label "Gain 1 [Credits] for each advancement counter (start of turn)"
+                 :once :per-turn
+                 :async true
+                 :effect (effect (gain-credits eid (get-counters card :advancement)))}]
+    {:derezzed-events [corp-rez-toast]
+     :advanceable :always
+     :events [(assoc ability :event :corp-turn-begins)]
+     :abilities [ability]}))
+
 (defcard "Urban Renewal"
   {:on-rez {:effect (effect (add-counter card :power 3))}
    :derezzed-events [corp-rez-toast]

src/clj/game/cards/events.clj

@@ -394,6 +394,17 @@
                                   (cbi-choice from '() (count from) from)))
                               card nil))}})]}))
 
+(defcard "Chastushka"
+  {:makes-run true
+   :on-play {:req (req hq-runnable)
+             :async true
+             :effect (effect (make-run eid :hq card))}
+   :events [(successful-run-replace-breach
+              {:target-server :hq
+               :this-card-run true
+               :mandatory true
+               :ability (sabotage-ability 4)})]})
+
 (defcard "Code Siphon"
   (letfn [(rd-ice [state]
             (* -3 (count (get-in @state [:corp :servers :rd :ices]))))]
@@ -2659,6 +2670,28 @@
                          choices (map str valid-amounts)]
                      (continue-ability state side (runner-choice choices) card nil)))}}))
 
+(defcard "Rigging Up"
+  {:on-play
+   {:prompt "Choose a program or piece of hardware to install from your Grip"
+    :choices {:req (req (and (or (hardware? target)
+                                 (program? target))
+                             (in-hand? target)
+                             (can-pay? state side (assoc eid :source card :source-type :runner-install) target nil
+                                       [:credit (install-cost state side target {:cost-bonus -3})])))}
+    :async true
+    :effect (req (wait-for (runner-install state side (make-eid state {:source card :source-type :runner-install}) target {:cost-bonus -3})
+                           (let [rig-target async-result]
+                             (continue-ability
+                               state side
+                               {:optional
+                                {:prompt (str "Charge " (:title rig-target) "?")
+                                 :req (req (can-charge state side rig-target))
+                                 :yes-ability
+                                 {:async true
+                                  :effect (effect (charge-card eid rig-target))
+                                  :msg (msg "charge " (:title rig-target))}}}
+                               card nil))))}})
+
 (defcard "Rip Deal"
   (let [add-cards-from-heap
         {:optional
@@ -2752,6 +2785,14 @@
                                    :effect (effect (trash eid target {:cause-card card}))})
                                 card nil)))}]}))
 
+(defcard "Running Hot"
+  {:on-play
+   {:msg "gain [Click][Click][Click]"
+    :additional-cost [:brain 1]
+    :async true
+    :effect (effect (gain-clicks 3)
+                    (effect-completed eid))}})
+
 (defcard "Running Interference"
   {:makes-run true
    :on-play {:prompt "Choose a server"
@@ -2925,6 +2966,18 @@
                               :effect (effect (make-run eid target))}
                              card nil)))}})
 
+(defcard "Steelskin Scarring"
+  {:on-play {:async true
+             :effect (effect (draw eid 3))}
+   :on-trash {:when-inactive true
+              :interactive (req true)
+              :async true
+              :req (req (let [zone (first (:zone (:card context)))]
+                          (or (= :hand zone)
+                              (= :deck zone))))
+              :msg "draw 2 cards"
+              :effect (effect (draw :runner eid 2))}})
+
 (defcard "Stimhack"
   {:makes-run true
    :on-play {:prompt "Choose a server"

src/clj/game/cards/hardware.clj

@@ -605,6 +605,17 @@
                                                      (toast state :corp "Cannot rez ice the rest of this run due to EMP Device"))
                                                     true))))}]))}]})
 
+(defcard "Endurance"
+  {:data {:counter {:power 3}}
+   :constant-effects [(mu+ 2)]
+   :events [{:event :successful-run
+             :req (req (first-event? state :runner :successful-run))
+             :silent (req true)
+             :msg "place 1 power counter on itself"
+             :async true
+             :effect (effect (add-counter eid card :power 1 nil))}]
+   :abilities [(break-sub [:power 2] 2 "All")]})
+
 (defcard "Feedback Filter"
   {:interactions {:prevent [{:type #{:net :brain}
                              :req (req true)}]}
@@ -1056,6 +1067,16 @@
                                                             " power counters on Mâché"))
                                 (add-counter state side card :power cost))))}]}))
 
+(defcard "Marrow"
+  {:constant-effects [(mu+ 1)
+                      (runner-hand-size+ 3)]
+   :on-install {:async true
+                :effect (effect (damage eid :brain 1 {:card card}))}
+   :events [{:event :agenda-scored
+             :async true
+             :interactive (req true)
+             :effect (effect (continue-ability (sabotage-ability 1) card nil))}]})
+
 (defcard "Masterwork (v37)"
   {:constant-effects [(mu+ 1)]
    :events [{:event :run
@@ -2048,6 +2069,32 @@
      :events [(assoc ability :event :runner-turn-begins)]
      :abilities [ability]}))
 
+(defcard "Virtuoso"
+  {:constant-effects [(mu+ 1)]
+   :events [(assoc identify-mark-ability :event :runner-turn-begins)
+            {:event :successful-run
+             :req (req (and (:marked-server target)
+                            (first-event? state side :successful-run #(:marked-server (first %)))))
+             :async true
+             :effect (req (if (= :hq (first (:server target)))
+                            (do
+                              (system-msg state side (str "uses " (:title card) " to access 1 additional card from HQ this run"))
+                              (register-events
+                                  state side
+                                  card [(breach-access-bonus :hq 1 {:duration :end-of-run})])
+                                (effect-completed state side eid))
+                            (do (system-msg state side (str "will use " (:title card) " to breach HQ when this run ends"))
+                                (register-events
+                                  state side
+                                  card
+                                  [{:event :run-ends
+                                    :duration :end-of-run
+                                    :async true
+                                    :interactive (req true)
+                                    :msg (msg "breach HQ")
+                                    :effect (req (breach-server state :runner eid [:hq] {:no-root true}))}])
+                                (effect-completed state side eid))))}]})
+
 (defcard "Window"
   {:abilities [{:cost [:click 1]
                 :keep-menu-open :while-clicks-left