japonca/soru.lisp

(in-package :japonca)

(setf *random-state* (make-random-state t))

(defparameter *kelimeler* nil)
(defparameter *kelimeler-dosyası*
  (asdf:system-relative-pathname :japonca "kelime/kelimeler.txt"))

(defun kelimeleri-yükle (&optional (dosya *kelimeler-dosyası*))
  (setf *kelimeler*
        (okurla (okur dosya)
          (metni-yükle okur)
          (işle okur))))

(defun kullanıcı-cevap ()
  (let ((cevap (string-left-trim '(#\Space) (read-line))))
    (cond ((string= "" cevap) :çık)
          ((string= "？" cevap) :kopya)
          ((char= #\: (char cevap 0)) (read-from-string cevap))
          (t cevap))))

(defparameter *soru-sayısı* nil)

(defmethod kelime-soru :before (kelime tip)
  (when *soru-sayısı*
    (format t "~a. " *soru-sayısı*)))

(defmethod kelime-soru ((kelime kelime) (tip (eql :okunuş)))
  (block soru
    (let (cevap sonuç)
      (format t "~a nasıl okunur ? " (kanji kelime))
      (setf sonuç (loop :do (case (setf cevap (kullanıcı-cevap))
                              (:çık (return-from soru :çık))
                              (:kopya (format t "anlam: ~{~a~^, ~} : " (anlam kelime)))
                              (t (return (kana= kelime cevap))))))
      (when (not sonuç)
        (format t "yanlış. ~{~a~^、~} olmalı~%" (kana kelime)))
      sonuç)))

(defgeneric alıştırma (tip &key &allow-other-keys))

(defmethod alıştırma :before ((tip (eql :okunuş)) &key (baş 0) son sırayla (kelimeler *kelimeler*) &allow-other-keys)
  (when (null kelimeler)
    (setf kelimeler (kelimeleri-yükle)))
  (format t "Tanımlı kelimeler: ~d~%" (fill-pointer kelimeler))
  (when (not son)
    (setf son (length kelimeler)))
  (when (not sırayla)
    (format t "Aralık: ~d-~d, ~d kelime~%" baş (- son 1) (- son baş))))

(defmethod alıştırma ((tip (eql :okunuş)) &key (baş 0) son sırayla (kelimeler *kelimeler*) &allow-other-keys)
  (let ((yanlış 0) (doğru 0))
    (if (not sırayla)
        (loop :for *soru-sayısı* :from 1
              :for cevap := (kelime-soru (rastgele-kelime kelimeler :test #'kanji
                                                                    :baş baş :son son)
                                         :okunuş)
              :do (cond ((eq :çık cevap)
                         (format t "~d/~d~%" doğru (+ doğru yanlış))
                         (loop-finish))
                        ((not cevap) (incf yanlış))
                        (t (incf doğru))))
        (progn (kelimeleri-kar kelimeler)
               (loop :with *soru-sayısı* := 1
                     :for i :from 0 :below (length kelimeler)
                     :for cevap := (if (null (kanji (aref kelimeler i)))
                                       :geç
                                       (kelime-soru (aref kelimeler i) :okunuş))
                     :do (cond ((eq :çık cevap)
                                (format t "~d/~d~%" doğru (+ doğru yanlış))
                                (loop-finish))
                               ((not cevap) (incf yanlış))
                               (t (incf doğru)))
                         (unless (eq :geç cevap)
                           (incf *soru-sayısı*)))
               (kelimeleri-sırala kelimeler)))))

;; (defmacro soru-tanım (args &body beden)
;;   `(block soru
;;      (let (cevap sonuç)
;;        (format t "~a nasıl okunur ? " (kanji kelime))
;;        (setf sonuç
;;              (loop :do (case (setf cevap (kullanıcı-cevap))
;;                          (:çık (return-from soru))
;;                          (:kopya (format t "anlam: ~{~a~^, ~} : " (anlam kelime)))
;;                          (t (return (kana= kelime cevap))))))
;;        (when (not sonuç)
;;          (format t "yanlış. ~{~a~^、~} olmalı~%" (kana kelime))))))
;; (soru-tanım (kelime :okunuş)
;;             ;; (:doğru-cevap (kana kelime))
;;             (:soru "~a nasıl okunur ?" (kanji kelime))
;;             (:cevap
;;              (:kopya (format t "anlamı : ~a" (anlam kelime))
;;                      (setf cevap (kullanıcı-cevap))))
;;             (:d "doğru.~%")
;;             (:y "yanlış, doğrusu ~s.~%" (kana kelime)))

;; (defmethod cevap-kontrol ((kelime kelime) cevap fn))
;; (defmacro cevapla )

;; (defmethod kelime-soru ((kelime kelime) (tip (eql :okunuş)))
;;   (block soru
;;     (labels ((cevapla ()
;;                (let ((cevap (kullanıcı-cevap)))
;;                  (case cevap
;;                    (:çık (return))
;;                    (:kopya (format t "anlam: ~{~a~^, ~} : " (anlam kelime))
;;                     (cevapla))
;;                    (t (kana= kelime cevap))))))
;;       (format t "~a. ~a nasıl okunur ? " *soru-sayısı* (kanji kelime))
;;       (loop :for cevap := (kullanıcı-cevap)
;;             :do (case cevap
;;                   (:çık (return-from soru))
;;                   (:kopya (format t "anlam: ~{~a~^, ~} : " (anlam kelime)))
;;                   (t (return (kana= kelime cevap)))))
;;       (if (cevapla)
;;           (format t "doğru.~%")
;;           (format t "yanlış. ~{~a~^、~} olmalı~%" (kana kelime))))))