anchor.diff:                (let ((winner (if (> car-score cdr-score)
                                   (car players)
                                   (cdr players))))
  -                (format t "The winner is ~a~%~%" (player-name winner)))))))
  +                (format t "The winner is ~a~%~%" (player-name winner)))))
  +        (cons car-score cdr-score)))))
   
   
   ;; And now the GUI...
  
positive.code:   (with-slots (edges) graph
      (find v1 (aref edges v0))))
  
  (defun game-size+1 (graph)
    "Compute the game size + 1 (the number of vertices across)."
    (isqrt (1+ (length (graph-edges graph)))))
  
  (defun square-vertices-at (graph i j)
    "Return the vertices for the square at position i j."
    (verts-for-square graph (+ i (* j (game-size+1 graph)))))
  
  (defun verts-for-square (graph v1)
    "The vertices that make up the square who's upper left corner is vertex v."
    (let* ((v2 (1+ v1))
           (v3 (+ (game-size+1 graph) v1))
           (v4 (1+ v3)))
      (values v1 v2 v3 v4)))
  
  (defun count-complete-squares (graph)
    "Count the number of 'complete' squares in the graph."
    (let ((s-count 0)
          (size (1- (game-size+1 graph))))
      (dotimes (j size)
        (dotimes (i size)
          (multiple-value-bind (v1 v2 v3 v4) (square-vertices-at graph i j)
            (when (and (has-edge-p graph v1 v2)
                       (has-edge-p graph v1 v3)
                       (has-edge-p graph v2 v4)
                       (has-edge-p graph v3 v4))
              (incf s-count)))))
      s-count))
  
  (defun get-possibilities (graph vertex)
    "Return the list of possible moves available for the specified vertex."
    (let* ((possibilities nil)
           (size+1 (game-size+1 graph))
           (j (mod vertex size+1))
           (i (/ (- vertex j) size+1)))
  
      (when (and (< i (1- size+1)) (not (has-edge-p graph vertex (+ size+1 vertex))))
        (push (+ size+1 vertex) possibilities))
  
      (when (and (< j (1- size+1)) (not (has-edge-p graph vertex (1+ vertex))))
        (push (1+ vertex) possibilities))
  
      (when (and (> j 0) (not (has-edge-p graph vertex (1- vertex))))
        (push (1- vertex) possibilities))
  
      (when (and (> i 0) (not (has-edge-p graph vertex (- vertex size+1))))
        (push (- vertex size+1) possibilities))
  
      possibilities))
  
  
negative.code:   (score 0 :type fixnum)
    (edge-function #'get-human-edge)
    (name "human" :type string)
    (tag #\a)
    (next-player #'cdr))
  
  (defstruct dab
    "A structure representing a Dots and Boxes game."
    (game-size 2 :type fixnum)
    (squares nil :type list)
    (owners nil :type list)
    (players (cons (make-player :edge-function #'get-human-edge :name "Human" :next-player #'cdr :tag #\A)
                   (make-player :edge-function #'get-random-computer-edge :name "Computer" :next-player #'car :tag #\B)))
    (graph (create-dab-graph 2) :type graph))
  
  
  