anchor.diff:         (error "Los territorios deben ser divisibles entre los jugadores"))
        (loop
          with territories = (shuffle (territory-keys game))
  -       for player in (players-round game)
  +       for player in (%players-round game)
          for territory in territories do
  -       (setf (owner (territory game territory)) player)
  -       (setf (armies (territory game territory)) 1)))))
  +       (setf (%owner (territory game territory)) player)
  +       (setf (%armies (territory game territory)) 1)))))
   
   (defgeneric claim (game territory)
     (:method ((game game) territory-key)
      (let ((territory (territory game territory-key)))
        (when (owner territory)
          (error "El territorio ya tiene dueño"))
  -     (setf (owner territory) (turn-player game))
  -     (setf (armies territory) 1))))
  +     (setf (%owner territory) (turn-player game))
  +     (setf (%armies territory) 1))))
   
   (defgeneric reset-movable-armies (game)
     (:method ((game game))
      (loop for territory being the hash-values in (territories game) do
  -         (setf (movable-armies territory) (armies territory)))))
  +         (setf (%movable-armies territory) (armies territory)))))
   
   (defgeneric move-armies (game from to amount)
     (:method ((game game) origin-key destination-key amount)
  
positive.code:   ((game-map nil r)
     (game-fsm nil r)
     (players (make-hash-table :test 'equalp) r)
     (players-round nil a)
     (turn-player nil)
     (pending-armies nil a)))
  
  (defmethod initialize-instance :after ((game game) &rest rest
                                                     &key game-map players)
    (declare (ignorable rest))
    (with-slots ((the-game-map game-map)
                 (the-players players)
                 (the-players-round players-round)
                 (the-turn-player turn-player)
                 (the-fsm game-fsm)
                 (the-pending-armies pending-armies)) game
      (setf the-game-map
            (typecase game-map
              (game-map game-map)
  
negative.code:        (error "No se pueden mover 0 o menos ejércitos"))
       (unless (>= (movable-armies origin) amount)
         (error "No hay suficientes ejércitos"))
       (decf (%movable-armies origin) amount)
       (decf (%armies origin) amount)
       (incf (%armies destination) amount))))
  
  (defgeneric place-armies (game where amount)
    (:method ((game game) territory-key (amount integer))
  