Implement Recurring and Placed Credits

src/clj/game/cards.clj

@@ -207,6 +207,42 @@
                                                (vals selected-cards)))]
                            (effect-completed state side (make-result eid {:number counter-count :msg msg})))))}))
 
+(defn pick-credit-providing-cards
+  "Similar to pick-virus-counters-to-spend. Works on :recurring and normal credits."
+  ([provider-func] (pick-credit-providing-cards (hash-map) 0 nil provider-func))
+  ([target-count provider-func] (pick-credit-providing-cards (hash-map) 0 target-count provider-func))
+  ([selected-cards counter-count target-count provider-func]
+   {:async true
+    :prompt (str "Select a card with recurring credits ("
+                 counter-count (when (and target-count (pos? target-count))
+                                 (str " of " target-count))
+                 " credits)")
+    :choices {:req #(and (< 0 (get-counters % :recurring)) (.contains (provider-func) %))}
+    :effect (req (add-counter state :runner target :recurring -1)
+                 (let [selected-cards (update selected-cards (:cid target)
+                                              ;; Store card reference and number of counters picked
+                                              ;; Overwrite card reference each time
+                                              #(assoc % :card target :number (inc (:number % 0))))
+                       counter-count (inc counter-count)]
+                   (if (or (not target-count) (< counter-count target-count))
+                     (continue-ability state side
+                                       (pick-credit-providing-cards selected-cards counter-count target-count provider-func)
+                                       card nil)
+                     (let [msg (join ", " (map #(let [{:keys [card number]} %
+                                                      title (:title card)]
+                                                  (str (quantify number "recurring credit") " from " title))
+                                               (vals selected-cards)))]
+                       (effect-completed state side (make-result eid {:number counter-count :msg msg}))))))
+    :cancel-effect (if target-count
+                     (req (doseq [{:keys [card number]} (vals selected-cards)]
+                            (add-counter state :runner (get-card state card) :recurring number))
+                          (effect-completed state side (make-result eid :cancel)))
+                     (req (let [msg (join ", " (map #(let [{:keys [card number]} %
+                                                      title (:title card)]
+                                                  (str (quantify number "recurring credit") " from " title))
+                                               (vals selected-cards)))]
+                           (effect-completed state side (make-result eid {:number counter-count :msg msg})))))}))
+
 (defn never?
   "Returns true if is argument is :never."
   [x]

src/clj/game/cards/programs.clj

@@ -1970,7 +1970,8 @@
                                    :msg "break 1 Code Gate or Barrier subroutine"}])
 
    "Sahasrara"
-   {:recurring 2}
+   {:recurring 2
+    :interactions {:pay-credits (req (and (< 0 (get-counters card :recurring)) (program? target)))}}
 
    "Saker"
    (auto-icebreaker ["Barrier"]

src/clj/game/core/actions.clj

@@ -15,7 +15,8 @@
   (when-let [card (get-card state card)]
     (case (:type card)
       ("Event" "Operation") (play-instant state side card {:extra-cost [:click 1]})
-      ("Hardware" "Resource" "Program") (runner-install state side (make-eid state) card {:extra-cost [:click 1]})
+      ("Hardware" "Resource" "Program") (runner-install state side (make-eid state {:source :action
+                                                                                    :source-type :runner-install}) card {:extra-cost [:click 1]})
       ("ICE" "Upgrade" "Asset" "Agenda") (corp-install state side card server {:extra-cost [:click 1] :action :corp-click-install}))
     (trigger-event state side :play card)))
 

src/clj/game/core/costs.clj

@@ -2,7 +2,7 @@
 
 (declare forfeit prompt! toast damage mill installed? is-type? is-scored? system-msg
          facedown? make-result unknown->kw discard-from-hand card-str trash trash-cards
-         complete-with-result all-installed-runner-type)
+         complete-with-result all-installed-runner-type pick-credit-providing-cards)
 
 (defn deduct
   "Deduct the value from the player's attribute."
@@ -264,6 +264,25 @@
                 (str "trashes " (quantify amount "card") " randomly from "
                      (if (= :corp side) "HQ" "the grip"))))))
 
+(defn pay-credits
+  [state side eid card amount]
+  (case (:source-type eid)
+    :runner-install
+    (letfn [(provider-func []
+              (filter #((or (-> % card-def :interactions :pay-credits) (req false)) state side eid % [card]) (all-active-installed state :runner)))]
+      (if (< 0 (count (provider-func)))
+        (wait-for (resolve-ability state side (pick-credit-providing-cards amount provider-func) card nil)
+                  (swap! state update-in [:stats side :spent :credit] (fnil + 0) amount)
+                  (complete-with-result state side eid (:msg async-result)))
+        (do
+          (swap! state update-in [:stats side :spent :credit] (fnil + 0) amount)
+          (complete-with-result state side eid (deduct state side [:credit amount])))))
+
+    ;; Default
+    (do
+      (swap! state update-in [:stats side :spent :credit] (fnil + 0) amount)
+      (complete-with-result state side eid (deduct state side [:credit amount])))))
+
 (defn- cost-handler
   "Calls the relevant function for a cost depending on the keyword passed in"
   ([state side card action costs cost] (cost-handler state side (make-eid state) card action costs cost))
@@ -309,6 +328,9 @@
      ;; Shuffle installed runner cards into the stack (eg Degree Mill)
      :shuffle-installed-to-stack (pay-shuffle-installed-to-stack state side eid card amount)
 
+     ;; Pay credits
+     :credit (pay-credits state side eid card amount)
+
      ;; Else
      (do
        (swap! state update-in [:stats side :spent cost-type] (fnil + 0) amount)
@@ -332,7 +354,7 @@
   [state side eid costs card action msgs]
   (if (empty? costs)
     (effect-completed state side (make-result eid msgs))
-    (wait-for (cost-handler state side card action costs (first costs))
+    (wait-for (cost-handler state side (make-eid state eid) card action costs (first costs))
               (pay-sync-next state side eid (next costs) card action (conj msgs async-result)))))
 
 (defn pay-sync
@@ -341,7 +363,7 @@
   (let [raw-costs (not-empty (remove map? args))
         action (not-empty (filter map? args))]
     (if-let [costs (apply can-pay? state side (:title card) raw-costs)]
-      (wait-for (pay-sync-next state side costs card action [])
+      (wait-for (pay-sync-next state side (make-eid state eid) costs card action [])
                 (complete-with-result state side eid (->> async-result
                                                           (filter some?)
                                                           (join " and "))))

src/clj/game/core/installing.clj

@@ -406,8 +406,10 @@
 (defn runner-install
   "Installs specified runner card if able
   Params include extra-cost, no-cost, host-card, facedown and custom-message."
-  ([state side card] (runner-install state side (make-eid state) card nil))
-  ([state side card params] (runner-install state side (make-eid state) card params))
+  ([state side card] (runner-install state side (make-eid state {:source nil
+                                                                 :source-type :runner-install}) card nil))
+  ([state side card params] (runner-install state side (make-eid state {:source nil
+                                                                        :source-type :runner-install}) card params))
   ([state side eid card {:keys [host-card facedown no-mu no-msg] :as params}]
    (if (and (empty? (get-in @state [side :locked (-> card :zone first)]))
             (not (install-locked? state :runner)))
@@ -421,37 +423,38 @@
        (wait-for (trigger-event-simult state side :pre-install nil card facedown)
                  (let [cost (runner-get-cost state side card params)]
                    (if (runner-can-install? state side card facedown)
-                     (if-let [cost-str (pay state side card cost)]
-                       (let [c (if host-card
-                                 (host state side host-card card)
-                                 (move state side card
-                                       [:rig (if facedown :facedown (to-keyword (:type card)))]))
-                             c (assoc c :installed :this-turn :new true)
-                             installed-card (if facedown
-                                              (do (update! state side c)
-                                                  (find-latest state c))
-                                              (card-init state side c {:resolve-effect false
-                                                                       :init-data true}))]
-                         (when-not no-msg
-                           (runner-install-message state side (:title card) cost-str params))
-
-                         (play-sfx state side "install-runner")
-                         (when (and (is-type? card "Program")
-                                    (not facedown)
-                                    (not no-mu))
-                           ;; Use up mu from program not installed facedown
-                           (use-mu state (:memoryunits card))
-                           (toast-check-mu state))
-                         (handle-virus-counter-flag state side installed-card)
-                         (when (and (not facedown) (is-type? card "Resource"))
-                           (swap! state assoc-in [:runner :register :installed-resource] true))
-                         (when (and (not facedown) (has-subtype? c "Icebreaker"))
-                           (update-breaker-strength state side c))
-                         (trigger-event-simult state side eid :runner-install
-                                               (when-not facedown
-                                                 {:card-ability (card-as-handler installed-card)})
-                                               installed-card))
-                       (effect-completed state side eid))
-                     (effect-completed state side eid)))
-                 (clear-install-cost-bonus state side)))
-     (effect-completed state side eid))))
+                     (wait-for (pay-sync state side (make-eid state eid) card cost)
+                               (if-let [cost-str async-result]
+                                 (let [c (if host-card
+                                           (host state side host-card card)
+                                           (move state side card
+                                                 [:rig (if facedown :facedown (to-keyword (:type card)))]))
+                                       c (assoc c :installed :this-turn :new true)
+                                       installed-card (if facedown
+                                                        (do (update! state side c)
+                                                            (find-latest state c))
+                                                        (card-init state side c {:resolve-effect false
+                                                                                 :init-data true}))]
+                                   (when-not no-msg
+                                     (runner-install-message state side (:title card) cost-str params))
+
+                                   (play-sfx state side "install-runner")
+                                   (when (and (is-type? card "Program")
+                                              (not facedown)
+                                              (not no-mu))
+                                     ;; Use up mu from program not installed facedown
+                                     (use-mu state (:memoryunits card))
+                                     (toast-check-mu state))
+                                   (handle-virus-counter-flag state side installed-card)
+                                   (when (and (not facedown) (is-type? card "Resource"))
+                                     (swap! state assoc-in [:runner :register :installed-resource] true))
+                                   (when (and (not facedown) (has-subtype? c "Icebreaker"))
+                                     (update-breaker-strength state side c))
+                                   (trigger-event-simult state side eid :runner-install
+                                                         (when-not facedown
+                                                           {:card-ability (card-as-handler installed-card)})
+                                                         installed-card))
+                                 (effect-completed state side eid)))
+                               (effect-completed state side eid)))
+                   (clear-install-cost-bonus state side)))
+       (effect-completed state side eid))))