;; ========================================
;;  This is from lecture3:

;; --- Snake

; A snake is
;  (make-snake sym num sym)
(define-struct snake (name weight food))

; feed-snake : snake -> snake
;  To feed s five pounds
;(define (feed-snake s)
;  ... (snake-name s)
;      (snake-weight s)
;      (snake-food s) ...)
(define (feed-snake s)
  (make-snake (snake-name s)
              (+ 5 (snake-weight s))
              (snake-food s)))
; (feed-snake (make-snake 'slinky 12 'rats))
; "should be" (make-snake 'slinky 17 'rats)

;; --- Dillo

; A dillo is
;   (make-dillo num bool)
(define-struct dillo (weight alive?))

; force-feed-dillo : dillo -> dillo
;  Feeds d 2 lbs of food
;(define (force-feed-dillo d)
;  ... (dillo-weight d)
;      (dillo-alive? d) ...)
(define (force-feed-dillo d)
  (make-dillo (+ 2 (dillo-weight d))
              (dillo-alive? d)))
; (force-feed-dillo (make-dillo 2 true))
; "should be" (make-dillo 4 true)
; (force-feed-dillo (make-dillo 1 false))
; "should be" (make-dillo 3 false)

; feed-dillo : dillo -> dillo
;; feed d 2 lbs if d is alive
;(define (feed-dillo d)
;  ... (dillo-weight d)
;      (dillo-alive? d) ...)
(define (feed-dillo d)
  (cond
    [(dillo-alive? d) (force-feed-dillo d)]
    [else  d]))
; (feed-dillo (make-dillo 2 true))
; "should be" (make-dillo 4 true)
; (feed-dillo (make-dillo 1 false))
; "should be" (make-dillo 1 false)

;; ========================================
;;  New for lecture4 starts here:

; An ant is
;   (make-ant num posn)
(define-struct ant (weight loc))

;; ant-at-home? : ant -> bool
;;  Returns true if a is at (0,0), false otherwise
; (define (ant-at-home? a)
;   ... (ant-weight a)
;   ... (posn-at-home? (ant-loc a)) ...)
(define (ant-at-home? a)
  (posn-at-home? (ant-loc a)))
; Examples after posn-at-home?...

;; posn-at-home? : posn -> bool
;;   Returns true if p is (0,0), false otherwise
; (define (posn-at-home? p)
;   ... (posn-x p) ... (posn-y p) ...)
(define (posn-at-home? p)
  (and (= (posn-x p) 0)
       (= (posn-y p) 0)))
(posn-at-home? (make-posn 1 2)) "should be" false
(posn-at-home? (make-posn 0 0)) "should be" true

(ant-at-home? (make-ant 0.001 (make-posn 1 2)))
"should be" false
(ant-at-home? (make-ant 0.002 (make-posn 0 0)))
"should be" true



; feed-ant : ant -> ant
;  To feed a 0.001 lbs of food
;(define (feed-ant a)
;  ... (ant-weight a)
;  ... (feed-posn (ant-loc a)) ...)
(define (feed-ant a)
  (make-ant (+ 0.001 (ant-weight a))
            (ant-loc a)))
(feed-ant (make-ant 0.007 (make-posn 0 0)))
"should be" (make-ant 0.008 (make-posn 0 0))


; move-ant : ant num num -> ant
;  Move a by dx and dy
(define (move-ant a dx dy)
  (make-ant (ant-weight a)
            (move-posn (ant-loc a) dx dy)))

; move-posn : posn num num -> posn
;  Move p by dx and dy
(define (move-posn p dx dy)
  (make-posn (+ dx (posn-x p))
             (+ dy (posn-y p))))
(move-posn (make-posn 1 2) 6 7)
"should be" (make-posn 7 9)

(move-ant (make-ant 0.001 (make-posn 0 0))
          3 9)
"should be" (make-ant 0.001 (make-posn 3 9))

          

;; An animal is either
;;  - snake
;;  - dillo
;;  - ant

;; feed-animal : animal -> animal
;;  To feed a
(define (feed-animal a)
  (cond
    [(snake? a) (feed-snake a)]
    [(dillo? a) (feed-dillo a)]
    [(ant? a) (feed-ant a)]))

(feed-animal (make-snake 'slinky 10 'rats))
"should be" (make-snake 'slinky 15 'rats)
(feed-animal (make-dillo 2 true))
"should be" (make-dillo 4 true)
(feed-animal (make-ant 0.001 (make-posn 0 0)))
"should be" (make-ant 0.002 (make-posn 0 0))


;; Another example (not covered in lecture)

;; animal-bigger? : animal size -> bool
;;  Determines whether animal a is bigger
;;  than w pounds
;(define (animal-bigger? a w)
;  (cond
;    [(snake? a) ... (snake-bigger? a w) ...]
;    [(dillo? a) ... (dillo-bigger? a w) ...]
;    [(ant? a) ... (ant-bigger? a w) ...]))
(define (animal-bigger? a w)
  (cond
    [(snake? a) (snake-bigger? a w)]
    [(dillo? a) (dillo-bigger? a w)]
    [(ant? a) (ant-bigger? a w)]))

;;;; It would be ok to leave out the templates
;;;; below. Even though there's an extra argument,
;;;; these templates are essentially the ones
;;;; we've seen before.

;; snake-bigger? : snake num -> bool
;;  Determines whether s weighs more than w
;(define (snake-bigger? s w)
;  ... (snake-name s)
;  ... (snake-weight s)
;  ... (snake-food s) ...)
(define (snake-bigger? s w)
  (> (snake-weight s) w))
(snake-bigger? (make-snake 'slinky 10 'rats) 1)
"should be" true
(snake-bigger? (make-snake 'slinky 10 'rats) 11)
"should be" false
    
;; dillo-bigger? : dillo num -> bool
;;  Determines whether d weighs more than w
;(define (dillo-bigger? d w)
;  ... (dillo-weight d)
;  ... (dillo-alive? d) ...)
(define (dillo-bigger? d w)
  (> (dillo-weight d) w))
(dillo-bigger? (make-dillo 2 true) 1)
"should be" true
(dillo-bigger? (make-dillo 2 true) 10)
"should be" false
    
;; ant-bigger? : ant num -> bool
;;  Determines whether a weighs more than w
;(define (ant-bigger? a w)
;  ... (ant-weight d)
;  ... (posn-bigger? (ant-loc d) w) ...)
(define (ant-bigger? a w)
  (> (ant-weight a) w))
(ant-bigger? (make-ant 0.001 (make-posn 0 0)) 1)
"should be" false
(ant-bigger? (make-ant 0.001 (make-posn 0 0)) 0)
"should be" true
    
    
(animal-bigger? (make-snake 'slinky 10 'rats) 1)
"should be" true
(animal-bigger? (make-dillo 2 true) 1)
"should be" true
(animal-bigger? (make-ant 0.001 (make-posn 0 0)) 1)
"should be" false