anchor.diff:  (defun movingp (modifiers)
     "Detects if a piece can move or not"
     (or (find #\m modifiers)
  -      (not (or find #\m modifiers)
  -           (or find #\c modifiers))))
  +      (not (or (find #\m modifiers)
  +               (find #\c modifiers)))))
   
  -(defun generate-directions (x y)
  +(defun generate-directions (x y &optional sig)
     "Generates a list of destinations radially symmetric with the original (x, y) pair."
     (let ((max (max x y))
           (-max (- (max x y)))
  
positive.code:     (unless (string-equal "" fstr) ; catch (0, 0) and return nil for it.
        (force-exist-symbol fstr "keyword"))))
  
  (defun decode-directional-modifiers (modifier-string &optional (context-landmark "W"))
    "Takes the modifier string of directions and transform them into a list of direction selectors."
    ;; Annoyingly, the semantics of each modifier is different depending on whether or not the landmark is orthogonal, diagonal or hippogonal.
  
negative.code:   ;; Things get even worse with the two hybrid landmarks Q and K,
    ;; where bK is bWbF, brlK is brlFbK, etc etc etc.
    ;; As such it is best to consider each case separate.
    (ecase (aref context-landmark 0) ; the first letter (the second letter is always the same) is...
      ((#\W #\R #\D #\H)             ; orthogonal
       (if (equal "" (remove-if-not #'(lambda (p) (find p "brflvs")) modifier-string))
           (list :f :b :r :l)
           (remove-duplicates
            (loop for i across modifier-string
                  append (case i
                           (#\s (list :r :l))
                           (#\v (list :f :b))
                           ((#\b #\r #\f #\l) (list (force-exist-symbol i :keyword))))))))
      ((#\F #\B #\A #\G)                  ; diagonal
       (let ((effective-directions (remove-if-not #'(lambda (p) (find p "brfl")) modifier-string)))
         (case-using-equal effective-directions
           ("" (list :br :bl :fr :fl))
           ("b" (list :br :bl))
           ("r" (list :fr :br))
           ("f" (list :fr :fl))
           ("l" (list :fl :bl))
           (("br" "bl" "fr" "fl") (list (force-exist-symbol effective-directions :keyword)))
           (t (error (format nil "No match for directional modifier ~a found." effective-directions))))))
      ((#\N #\L #\J)                      ; hippogonal
       (let ((effective-directions (remove-if-not #'(lambda (p) (find p "brflvsh")) modifier-string)))
         (case-using-equal effective-directions
           ("" (list :ffl :ffr :bbl :bbr :fsl :fsr :bsl :bsr)) 
           (("b" "bh") (list :bbr :bsr :bbl :bsl))
           (("r" "rh") (list :bbr :bsr :ffr :fsr))
           (("f" "fh") (list :ffr :fsr :ffl :fsl))
           (("l" "lh") (list :ffl :fsl :bsl :bbl))
           (("s" "rl") (list :fsr :fsl :bsr :bsl))
           (("v" "fb") (list :ffl :ffr :bbl :bbr))
           ("ff" (list :ffl :ffr))
           ("bb" (list :bbl :bbr))
           ("fs" (list :fsl :fsr))
           ("bs" (list :bsl :bsr))
           ("ll" (list :fsl :bsl))
           ("lv" (list :ffl :bbl))
           ("rr" (list :fsr :bsr))
           ("rv" (list :ffr :ffl))
           (("ffr" "ffl" "fsr" "fsl" "bbr" "bbl" "bsr" "bsl")
            (list (force-exist-symbol effective-directions :keyword)))
           (t (error (format nil "No match for directional modifier ~a found." effective-directions))))))
      ((#\Q #\K)                          ; hybrid directions
       (if (equal "" (remove-if-not #'(lambda (p) (find p "brflvs")) modifier-string))
           (list :bl :b :br :fl :f :fr :r :l)
           (remove-duplicates
            (loop for i across modifier-string
                  append (case i
                           (#\b (list :bl :b :br))
                           (#\r (list :fr :r :br))
                           (#\f (list :fl :f :fr))
                           (#\l (list :fl :l :bl))
                           (#\v (list :fl :f :fr :bl :b :br))
                           (#\s (list :fl :l :bl :fr :r :br)))))))))
  
  