project1_joker.scm

;exercise 10
(define (twenty-one-joker strategy)
  (define (play-dealer customer-hand dealer-hand-so-far rest-of-deck)
    (cond ((> (best-total dealer-hand-so-far) 21) 1)
	  ((< (best-total dealer-hand-so-far) 17)
	   (play-dealer customer-hand
			(se dealer-hand-so-far (first rest-of-deck))
			(bf rest-of-deck)))
	  ((< (best-total customer-hand) (best-total dealer-hand-so-far)) -1)
	  ((= (best-total customer-hand) (best-total dealer-hand-so-far)) 0)
	  (else 1)))

  (define (play-customer customer-hand-so-far dealer-up-card rest-of-deck)
    (cond ((> (best-total customer-hand-so-far) 21) -1)
	  ((strategy customer-hand-so-far dealer-up-card)
	   (play-customer (se customer-hand-so-far (first rest-of-deck))
			  dealer-up-card
			  (bf rest-of-deck)))
	  (else
	   (play-dealer customer-hand-so-far
			(se dealer-up-card (first rest-of-deck))
			(bf rest-of-deck)))))

  (let ((deck (make-deck)))
    (play-customer (se (first deck) (first (bf deck)))
		   (first (bf (bf deck)))
		   (bf (bf (bf deck))))) )

(define (make-ordered-deck)
  (define (make-suit s)
    (every (lambda (rank) (word rank s)) '(A 2 3 4 5 6 7 8 9 10 J Q K)) )
  (se (make-suit 'H) (make-suit 'S) (make-suit 'D) (make-suit 'C) 'XX 'XX) )

(define (make-deck)
  (define (shuffle deck size)
    (define (move-card in out which)
      (if (= which 0)
	  (se (first in) (shuffle (se (bf in) out) (- size 1)))
	  (move-card (bf in) (se (first in) out) (- which 1)) ))
    (if (= size 0)
	deck
    	(move-card deck '() (random size)) ))
  (shuffle (make-ordered-deck) 54) )

(define (best-total hand)
  (define (rate-card card)
    (cond ((equal? card 'x) 12) 
          ((equal? card 'a) 11)
          ((equal? card '10) 10)
          ((equal? card '9) 9)
          ((equal? card '8) 8)
          ((equal? card '7) 7)
          ((equal? card '6) 6)
          ((equal? card '5) 5)
          ((equal? card '4) 4)
          ((equal? card '3) 3)
          ((equal? card '2) 2)
          (else 10)))
  (define (sort-hand hand)
    (cond ((empty? hand) '())
          ((= (length hand) 1) hand)
          ((> (rate-card (bl (first hand))) (rate-card (bl (last hand)))) (se (sort-hand (bl hand)) (last hand)))
          ((= (rate-card (bl (first hand))) (rate-card (bl (last hand)))) hand)
          (else (sort-hand (se (last hand) (sort-hand (se (bl (bf hand)) (first hand))))))))
  (define (bt-inner hand result)
    (cond ((empty? hand) result)
          ((equal? (bl (last hand)) 'a) (if (> (+ result 11) 21)
                                             (bt-inner (bl hand) (+ result 1))
                                             (bt-inner (bl hand) (+ result 11))))
          ((equal? (bl (last hand)) 'x) (if (= (length hand) 1)
                                            (if (< (- 21 result) 12)
                                                (bt-inner (bl hand) (+ result (- 21 result)))
                                                (bt-inner (bl hand) (+ result 11)))
                                            (if (> (- 21 result) 11)
                                                (bt-inner (bl hand) (+ result 11))
                                                (bt-inner (bl hand) (+ result 1)))))
          (else (bt-inner (bl hand) (+ result (rate-card (bl (last hand))))))))
  (bt-inner (sort-hand hand) 0))