anchor.diff:    (:method ((game game) origin-key destination-key amount)
      (let ((origin (territory game origin-key))
            (destination (territory game destination-key)))
  +     (unless (eq (owner origin) (turn-player game))
  +       (error "Los territorios deben pertenecer al jugador de turno"))
        (unless (territories-connected-p game origin-key destination-key)
          (error "Los territorios deben estar conectados"))
        (unless (eq (owner origin) (owner destination))
  
positive.code:   (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 game))
  
negative.code:     (setf the-turn-player the-players-round)
      (setf the-pending-armies nil)
      (setf the-fsm
            (flet
              ((pass-placing (fsm old-armies new-state
                                  &optional new-armies playing)
                 (when (> the-pending-armies 0)
                   (error "No se pusieron todos los ejércitos aún"))
                 (setf the-pending-armies
                       (if (if playing
                             (pass-turn game)
                             (rotate-turn game))
                         (progn
                           (switch fsm new-state)
                           new-armies)
                         old-armies))))
              (make-fsm
                (:setup
                  (:done ((fsm)
                          (setf the-pending-armies 10)
                          (switch fsm :placing-twice-n)))
                  :placing-twice-n
                  (:place ((fsm where amount)
                           (place-armies game where amount))
                   :done ((fsm)
                          (pass-placing fsm 10 :placing-n 5)))
                  :placing-n
                  (:place ((fsm where amount)
                           (place-armies game where amount))
                   :done ((fsm)
                          (pass-placing fsm 5 :attacking)))
                  :attacking
                  (:attack ((fsm from to)
                            (attack game from to))
                   :done ((fsm)
                          (switch fsm :regrouping)))
                  :regrouping
                  (:move ((fsm from to amount)
                          (move-armies game from to amount))
                   :done ((fsm)
                          (switch fsm (if (pass-turn game)
                                        (progn
                                          (setf the-pending-armies 5)
                                          :placing)
                                        :attacking))))
                  :placing
                  (:place ((fsm where amount)
                           (place-armies game where amount))
                   :done ((fsm)
                          (pass-placing fsm 5 :placing-n nil t))))
                :setup)))))
  
  (defgeneric read-map (file)
    (:method ((list list))
  