   (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)

(defn derez [state side card]
  (system-msg state side (str "derez " (:title card)))
  (update! state :corp (desactivate state :corp card true))
  (trigger-event state side :derez card))

(defn advance [state side {:keys [card]}]

                 (when-let [events (:events (card-def c))]
                   (unregister-events state side c)
                   (register-events state side events c))))))
         (trigger-event state side :card-moved moved-card)
         moved-card)))))

(defn draw
