anchor.diff:    (let* ((root (game-root *game*))
            (root-size (size root)))
       (loop for i from (1+ (floor count -2)) to (floor count 2)
  -       do (with-slots (offset size veloc)
  +       do (let ((primary-weapon (make-instance 
  +                          'weapon :projectile-class 'enemy-bullet
  +                          :projectile-image :enemy-bullet
  +                          :projectile-n-directions 16
  +                          :projectile-veloc #c (0 +12)
  +                          :projectile-timer 60
  +                          :ammo ammo))
  +                 (secondary-weapon (make-instance 
  +                          'weapon :projectile-class 'enemy-missile
  +                          :projectile-image :enemy-missile
  +                          :projectile-n-directions 16
  +                          :projectile-veloc #c (0 +4)
  +                          :projectile-timer 120
  +                          :firepower 1
  +                          :ammo missiles)))
  +            (with-slots (offset size veloc)
                 (make-instance enemy-type :parent root :depth 1
  -                             :health health
  -                             :ammo ammo
  -                             :missiles missiles
  -                             :missile-chance missile-chance
  -                             :difficulty (floor wave 5))
  +                :health health
  +                :missile-chance missile-chance
  +                :difficulty (floor wave 5)
  +                :primary-weapon primary-weapon
  +                :secondary-weapon secondary-weapon)
               (setf offset
  -                  (complex (+ (/ (x root-size) 2) (* i (x size) 2))
  -                           (* (y size) -2)))))))
  +              (complex (+ (/ (x root-size) 2) (* i (x size) 2))
  +                (* (y size) -2))))))))
   
   (defmethod alarm ((wave wave-controller) event)
     (with-slots (level) wave
  
positive.code:       (progn (setf (boost-on thopter) nil) (change-veloc thopter event))
        (setf (boost-on thopter) t)))
  
  (defmethod initialize-instance :after ((shooter shooter) &key)
    (setf (ammo shooter) (* (ammo shooter) (ammo-deplete-rate shooter))))
  
  (defmethod shoot ((shooter shooter) event)
    (with-slots (parent offset size veloc ammo bullet-class bullet-image
                 bullet-n-directions bullet-veloc bullet-timer ammo-deplete-rate)
                shooter
      (when (> ammo 0)
        (let* ((firepower (ceiling ammo ammo-deplete-rate))
               (increment (if (< (* (floor firepower 2) 0.15d0) 1) (* 0.15d0 pi)
                              (/ pi (/ firepower 2)))))
          (iter (for i from (+ (ceiling firepower -2)
                               (if (evenp firepower) 1/2 0))
                     to (floor firepower 2))
                (for v = (+ veloc (rot bullet-veloc (* i increment))))
                (for image = (if bullet-n-directions
                                  (make-image
                                   "~a-~2,'0d" bullet-image
                                   (quadrant v bullet-n-directions))
                                  (make-image bullet-image)))
             (make-instance bullet-class :parent parent 
                            :offset (+ offset (/ size 2) (- (/ (size image) 2))
                                       (* (rot (unit bullet-veloc)
                                               (* i increment))
                                          (+ (x size) (y size))
                                          0.25d0))
                            :depth -1 :veloc v :image image :timer bullet-timer))
          (decf ammo firepower))
        (play (make-instance 'sample :name :thopter-gun
                               :source (resource "sound/thoptergun.ogg")
                               :type :sample)))))
  
  (defmethod missile ((thopter thopter) event)
    (with-slots (parent offset size veloc missiles) thopter
      (when (> missiles 0)
        (decf missiles)
        (make-instance 'missile
                       :parent parent 
                       :offset (+ offset (/ (x size) 2) #c(0 -4)) :depth -1
                       :veloc (+ veloc #c(0 -4))
                       :image (make-image "~a-~2,'0d" :missile
                                          (quadrant (+ veloc #c(0 -4)) 16)))
        (play (make-instance 'sample
                               :name :missile
                               :source (resource "sound/missile.ogg")
                               :type :sample)))))
  
  (defmethod missile ((enemy enemy) event)
    (with-slots (parent offset size veloc missiles) enemy
      (when (> missiles 0)
        (decf missiles)
        (make-instance 'enemy-missile
                       :parent parent 
                       :offset (+ offset (/ (x size) 2) #c(0 4)) :depth -1
                       :veloc (+ veloc #c(0 4))
                       :image (make-image "~a-~2,'0d" :enemy-missile
                                          (quadrant (+ veloc #c(0 4)) 16)))
        (play (make-instance 'sample
                               :name :missile
                               :source (resource "sound/missile.ogg")
                               :type :sample))
        (when (<= (enemy-missiles (game-screen *game*)) 0)
          (setf (missile-lock (game-screen *game*))
                (play (make-instance 'sample
                                     :name :beep
                                     :source (resource "sound/beep.ogg")
                                     :type :sample) :loop t)))
        (incf (enemy-missiles (game-screen *game*))))))
  
  (defmethod update ((missile missile) event)
    (with-slots (parent offset size veloc accel image) missile
  
negative.code:           (setf accel 0)))))
  
  (defmethod collide ((thopter thopter) event)
    (with-slots (parent offset depth veloc health primary-weapon
                        secondary-weapon missiles speed-boost) thopter
      (with-slots (ammo ammo-refill-rate) primary-weapon
        (typecase (event-hit event)
          (enemy-bullet  (decf health))
          (enemy-missile (decf health))
          (enemy         (decf health 8))
          (explosion     (decf health))
          (health-pack   (incf health 2))
          (upgrade-bullet (incf ammo ammo-refill-rate))
          (upgrade-missile (incf (ammo secondary-weapon)))
          (upgrade-speed (progn
                           (setf speed-boost
                             (min (+ speed-boost 240) (max-speed-timer thopter)))
                           (change-veloc thopter event))))
        (when (and parent (<= health 0))
          (make-instance 'explosion :parent parent
            :offset offset :depth depth :veloc (/ veloc 2)
            :image (make-anim :explosion)
            :timer 28)
          (detach parent thopter)
          (decf (players-left (players-left (game-screen *game*))))))))
  
  (defmethod update :after ((thopter thopter) event)
    (with-slots (parent offset size veloc) thopter
  