   (let [server (first (get-in @state [:run :server]))]
     (swap! state update-in [:runner :register :unsuccessful-run] #(conj % server))
     (swap! state assoc-in [:run :unsuccessful] true)
+    (update-all-ice state side)
     (trigger-event state side :unsuccessful-run)
     (handle-end-run state side)))
 
 (defn no-action [state side args]
   (swap! state assoc-in [:run :no-action] true)
-  (system-msg state side "has no further action"))
+  (system-msg state side "has no further action")
+  (when-let [pos (get-in @state [:run :position])]
+    (when-let [ice (when (and pos (> pos 0)) (get-card state (nth (get-in @state [:run :ices]) (dec pos))))]
+      (when (:rezzed ice)
+        (trigger-event state side :encounter-ice ice)
+        (update-ice-strength state side ice)
+        (let [stren (:current-strength (get-card state ice))]
+          (system-msg state :runner (str "encounters " (:title ice) " at strength " stren)))))))
 
 (defn continue [state side args]
   (when (get-in @state [:run :no-action])
+    (when-let [pos (get-in @state [:run :position])]
+      (when-let [ice (when (and pos (> pos 0)) (get-card state (nth (get-in @state [:run :ices]) (dec pos))))]
+        (trigger-event state side :pass-ice ice)
+        (update-ice-in-server state side (card->server state ice))))
     (swap! state update-in [:run :position] dec)
     (swap! state assoc-in [:run :no-action] false)
     (swap! state assoc-in [:runner :rig :program]
            (for [p (get-in @state [:runner :rig :program])]
              (if (or (not (:current-strength p)) (:all-run p))
                p (assoc p :current-strength nil))))
-    (system-msg state side "continues the run")))
+    (system-msg state side "continues the run")
+    (let [pos (get-in @state [:run :position])]
+      (when (> (count (get-in @state [:run :ices])) 0)
+        (update-ice-strength state side (nth (get-in @state [:run :ices]) pos)))
+      (when (> pos 0)
+        (let [ice (get-card state (nth (get-in @state [:run :ices]) (dec pos)))]
+          (trigger-event state side :approach-ice ice))))))
 
 (defn play-ability [state side {:keys [card ability targets] :as args}]
   (let [cdef (card-def card)

         (when (or no-cost (pay state side card :credit cost (:additional-cost cdef)))
           (card-init state side (assoc card :rezzed true))
           (system-msg state side (str "rez " (:title card) (when no-cost " at no cost")))
           (trigger-event state side :rez card))))))

(defn corp-install

              (resolve-ability state side end-run-effect (:card run-effect) [(first server)]))))
        (swap! state assoc :run nil))))

(declare update-ice-strength)

(defn add-prop [state side card key n]
  (update! state side (update-in card [key] #(+ (or % 0) n)))
  (when (= key :advance-counter)
    (trigger-event state side :advance card)
    (when (and (#{"ICE"} (:type card)) (:rezzed card)) (update-ice-strength state side card))))

(defn set-prop [state side card & args]
  (update! state side (apply assoc (cons card args))))
