   (newline)
   (insert "Monster #:")
   (let ((x (read)))
-    (if (not (and (integerp x) (>= x 1) (<= x *monster-num*)))
+    (if (not (and (integerp x) (>= x 1) (<= x orc-battle-monster-num)))
         (progn (insert "That is not a valid monster number.")
                (pick-monster))
-        (let ((m (aref *monsters* (1- x))))
+        (let ((m (aref orc-battle-monsters (1- x))))
           (if (monster-dead m)
               (progn (insert "That monster is already dead.")
                      (pick-monster))
               m)))))
 
 (defun init-monsters ()
-  (setf *monsters*
+  (setf orc-battle-monsters
         (map 'vector
              (lambda (x)
-               (funcall (nth (random (length *monster-builders*))
-                         *monster-builders*)))
-             (make-array *monster-num*))))
+               (funcall (nth (random (length orc-battle-monster-builders))
+                         orc-battle-monster-builders)))
+             (make-array orc-battle-monster-num))))
 
 (defun monster-dead (m)
   (<= (monster-health m) 0))
 (defun monsters-dead ()
-  (every 'monster-dead *monsters*))
+  (every 'monster-dead orc-battle-monsters))
 
 (defun show-monsters ()
   (newline)

    (map 'list
         (lambda(m)
           (or (monster-dead m) (monster-attack m)))
         *monsters*)
    (game-loop)))

(defun init-player ()
  (setf *player-health* 30)
  (setf *player-agility* 30)
  (setf *player-strength* 30))

(defun player-dead ()
  (<= *player-health* 0))

(defun show-player ()
  (newline)
  (insert "You are a valiant knight with a health of ")
  (insert *player-health*)
  (insert ", an agility of ")
  (insert *player-agility*)
  (insert ", and a strength of ")
  (insert *player-strength*))

(defun player-attack ()
  (newline)
  (insert "Attack style: [s]tab [d]ouble swing [r]oundhouse:")
  (case (read)
    (s (monster-hit (pick-monster)
                    (+ 2 (randval (ash *player-strength* -1)))))
    (d (let ((x (randval (truncate (/ *player-strength* 6)))))
         (insert "Your double swing has a strength of ")
         (insert x)
         (newline)
         (monster-hit (pick-monster) x)
         (unless (monsters-dead)
           (monster-hit (pick-monster) x))))
    (otherwise (dotimes (x (1+ (randval (truncate (/ *player-strength* 3)))))
                 (unless (monsters-dead)
                   (monster-hit (random-monster) 1))))))

(defun random-monster ()
  (let ((m (aref *monsters* (random (length *monsters*)))))
    (if (monster-dead m)
        (random-monster)
        m)))

(defun game-loop ()
  (unless (or (player-dead) (monsters-dead))
    (show-player)
    (dotimes (k (1+ (truncate (/ (max 0 orc-battle-player-agility) 15))))
      (unless (monsters-dead)
        (show-monsters)
        (player-attack)))
