anchor.diff:  (defstruct (potion (:include item)) (power 15))
   (defstruct (sword  (:include item)) (durability 100) (power 5))
   (defstruct (shield (:include item)) (durability 100) (power 7))
  +(defstruct node (contents nil) (visited nil))
   
  -(defparameter *map*     (make-array 25))
  -(defparameter *visited* (make-array 25))
  -(defparameter *rows*    5)
  -(defparameter *columns* 5)
   (defparameter *inventory* (make-array 10))
   (defparameter *item-builders* nil)
   (defparameter *player* (make-player :position (cons 3 3)))
  -
  -(setf (aref *map* 17) (make-sword))
  -(setf (aref *map* 2) (make-shield))
  -(setf (aref *map* 3) (make-potion))
  -(setf (aref *map* 10) (make-potion))
  -(setf (aref *map* 22) (make-potion))
  -(setf (aref *map* 8) (make-shield))
   
   (setf (aref *inventory* 0) (make-sword))
   (setf (aref *inventory* 1) (make-shield))
  
positive.code: )
  
  (defun pickup-item ()
    (let ((player-x (car (player-position *player*)))
          (player-y (cdr (player-position *player*)))
         )
    
    (loop for i below (length *inventory*)
       do (if (equal (aref *inventory* i) nil)
                (progn
                  (setf (aref *inventory* i) (aref *map* (map-index *rows* *columns* player-x player-y)))
                  (setf (aref *map* (map-index *rows* *columns* player-x player-y))
                        nil))
                )))
    )
  
  (defun view-inventory ()
    (loop for item across *inventory*
  
negative.code: (defun no-item
    NIL)
  
  
  (push #'make-potion *item-builders*)
  (push #'make-sword  *item-builders*)
  (push #'make-shield *item-builders*)
  (push #'no-item     *item-builders*)
  
  
  ; Map related functions
  (defun make-map (rows columns)
    (defparameter *map* (make-hash-table :test 'equal))
    (create-node rows columns columns))
  
  (defun random-contents ()
    nil)
    
  (defun create-node (x y rows)
    (if (< x 0)
        nil
        (progn
          (setf (gethash (cons x y) *map*) (make-node :contents (random-contents)))
          (if (= y 0)
              (create-node (1- x) rows rows)
              (create-node x (1- y) rows)))))
  
  (defun get-node (coord)
    (gethash coord *map*))
  
  (defun set-contents (node item)
    (if (consp node)
        (setf (node-contents (get-node node)) item)
        (setf (node-contents node) item)))
  ; End map related functions
  
  (defmethod view-item (item)
    "Empty"
  