anchor.diff:  ready immediately."
     (push-event (make-instance 'event
   			     :payload payload 
  -			     :exec-frame (+ delay (current-frame *game*)))
  -	      *game*))
  +			     :exec-frame (+ delay (current-frame (current-level *game*))))
  +	      (current-level *game*)))
   
   ;;;
   ;;; Event-queue
  
positive.code: ;;; Methods
  
  ;; Why am I not using this in main.lisp? ffs.
  (defmethod process-next-event ((game game))
    "Processes the next event in EVENT-QUEUE, executing it if it's 'baked'."
    (when (event-available-p game)
      (let ((event (pop-next-event game)))
        (execute-event event))))
  
  (defmethod event-available-p ((game game))
    "Simply peeks to see if there's an event in the queue, and if it's cooked."
    (when (and (peek-next-event game)
  	     (cooked-p (peek-next-event game)))
      t))
  
  (defmethod cooked-p ((event event))
    "Simply checks that it doesn't shoot its load prematurely.."
    (let  ((frame-difference (- (exec-frame event) (current-frame *game*))))
      (when (<= frame-difference 0)
        t)))
  
  
negative.code:   (make-priority-queue :key #'exec-frame))
  
  ;;; Generics
  (defgeneric push-event (event level)
    (:documentation "Adds EVENT to LEVEL's event-queue"))
  (defgeneric peek-next-event (level)
    (:documentation "Peeks at the next event in LEVEL's event-queue without removing it.
  Returns NIL if there are no queued events."))
  (defgeneric pop-next-event (level)
    (:documentation "Returns the next available event, and removes it from LEVEL's event-queue.
  Returns NIL if there is nothing in the queue."))
  (defgeneric clear-events (level)
    (:documentation "Clears all events off the event queue"))
  
  ;;; Methods
  (defmethod push-event ((event event) (level level))
    (priority-queue-insert (event-queue level) event)
    t)
  
  (defmethod peek-next-event ((level level))
    (priority-queue-minimum (event-queue level)))
  
  (defmethod pop-next-event ((level level))
    (priority-queue-extract-minimum (event-queue level)))
  
  (defmethod clear-events ((level level))
    (let ((pause-state (paused-p level)))
     (setf (event-queue level) (make-event-queue))
     (setf (paused-p level) pause-state)))
  
  ;;;
  ;;; Event processing
  ;;;
  
  ;;; Generics
  (defgeneric process-next-event (level)
    (:documentation "Grabs the next event from LEVEL's event queue and executes it."))
  
  (defgeneric process-cooked-events (level)
    (:documentation "Processes all cooked events in LEVEL"))
  
  (defgeneric event-available-p (level)
    (:documentation "Is there a cooked event available?"))
  
  (defgeneric execute-event (event)
  