anchor.diff:  
   (defmethod initialize-instance :after ((player player) &rest initargs)
     (declare (ignore initargs))
  -  (let ((row (row player))
  -        (col (col player)))
  -    (setf (pos player) (cell-center-position row col))))
  +  (setf (pos player) (cell-center-position (initial-location player))))
   
   (defmethod update ((player player))
     (when (null (movement-actions player))
  
positive.code:       (draw -95.0 (- 85.0 (* i 10.0))))))
  
  (defun maybe-queue-movement-actions (player)
    (flet ((goto (row col)
             (let* ((target (cell-center-position row col))
                    (step (vec/ (vec- target (pos player))
                                (float player-movement-steps))))
               (setf (movement-actions player)
  
negative.code:                          else
                           collect (lambda ()
                                     (setf (pos player) target)
                                     (setf (loc player) location)
                                     (player-changed-cell player)))))))
      (when-let (move (find-if (lambda (move)
                                 (movement-possible-p move player))
                               (requested-moves (loc player))))
        (goto move))))
  
  (defun requested-moves (location)
    (mapcan (lambda (key)
              (case key
                (:key-left (list (valid-col+ location -1)))
                (:key-right (list (valid-col+ location 1)))
                (:key-up (list (valid-row+ location 1)))
                (:key-down (list (valid-row+ location -1)))))
            *keys*))
  
  (defsubst movement-possible-p (location player)
    (or (= cell-edge (cell-ref location (grid player)))
        (and (member #\Space *keys*)
             (= cell-unclaimed (cell-ref location (grid player))))))
  
  (defun player-changed-cell (player)
    (symbol-macrolet ((cell (cell-ref (loc player) (grid player))))
      (case cell
        (#.cell-unclaimed
         (setf cell cell-claiming)
  