;; CMPU101, Spring 2013
;; Lecture #14


(require 2htdp/universe)
(require 2htdp/image)

;  
; STRUCTS: Creating new compound data types.
; 
; The DEFINE-STRUCT special form is used to create a new data
; type that is a container for more than one piece of data.
; 
; GENERAL FORM OF DEFINING A STRUCT:
; 
; 1. Use the define-struct special form, which takes the name of        
;    the struct and a parenthesized list of fields as arguments.     
;    
;    E.g., to define a car struct with fields for max (speed), 
;    color, make, and model, you would type:
;    
;    (define-struct car (max col make mod))
;    
;    where    max: number      col, make, and mod: strings.
;    
; 2. This define-struct creates functions that you can use to 
;    make new car-structs, to access the fields of a particular 
;    struct, and to determine whether a given thing is a car.
;    
; 3. After my-car is defined, I can use the following functions 
;    to access the specific fields of my-car:
;    
;    (define my-car
;      (make-car 200 "green" "Toyota" "Corolla"))
;    
;    (car-max my-car)         ==> 200       ;; Yes, I'm dreaming
;    (car-color my-car)       ==> "green"
;    (car-make my-car)        ==> "Toyota"
;    (car-mod my-car)         ==> "Corolla"
;    


;  
; posns:
; 
;  The first struct we'll use is a built-in struct known as a
;  POSN that holds two numbers representing an (x,y) coordinate      
;  pair on a plane. There are 6 functions associated with posn's:
;  
;  ; (make-posn x y)        -> posn, where x: number, y: number
;  ; (posn-x p)             -> number, where p: posn
;  ; (posn-y p)             -> number, where p: posn
;  ; (set-posn-x! p number) -> Sets the posn-x field in p to number
;  ; (set-posn-y! p number) -> Sets the posn-y field in p to number 
;  ; (posn? z)              -> boolean, where z is anything
;  


;; Ex1: Recall that the distance between a point in the plane
;; and the origin is calculated as follows: 
;;                 (sqrt (+ (sqr x) (sqr y)))
;; 
;; Write a function that consumes a posn and calculates its 
;; distance from the origin.

; ;Contract: (dist-from-origin posn) -> number
; ;Header:   (define dist-from-origin (lambda (p) ...))
; ;Purpose:  Calculate distance from p to (0,0)
; 
; (define MY-POSN (make-posn 5 12))
; 
; ;Pre-function Tests:
; (check-expect (dist-from-origin (make-posn 3 4)) 5)
; (check-expect (dist-from-origin (make-posn 4 0)) 4)
; (check-expect (dist-from-origin (make-posn 0 6)) 6)
; (check-expect (dist-from-origin MY-POSN) 13)
; ;
; ;;Function definition:
; (define dist-from-origin 
;   (lambda (p)
;   








;;-----------------------

; ;; Ex2: Write a function posn=? that takes 2 posns as inputs and
; ;;      returns true only if the two are equal
; ; Contract: (posn=? posn posn) -> boolean
; ; Header:   (define posn=? (lambda (p q) ... ))
; ; Purpose:  Determines if p and q have the same x and y fields.
; 
; ; Pre-function tests:
; (check-expect (posn=? ...)
; (check-expect (posn=? ...)
; 
; ;; Function:
; 








;; 
;;-----------------------

; ;; Ex3: Write a function called swap-x-y that takes in a posn
; ;; and returns a posn with the coordinates of its input swapped.
; ; Contract: (swap-x-y posn) -> posn
; ; Header:   (define swap-x-y (lambda (p) ... )) 
; ; Purpose:  produce posn that has the x,y coordinates of p swapped.
; 
; ; Pre-function tests:
; (check-expect (swap-x-y ...)
;               
; ;; Function:
; 








;;-----------------------

; ;; Ex4: Write a function called add-posns that takes in 2 posns
; ;; and returns a posn whose x coordinate is the sum of the x 
; ;; coordinates and whose y coordinate is the sum of the y 
; ;; coordinates of the 2 input posns.
; 
; ; Contract: (add-posns posn posn) -> posn
; ; Header:   (define add-posns (lambda (p q) ... ))
; ; Purpose:  To return a posn that has the sum of the x and y 
; ;           coordinates of p and q
; 
; ;Pre-function tests:
; (check-expect (add-posns...) )
; 
; ;; Function:
; 




; Color:
; 
;  Another built-in struct is the color data type:
;  
;   (make-color red green blue alpha) -> color, where red, green,       
;                                        blue and alpha are numbers
;                                        between 0 to 255
;  
;  Functions available for the color data type:
;  
;   make-color, color-red, color-green, color-blue, color-alpha, 
;   color?, set-color-red!, set-color-green!, set-color-blue!,
;   set-color-alpha!
;     
;  The alpha field controls the transparency of the color, where the
;  default is 255, no transparency.
;  




;; Structs allow us to write functions that consume and produce
;; containers with a specific number of fields.
;;

; Write a function that generates a square and places it on an 
; empty scene. Use a random-number generator to create the color.

;----------------BEGIN SQUARE CONSTANTS--------- 
(define MODE "solid")
(define SIZE 400) ;; size of screen
(define MTSQ (empty-scene SIZE SIZE))
;-----------------END SQUARE CONSTANTS---------- 

;
; Contract: (ran-clr) -> color
; Header:   (define ran-clr (lambda () ...))
; Purpose:  To create a color object with random entries between
;           0 and 255 for red, green, and blue fields
; Prefunction tests by visual inspection.

(define UPPER 256)

; Function definition:
(define (ran-clr)
  (make-color
   (random UPPER) 
   (random UPPER) 
   (random UPPER)))  ;; Note: You can leave off the field for alpha

; Post-function printfs:
(printf "(ran-clr) => ~a~%" (ran-clr))
(printf "(ran-clr) => ~a~%" (ran-clr))
(printf "(ran-clr) => ~a~%" (ran-clr))

; Contract: (show-square) -> image
; Header:   (define show-square (lambda () ...))          
; Purpose:  randomly set color of square
; Pre-function tests: By visual inspection.

; Function definition:
(define show-square
  (lambda ()
    (place-image
     (square SIZE MODE (ran-clr))
     ;; SIZE/2 PUTS THE PIN-HOLE OF THE SQUARE AT THE CENTER OF THE SCENE.
     (/ SIZE 2)  ;; X-coordinate
     (/ SIZE 2)  ;; Y-coordinate
     MTSQ)
    )
  )

; Post-function printfs:
;(printf "(show-square) => ~a~%" (show-square))
;(printf "(show-square) => ~a~%" (show-square))
;(printf "(show-square) => ~a~%" (show-square))