anchor.diff:  (defclass enemy ()
     ((pos :initarg :pos :accessor pos)
      (grid :initarg :grid :accessor grid)
  -   (target-row :initform nil :accessor target-row)
  -   (target-col :initform nil :accessor target-col)
  +   (target-location :initform nil :accessor target-location)
      (structure :initarg :structure :accessor enemy-structure)
      (death-tick :initform nil :accessor death-tick)))
   
   (defmethod update ((enemy enemy))
  -  (multiple-value-bind (row col)
  -      (cell-row/col (pos enemy))
  +  (let ((location (cell-location (pos enemy))))
  +    (assert (not (null location)))
       (cond ((death-tick enemy)
              (when (= (incf (death-tick enemy)) enemy-death-ticks)
                (remove-object enemy)))
  -          ((= cell-claimed (cell-ref row col (grid enemy)))
  +          ((= cell-claimed (cell-ref location (grid enemy)))
              (setf (death-tick enemy) 0))
  -          ((need-new-target-p row col enemy)
  -           (setf (values (target-row enemy) (target-col enemy))
  -                 (choose-target-cell row col enemy)))))
  +          ((need-new-target-p location enemy)
  +           (setf (target-location enemy) (choose-target-cell location enemy)))))
     (when (null (death-tick enemy))
       (enemy-fix-direction enemy)
       (enemy-forward enemy)
       (enemy-check-claiming enemy)))
   
  -(defsubst need-new-target-p (row col enemy)
  -  (or (and (null (target-row enemy))
  -           (null (target-col enemy)))
  -      (and (= row (target-row enemy))
  -           (= col (target-col enemy)))))
  -
  -(defun choose-target-cell (row col enemy)
  -  (let* ((neighbors (collect-potential-target-cells row col enemy))
  +(defsubst need-new-target-p (location enemy)
  +  (or (null (target-location enemy)) (= location (target-location enemy))))
  +
  +(defun choose-target-cell (location enemy)
  +  (let* ((neighbors (collect-potential-target-cells location enemy))
            (weights-sum (reduce #'+ neighbors :key #'first))
            (choice (random weights-sum)))
  -    (loop for (weight nrow ncol) in neighbors
  +    (loop for (weight nlocation) in neighbors
             summing weight into sum
             when (> sum choice)
  -          return (values nrow ncol))))
  +          return nlocation)))
   
   (defsubst angle- (angle-1 angle-2)
     (let ((d1 (normalize-deg (- angle-1 angle-2)))
  
positive.code:       (do () ((null possibilities))
          (let ((filled nil)
                (location (pop possibilities)))
            (destructuring-bind (row col) location
              (flood-fill grid row col cell-unclaimed
                          (lambda (frow fcol)
                            (incf part-unclaimed)
                            (setf (cell-ref frow fcol grid) cell-fill)
                            (setf filled t)))
              (when filled
                (setf part-location location)
                (push (list nil 0) parts))))))
      parts))
  
  (defun flood-fill (grid starting-row starting-col source visitor)
    (let ((locations (list (list starting-row starting-col))))
      (flet ((interesting-p (row col)
               (and (valid-cell-p row col)
                    (= source (cell-ref row col grid)))))
        (do () ((null locations))
          (destructuring-bind (row col) (pop locations)
            (when (interesting-p row col)
              (let ((left (do ((left col (1- left)))
                              ((not (interesting-p row left)) left)))
                    (right (do ((right col (1+ right)))
                               ((not (interesting-p row right)) right))))
                (loop for fill-col from (1+ left) below right do
                      (funcall visitor row fill-col)
                      (when (interesting-p (1- row) fill-col)
                        (push (list (1- row) fill-col) locations))
                      (when (interesting-p (1+ row) fill-col)
                        (push (list (1+ row) fill-col) locations))))))))))
  
  
  
negative.code:       0.0
        (normalize-deg (vec-angle (vec- source-position target-position)))))
  
  (defsubst angle-between-position-and-location (source-position target-location)
    (angle-between-positions source-position (cell-center-position target-location)))
  
  (defsubst enemy-target-angle (enemy)
    (angle-between-position-and-location (pos enemy) (target-location enemy)))
  
  (defun enemy-fix-direction (enemy)
    (let ((target-angle (enemy-target-angle enemy))
  