anchor.diff:     (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 shared-initialize :after ((world world) slot-names &rest initargs &key test-order render-order update-order hit-test-order &allow-other-keys)
  +  (declare (ignore slot-names initargs))
  +  (unless (slot-boundp world 'objects)
  +    (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))
  
positive.code:     (let ((object-names (loop for object in objects
                                when (object-name object)
                                collect it)))
        `(progn
           (defclass ,name (world) ())
           (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))))
  
negative.code:       (gl:raster-pos x y)
        (glut:bitmap-string glut:+bitmap-8-by-13+ string))))
  
  (defmacro define-level (name-and-initargs &body objects)
    (labels ((object-name (object)
               (getf (cdr object) :named))
             (object-class-name (object)
  