anchor.diff:  
   (define-level (consix :test-order '(player enemy t))
     (grid :named grid)
  -  (player :lives 3 :row (1- grid-rows) :col (floor grid-cols 2) :grid grid)
  +  (player :lives 3 :loc (location (1- grid-rows) (floor grid-cols 2)) :grid grid)
     (enemy :pos (vec 0 0) :structure (list 0.0 0.0 0.0) :grid grid))
   
   (defun game ()
  
positive.code:       0.0
        (normalize-deg (vec-angle (vec- source-position target-position)))))
  
  (defsubst angle-between-position-and-cell (source-position target-row target-col)
    (angle-between-positions source-position
                             (cell-center-position target-row target-col)))
  
  (defsubst enemy-target-angle (enemy)
    (angle-between-position-and-cell (pos enemy)
                                     (target-row enemy)
                                     (target-col enemy)))
  
  (defun enemy-fix-direction (enemy)
    (let ((target-angle (enemy-target-angle enemy))
  
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)
  