anchor.diff:  
   
   (defmacro defattribute (name general-description &body level-descriptions)
  -  `(progn  (cl-ecs:defcomponent ,name (dots))
  -            (push '(,name . ,general-description) attribute-descriptions)
  -            (push '(,name . ,level-descriptions) attribute-level-descriptions)))
  +  `(progn  (unless (member (quote ,name) (cl-ecs::all-components))
  +             (cl-ecs:defcomponent ,name (dots)))
  +           (unless (assoc (quote ,name) attribute-descriptions)
  +             (push '(,name . ,general-description) attribute-descriptions))
  +           (unless (assoc (quote ,name) attribute-level-descriptions)
  +             (push '(,name . ,level-descriptions) attribute-level-descriptions))))
   
   
   
  
positive.code:                             do what a character wants because his words seem 
                              true or the only option not because they trust the 
                              character or see him as a leader.)
                 ((1 (awkward))
                  (2 (average))
                  (3 (persuasive))
                  (4 (exceptional))
                  (5 (outstanding))))
  
  (defattribute resolve 
                (how determined is a character to continue arguing his case.  
  
negative.code: 
  
  (defun attribute-dots (attribute)
    "Return the symbol that corresponds to the dots field of `attribute`."
    (find-symbol (format nil "~A/DOTS" attribute) 'merlin))
  
  
  (defun get-attribute-dots (entity attribute)
    "Return the number of dots (i.e. level and available dice) `entity` 
     has in the given attribute."
    (apply (attribute-dots attribute) (list entity)))
  
  
  (defun print-entity-attribute (entity attribute)
    "Print a human readable description of the level of `attribute` that
     `entity` has."
    (print-attribute-level-description 
      attribute
      (get-attribute-dots entity attribute)))
  
  
  (defun  print-entity-all-attributes (entity)
    "Print a human readable description of the level of evry attribute
     that `entity` has."
    (mapcar #'(lambda (x)
                (if (member x (cl-ecs::entity-components entity))
                  (progn 
                    (print-entity-attribute entity x)
                    (fresh-line))))
            (mapcar #'car attribute-descriptions)))
  
  
  (defun attribute-dice-pool (entity attribute)
    "Create a dice pool for `attribute` of `entity`."
    (dice-pool (get-attribute-dots entity attribute)))
  
  
  (defun add-random-mundane-attribute (entity attribute)
    "Set `attribute` of `entity` to a random value appropriate for a
     mundane character." 
    (cl-ecs:add-component entity attribute nil)
    (funcall (fdefinition `(setf ,(attribute-dots attribute))) (dice 3) entity))
  
  
  (defun add-all-random-mundane-attributes (entity)
    "Set all attributes of `entity`, that were not previously set, to
     random values appropriate for mundane characters."
    (mapcar #'(lambda (x)
                (unless (member x (cl-ecs::entity-components entity))
                  (add-random-mundane-attribute entity x)))
            (mapcar #'car attribute-descriptions)))
  