(defun dragon-n (string n)
  (if (equal n 0)
      string
      (dragon-n
       (format nil "~{~A~}"
           (loop for item in (coerce string 'list)
                    when (equal item #\a) collect "aRbFR"
                    when (equal item #\b) collect "LFaLb"
                    unless (or (equal item #\a) (equal item #\b)) collect item))
       (- n 1))))

(defclass d-screen
               ()
             ((dir :initarg :dir :initform nil)
              (x   :initarg :x   :initform nil)
              (y   :initarg :y   :initform nil)
              (ox  :initarg :ox  :initform nil)
              (oy  :initarg :oy  :initform nil)))

(defmethod right ((screen d-screen))
           (with-slots (dir) screen
             (if (equal dir 3)
                 (setf dir 0)
                 (incf dir))))

(defmethod left ((screen d-screen))
           (with-slots (dir) screen
             (if (equal dir 0)
                 (setf dir 3)
                 (decf dir))))

(defmethod forward ((screen d-screen))
           (with-slots (dir x y ox oy) screen
             (cond ((equal dir 0)
                    (setf oy y)
                    (decf y))
                   ((equal dir 1)
                    (setf ox x)
                    (incf x))
                   ((equal dir 2)
                    (setf oy y)
                    (incf y))
                   ((equal dir 3)
                    (setf ox x)
                    (decf x)))))

(defun strip-dragon (string)
  (remove #\a (remove #\b string)))

(defun render-dragon (string s)
           (let ((screen (make-instance 'd-screen :dir 0 :x 0 :y 0 :ox 0 :oy 0))
                 (sx (* 1/2 (aref (sdl:video-dimensions) 0)))
                 (sy (* 1/2 (aref (sdl:video-dimensions) 1))))
               (with-slots (dir x y ox oy) screen
                 (loop for item in (coerce string 'list)
                do (cond ((equal item #\L) (left screen))
                             ((equal item #\R) (right screen))
                             ((equal item #\F)
                              (progn
                                (forward screen)
                            (sdl:draw-line-* (+ (* ox s) sx) (+ (* oy s) sy) (+ (* x s) sx) (+ (* y s) sy))
                                (sdl:update-display))))))))

(defun dragon-display-loop (string s sizex sizey)
           (sdl:with-init ()
             (sdl:window sizex sizey)
             (render-dragon string s)
             (sdl:with-events ()
           (:quit-event () t)
               (:idle ()
                      (sdl:update-display)))))

;; run with something like (dragon-display-loop (strip-dragon (dragon-n "Fa" 10)) 1 640 480)