anchor.diff:        (gl:raster-pos x y)
         (glut:bitmap-string glut:+bitmap-8-by-13+ string))))
   
  -(defmacro define-level (name &body objects)
  +(defmacro define-level (name-and-initargs &body objects)
     (labels ((object-name (object)
                (getf (cdr object) :named))
              (object-class-name (object)
  
positive.code:    (order-table :initform (make-hash-table) :accessor order-table)
     (tick :initform nil :accessor tick)))
  
  (defmethod initialize-instance :after ((world world) &rest initargs &key test-order render-order update-order hit-test-order &allow-other-keys)
    (declare (ignore initargs))
    (when (null test-order)
      (setf test-order (list 't)))
    (when (null render-order)
      (setf render-order (reverse test-order)))
    (when (null update-order)
      (setf update-order (copy-list render-order)))
    (when (null hit-test-order)
      (setf hit-test-order (copy-list test-order)))
    (assert (set-equal test-order render-order))
    (assert (set-equal test-order update-order))
    (assert (set-equal test-order hit-test-order))
    (setf (objects world) (make-array (length test-order) :initial-element '()))
    (setf (gethash :render (order-table world))
          (mapcar (lambda (type) (position type test-order)) render-order))
    (setf (gethash :update (order-table world))
          (mapcar (lambda (type) (position type test-order)) update-order))
    (setf (gethash :hit-test (order-table world))
          (mapcar (lambda (type) (position type test-order)) hit-test-order))
    (setf (gethash :test (order-table world)) test-order))
    
  (defmethod reinitialize-instance :before ((world world) &rest initargs)
    (declare (ignore initargs))
  
negative.code:     (let ((object-names (loop for object in objects
                                when (object-name object)
                                collect it)))
        (destructuring-bind (name &rest initargs) (ensure-list name-and-initargs)
          `(progn
             (defclass ,name (world)
               ()
               (:default-initargs ,@initargs))
             (defmethod shared-initialize :after ((world ,name) slot-names &rest initargs)
               (declare (ignore slot-names initargs))
               (let ,object-names
                 ,@(loop for object in objects
                         for name = (object-name object)
                         for make = `(make-instance ',(object-class-name object) ,@(object-initargs object))
                         collect `(add-object ,(if name `(setf ,name ,make) make) world))))
           ',name)))))
  