#lang scheme

(require (lib "world.ss" "htdp"))

;                                               
;                                               
;                                               
;          ;                                    
;          ;                                    
;          ;                                    
;    ;;;   ;   ;;;    ;;;    ;;;    ;;;    ;;;  
;   ;   ;  ;  ;   ;  ;   ;  ;   ;  ;   ;  ;   ; 
;   ;      ;      ;  ;      ;      ;   ;  ;     
;   ;      ;   ;;;;   ;;;    ;;;   ;;;;;   ;;;  
;   ;      ;  ;   ;      ;      ;  ;          ; 
;   ;   ;  ;  ;  ;;  ;   ;  ;   ;  ;   ;  ;   ; 
;    ;;;   ;   ;; ;   ;;;    ;;;    ;;;    ;;;  
;                                               
;                                               
;                                               

(define figure%
  (class object%
    (init-field (image empty) (x 0) (y 0))
    
    (define/public (touche? autre-figure)
      (and (< (abs (- x (send autre-figure getX))) (send this getLargeur))
           (< (abs (- y (send autre-figure getY))) (send this getHauteur))))   
    
    (define/public (monte)
      (cond [(> y (+ (/ (send this getHauteur) 2) 10)) 
             (set! y (- y 10))]))
    
    (define/public (descend)
      (cond [(< y (- HAUTEUR (+ (/ (send this getHauteur) 2) 10)))
             (set! y (+ y 10))]))
    
    (define/public (getX) x)
    (define/public (getY) y)
    (define/public (setX new-x)
      (set! x new-x))
    (define/public (setY new-y)
      (set! y new-y))
    (define/public (getImage) image)
    (define/public (setImage new-image)
      (set! image new-image))
    (define/public (getLargeur) (image-width image))
    (define/public (getHauteur) (image-height image))
    (super-new)))

(define mobile%
  (class figure%
    (init-field (dx 0) (dy 0))
    
    (define/public (deplace dans-jeu)
      (begin
        (send this setX (+ (send this getX) dx))
        (send this setY (+ (send this getY) dy))))
    
    (define/public (getdX) dx)
    (define/public (getdY) dy)
    (define/public (setdX new-dx)
      (set! dx new-dx))
    (define/public (setdY new-dy)
      (set! dy new-dy))
    (super-new)))

(define mobile-rebondissant%
  (class mobile%
    (inherit 'deplace)
    (rename-super [super-deplace deplace])    
    
    (define/override (deplace dans-jeu)
      (let ([x (send this getX)]
            [y (send this getY)]
            [dx (send this getdX)]
            [dy (send this getdY)]
            [h (send this getHauteur)]
            [l (send this getLargeur)]
            [rg (jeu-mobile-gauche dans-jeu)]
            [rd (jeu-mobile-droit dans-jeu)]) 
        (begin
          (cond 
            [(or (and (> y (- HAUTEUR (+ (/ h 2) 5))) (> dy 0)) 
                 (and (< y (+ (/ h 2) 5)) (< dy 0)))
             (send this setdY (- dy))]
            [(or (and
                  (and (> x (- LARGEUR (+ (/ l 2) 10))) (> dx 0)) 
                  (send this touche? rd))
                 (and 
                  (and (< x (+ (/ h 2) 10)) (< dx 0))
                  (send this touche? rg)))
             (send this setdX (- dx))])
          (super-deplace dans-jeu)
          )))
    
    (super-new)))

(define joueur%
  (class mobile%
    (init-field (temps-reaction 2) (inertie 1))
    
    (define/public (joue avec-balle)
      (cond [(visible? avec-balle)
             (strategie avec-balle)]))
    
    (define/private (visible? figure)
      (< (distance figure) (/ (random LARGEUR) 1.2)))
    
    (define/private (strategie avec-balle)
      (let ([d (distance avec-balle)])
        (if (= compteur-temps-inertie 0)        
            (if (< compteur-temps-reaction temps-reaction)
                (set! compteur-temps-reaction (+ compteur-temps-reaction 1))
                (begin
                  (set! compteur-temps-reaction 0)
                  (set! compteur-temps-inertie inertie)
                  (send this monte)
                  (cond [(> (distance avec-balle) d)
                         (begin
                           (send this descend)
                           (send this descend))]
                        [(= (distance avec-balle) d)
                         (send this descend)])))
            (set! compteur-temps-inertie (- compteur-temps-inertie 1))
            )))
    
    (define compteur-temps-reaction 0)
    (define compteur-temps-inertie 0)
    (define/private (distance figure)
      (let ([x1 (send this getX)]
            [y1 (send this getY)]
            [x2 (send figure getX)]
            [y2 (send figure getY)])
        (sqrt (+ (sqr (- x2 x1)) (sqr (- y2 y1))))))
    (super-new)))    

;                                                                        
;                                                                        
;                                                                        
;     ;          ;                                                       
;    ;            ;                                                      
;   ;              ;                                           ;         
;                                                              ;         
;   ;;;  ;;; ;;; ;;;  ;; ;;    ;;;  ;; ;;  ;;    ;;;  ;; ;;   ;;;;  ;;;; 
;  ;   ;  ;   ; ;   ;  ;;  ;  ;   ;  ;;  ;;  ;  ;   ;  ;;  ;   ;   ;   ; 
;  ;;;;;   ; ;  ;;;;;  ;   ;  ;;;;;  ;   ;   ;  ;;;;;  ;   ;   ;    ;;   
;  ;       ; ;  ;      ;   ;  ;      ;   ;   ;  ;      ;   ;   ;      ;; 
;  ;   ;   ; ;  ;   ;  ;   ;  ;   ;  ;   ;   ;  ;   ;  ;   ;   ; ; ;   ; 
;   ;;;     ;    ;;;  ;;; ;;;  ;;;  ;;; ;;; ;;;  ;;;  ;;; ;;;  ;;; ;;;;  
;                                                                        
;                                                                        
;                                                                        

(define (jeu-suivant j)
  (let ([balle (jeu-mobile-balle j)]
        [raquette-gauche (jeu-mobile-gauche j)])
    (begin
      (send balle deplace j)
      (send raquette-gauche joue balle)
      j)))

(define (affiche-jeu j)
  (let* ([image1
          (place-image (send (jeu-mobile-gauche j) getImage)
                       (send (jeu-mobile-gauche j) getX)
                       (send (jeu-mobile-gauche j) getY)
                       (empty-scene LARGEUR HAUTEUR))]
         [image2 
          (place-image (send (jeu-mobile-droit j) getImage)
                       (send (jeu-mobile-droit j) getX)
                       (send (jeu-mobile-droit j) getY)
                       image1)] 
         [image3
          (place-image (send (jeu-mobile-balle j) getImage)
                       (send (jeu-mobile-balle j) getX)
                       (send (jeu-mobile-balle j) getY)
                       image2)]) 
    image3)) 

(define (gestion-clavier j a-key-event)
  (begin
    (cond 
      [(key=? a-key-event #\a)
       (send (jeu-mobile-gauche j) monte)]
      [(key=? a-key-event #\q) 
       (send (jeu-mobile-gauche j) descend)]
      [(key=? a-key-event 'up) 
       (send (jeu-mobile-droit j) monte)]
      [(key=? a-key-event 'down) 
       (send (jeu-mobile-droit j) descend)]
      ))
  j)

;                    
;                    
;                    
;                    
;                    
;                    
;   ; ; ;   ;  ; ;;  
;   ;;  ;   ;  ;;  ; 
;   ;   ;   ;  ;   ; 
;   ;   ;   ;  ;   ; 
;   ;   ;   ;  ;   ; 
;   ;   ;   ;  ;   ; 
;   ;    ;;;;  ;   ; 
;                    
;                    
;                    

(define-struct jeu (mobile-gauche mobile-droit mobile-balle))

(define LARGEUR 500)
(define HAUTEUR 300)

(big-bang LARGEUR HAUTEUR 0.01 (make-jeu
                                (new joueur% (image (rectangle 10 40 'solid 'red)) (x 10) (y (/ HAUTEUR 2)))
                                (new mobile% (image (rectangle 10 40 'solid 'green)) (x (- LARGEUR 10)) (y (/ HAUTEUR 2))) 
                                (new mobile-rebondissant% (image (circle 5 'solid 'black)) (x 100) (y 100) (dx 2.5) (dy 2))))

(on-tick-event jeu-suivant)
(on-redraw affiche-jeu)
(on-key-event gestion-clavier)