anchor.diff:  ;;; Methods
   
   ;; Why am I not using this in main.lisp? ffs.
  -(defmethod process-next-event ((game game))
  +(defmethod process-next-event ((level level))
     "Processes the next event in EVENT-QUEUE, executing it if it's 'baked'."
  -  (when (event-available-p game)
  -    (let ((event (pop-next-event game)))
  +  (when (event-available-p level)
  +    (let ((event (pop-next-event level)))
         (execute-event event))))
   
  -(defmethod event-available-p ((game game))
  +(defmethod event-available-p ((level level))
     "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)))
  +  (when (and (peek-next-event level)
  +	     (cooked-p (peek-next-event level)))
       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*))))
  +  (let  ((frame-difference (- (exec-frame event) (current-frame (current-level *game*)))))
       (when (<= frame-difference 0)
         t)))
   
  
positive.code:   (make-priority-queue :key #'exec-frame))
  
  ;;; Generics
  (defgeneric push-event (event game)
    (:documentation "Adds EVENT to GAME's event-queue"))
  (defgeneric peek-next-event (game)
    (:documentation "Peeks at the next event in GAME's event-queue without removing it.
  Returns NIL if there are no queued events."))
  (defgeneric pop-next-event (game)
    (:documentation "Returns the next available event, and removes it from GAME's event-queue.
  Returns NIL if there is nothing in the queue."))
  (defgeneric clear-events (game)
    (:documentation "Clears all events off the event queue"))
  
  ;;; Methods
  (defmethod push-event ((event event) (game game))
    (priority-queue-insert (event-queue game) event)
    t)
  
  (defmethod peek-next-event ((game game))
    (priority-queue-minimum (event-queue game)))
  
  (defmethod pop-next-event ((game game))
    (priority-queue-extract-minimum (event-queue game)))
  
  (defmethod clear-events ((game game))
    (let ((pause-state (paused-p game)))
     (setf (event-queue game) (make-event-queue))
     (setf (paused-p game) pause-state)))
  
  ;;;
  ;;; Event processing
  ;;;
  
  ;;; Generics
  (defgeneric process-next-event (game)
    (:documentation "Grabs the next event from GAME's event queue and executes it."))
  
  (defgeneric process-cooked-events (game)
    (:documentation "Processes all cooked events in GAME"))
  
  (defgeneric event-available-p (game)
    (:documentation "Is there a cooked event available?"))
  
  (defgeneric execute-event (event)
  
negative.code:     :documentation "A function, that contains the code to be executed.")
     (exec-frame
      :initarg :exec-frame
      :initform (current-frame (current-level *game*))
      :accessor exec-frame
      :documentation "The time of execution when this event will be considered 'cooked'. 
  By default, all events are immediately cooked.")))
  