anchor.diff:       (eq (owner origin) (owner destination)))))
   
   (defmethod print-object ((game game) stream)
  -  (format stream "~&Jugadores:~t~{~a~^, ~}~&Cabecera:~t~a~&Turno:~t~a"
  -          (loop for v being the hash-values in (players game)
  -                collecting (name v))
  -          (head-player game)
  -          (turn-player game))
  +  (format stream "~&Jugadores:~t~{~a~^, ~}"
  +          (loop repeat (size (players game))
  +                for p in (slot-value game 'players-round)
  +                collecting (if (equal p (turn-player game))
  +                             (format nil "-~a-" p)
  +                             p)))
  +  (format stream "~&Etapa:~t~a" (state (slot-value game 'fsm)))
     (format stream "~&Territorios:")
     (loop for v being the hash-values in (territories game) do
  -        (format stream "~&~a~&~tDueño:~t~a~&~tEjércitos:~t~a"
  +        (format stream "~&~t~a~&~t~tDueño:~t~t~a~&~t~tEjércitos:~t~t~a"
                   (name v)
                   (if (owner v) (name (owner v)) "Ninguno")
                   (if (armies v) (armies v) "Ninguno"))))
  
positive.code:   (with-slots ((the-game-map game-map)
                 (the-players players)
                 (the-players-round players-round)
                 (the-turn-player turn-player)) game
      (setf the-game-map
            (typecase game-map
              (game-map game-map)
  
negative.code:    (with-slots ((the-turn-player turn-player)
                  (the-players-round players-round)) game
       (pop the-turn-player)
       (let ((is-head-player (eq the-turn-player the-players-round)))
         (when is-head-player
           (pass-head game)
           (pop the-turn-player))
         is-head-player))))
  
  (defmethod territories ((game game))
    (territories (game-map game)))
  