 (defun monster-dead (m)
   (<= (monster-health m) 0))
 (defun monsters-dead ()
-  (every #'monster-dead *monsters*))
+  (every 'monster-dead *monsters*))
 
 (defun show-monsters ()
-  (fresh-line)
-  (princ "Your foes:")
+  (newline)
+  (insert "Your foes:")
   (let ((x 0))
     (map 'list
          (lambda (m)
-             (fresh-line)
-             (princ "    ")
-             (princ (incf x))
-             (princ ". ")
+             (newline)
+             (insert "    ")
+             (insert (incf x))
+             (insert ". ")
              (if (monster-dead m)
-                 (princ "**dead**")
-                 (progn (princ "(Health=")
-                         (princ (monster-health m))
-                         (princ ") ")
+                 (insert "**dead**")
+                 (progn (insert "(Health=")
+                         (insert (monster-health m))
+                         (insert ") ")
                          (monster-show m))))
          *monsters*)))
 
-(defstruct monster (health (randval 10)))
+(defclass monster nil ((health (randval 10))))
 
 (defmethod monster-hit (m x)
   (decf (monster-health m) x)
   (if (monster-dead m)
-      (progn (princ "You killed the ")
-             (princ (type-of m))
-             (princ "! "))
-      (progn (princ "You hit the ")
-             (princ (type-of m))
-             (princ ", knocking off ")
-             (princ x)
-             (princ " health points! "))))
+      (progn (insert "You killed the ")
+             (insert (type-of m))
+             (insert "! "))
+      (progn (insert "You hit the ")
+             (insert (type-of m))
+             (insert ", knocking off ")
+             (insert x)
+             (insert " health points! "))))
 
 (defmethod monster-show (m)
-  (princ "A fierce ")
-  (princ (type-of m)))
+  (insert "A fierce ")
+  (insert (type-of m)))
 
 (defmethod monster-attack (m))
 
-(defstruct (orc (:include monster)) (club-level (randval 8)))
-(push #'make-orc *monster-builders*)
+(defclass orc (monster) ((club-level (randval 8))))
+(push 'make-orc *monster-builders*)
 
 (defmethod monster-show ((m orc))
-  (princ "A wicked orc with a level ")
-  (princ (orc-club-level m))
-  (princ " club"))
+  (insert "A wicked orc with a level ")
+  (insert (orc-club-level m))
+  (insert " club"))
 
 (defmethod monster-attack ((m orc))
   (let ((x (randval (orc-club-level m))))
-       (princ "An orc swings his club at you and knocks off ")
-       (princ x)
-       (princ " of your health points. ")
+       (insert "An orc swings his club at you and knocks off ")
+       (insert x)
+       (insert " of your health points. ")
        (decf *player-health* x)))
 
-(defstruct (hydra (:include monster)))
-(push #'make-hydra *monster-builders*)
+(defclass hydra (monster) ())
+(push 'make-hydra *monster-builders*)
 
 (defmethod monster-show ((m hydra))
-  (princ "A malicious hydra with ")
-  (princ (monster-health m))
-  (princ " heads."))
+  (insert "A malicious hydra with ")
+  (insert (monster-health m))
+  (insert " heads."))
 
 (defmethod monster-hit ((m hydra) x)
   (decf (monster-health m) x)
   (if (monster-dead m)
-      (princ "The corpse of the fully decapitated and decapacitated hydra
+      (insert "The corpse of the fully decapitated and decapacitated hydra
 falls to the floor!")
-      (progn (princ "You lop off ")
-              (princ x)
-              (princ " of the hydra's heads! "))))
+      (progn (insert "You lop off ")
+              (insert x)
+              (insert " of the hydra's heads! "))))
 
 (defmethod monster-attack ((m hydra))
   (let ((x (randval (ash (monster-health m) -1))))
-    (princ "A hydra attacks you with ")
-    (princ x)
-    (princ " of its heads! It also grows back one more head! ")
+    (insert "A hydra attacks you with ")
+    (insert x)
+    (insert " of its heads! It also grows back one more head! ")
     (incf (monster-health m))
     (decf *player-health* x)))
 
-(defstruct (slime-mold (:include monster)) (sliminess (randval 5)))
-(push #'make-slime-mold *monster-builders*)
+(defclass slime-mold (monster) ((sliminess (randval 5))))
+(push 'make-slime-mold *monster-builders*)
 
 (defmethod monster-show ((m slime-mold))
-  (princ "A slime mold with a sliminess of ")
-  (princ (slime-mold-sliminess m)))
+  (insert "A slime mold with a sliminess of ")
+  (insert (slime-mold-sliminess m)))
 
 (defmethod monster-attack ((m slime-mold))
   (let ((x (randval (slime-mold-sliminess m))))
-       (princ "A slime mold wraps around your legs and decreases your agility
+       (insert "A slime mold wraps around your legs and decreases your agility
 by ")
-       (princ x)
-       (princ "! ")
+       (insert x)
+       (insert "! ")
        (decf *player-agility* x)
        (when (zerop (random 2))
-         (princ "It also squirts in your face, taking away a health point! ")
+         (insert "It also squirts in your face, taking away a health point! ")
          (decf *player-health*))))
 
-(defstruct (brigand (:include monster)))
-(push #'make-brigand *monster-builders*)
+(defclass brigand (monster) ())
+(push 'make-brigand *monster-builders*)
 
 (defmethod monster-attack ((m brigand))
   (let ((x (max *player-health* *player-agility* *player-strength*)))
     (cond ((= x *player-health*)
-           (princ "A brigand hits you with his slingshot, taking off 2 health
+           (insert "A brigand hits you with his slingshot, taking off 2 health
 points! ")
            (decf *player-health* 2))
           ((= x *player-agility*)
-           (princ "A brigand catches your leg with his whip, taking off 2
+           (insert "A brigand catches your leg with his whip, taking off 2
 agility points! ")
            (decf *player-agility* 2))
           ((= x *player-strength*)
-           (princ "A brigand cuts your arm with his whip, taking off 2
+           (insert "A brigand cuts your arm with his whip, taking off 2
 strength points! ")
            (decf *player-strength* 2)))))
 

(defparameter *player-health* nil)
(defparameter *player-agility* nil)
(defparameter *player-strength* nil)

(defparameter *monsters* nil)
(defparameter *monster-builders* nil)
(defparameter *monster-num* 12)

(defun orc-battle ()
  (init-monsters)
  (init-player)
  (game-loop)
  (when (player-dead)
    (princ "You have been killed. Game Over."))
  (when (monsters-dead)
    (princ "Congratulations! You have vanquished all of your foes.")))

(defun game-loop ()
  (unless (or (player-dead) (monsters-dead))

      (unless (monsters-dead)
        (show-monsters)
        (player-attack)))
    (newline)
    (map 'list
         (lambda(m)
           (or (monster-dead m) (monster-attack m)))
