anchor.diff:  			      (remove item (rs-objects state))))))))))
           (values new-state (rescue-reward env state action new-state)))))
   
  +(defun pick-elt (list)
  +  (nth (random (length list)) list))
  +
   (defmethod sample-init ((env <rescue-env>))
     (let* ((graph (nav-graph env))
            ;; (node-1 (find-node graph 1))
            (node-2 (find-node graph 2))
            (node-3 (find-node graph 3)))
       (make-rescue-state
  -     :location (home-node env)
  -     :target-locations (list (home-node env))
  +     :location (pick-elt (home-nodes env))
  +     :target-locations (home-nodes env)
        :objects (list (make-victim :v1 node-2 24)
                       (make-rubble :r1 node-3)))))
   
  
positive.code:          (from (rs-location state))
           (to (rs-location new-state))
           (edge (find to (node-edges from) :key #'edge-to))
           (reward (if (and (same (rs-location new-state) (home-node env))
                            (eql action 'drop))
                       1000
                       0)))
  
negative.code: (defclass <rescue-env> (<fully-observable-env>)
    ((nav-graph :accessor nav-graph :initarg :nav-graph
                :initform (required-initarg :map))
     (home-nodes :accessor home-nodes :initarg :home-nodes
                 :initform (required-initarg :home-nodes))
     (max-damage :accessor max-damage :initarg :max-damage
                 :initform 500)
     (invalid-action-cost :accessor invalid-action-cost :initarg :invalid-action-cost
                          :initform 2.0)))
  
  
  (defmethod initialize-instance :around ((self <rescue-env>) &key home-nodes nav-graph)
    (call-next-method self
                      :home-nodes (mapcar (lambda (node)
                                            (find-node nav-graph node))
                                          home-nodes)
                      :nav-graph nav-graph))
  
  #||
  