#lang racket/gui

;;EL ESPACIO CELULAR ES UNA MATRIZ CUADRADA DE 46 x 46.
;;CADA AUTÓMATA PROCESA SEGÚN LAS REGLAS DE CONWAY.
;;LAS RELACIONES DE VECINDAD SON LAS DE MOORE.

(define oscilador
  (list
   (list 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 0)
   (list 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 0)
   (list 0 0 0 0 0 0 1 1 0 1 0 0 1 0 1 0 0 0 0 0)
   (list 0 0 0 0 0 0 1 1 0 1 0 1 0 0 1 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0)
   (list 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0)
   ))

(define glider
  (list
   (list 0 1 0)
   (list 0 0 1)
   (list 1 1 1)
   ))

(define xor-ini
  (list
   (list 0 0 1 0 0 0 0 0 1 0 0)
   (list 0 0 0 1 0 0 0 1 0 0 0)
   (list 0 0 1 1 1 1 1 1 1 0 0)
   (list 0 1 1 0 1 1 1 0 1 1 0)
   (list 1 1 1 1 1 1 1 1 1 1 1)
   (list 1 0 1 1 1 1 1 1 1 0 1)
   (list 1 0 1 0 0 0 0 0 1 0 1)
   (list 0 0 0 1 1 0 1 1 0 0 0)))

(define aux-ubica-figura-ini
  (lambda (c fig)
    (if (null? fig)
        '()
        (cons
         (let go ((m 0)
                  (n (add1 columnas))
                  (row '())
                  )
           (if (= m n)
               row
               (if (= m c)
                   (go (+ m (length (car fig))) n (append row (car fig)))
                   (go (add1 m) n (append row (list 0)))
                   )
               )
             )
         (aux-ubica-figura-ini c (cdr fig))
         )
        )
    ))

(define ubica-figura-ini
  (lambda (f c fig)
    (let go ((i 0)
             (j (add1 filas))
             (salida '())
             )
      (if (= i j)
          salida
          (if (= i f)
              (go 
               (+ i (length fig)) j 
               (append salida (aux-ubica-figura-ini c fig)))
              (let salta ((m 0)
                          (n (add1 columnas))
                          (row '())
                          )
                (if (= m n)
                    (go (add1 i) j (append salida (list row)))
                    (salta (add1 m) n (append row (list 0)))
                    )
                )
              )
          )
      )
    ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Matrices
(require "Matrices.rkt")

;;;Vecindad
;; Ver fichero: Reglas-vecindad.rkt
(define filas 49); 0 to 17
(define columnas 49);45); 0 to 17

(require "Reglas-vecindad.rkt")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Automatas
(define automata-celular%
  (class object%
    (field
     (estado 0)
     )
    (define/public set-estado
      (lambda (valor)
        (set! estado valor) ))
    (define/public get-estado
      (lambda ()
        estado ))
    (define son-1
      (lambda (inputs)
        (if (null? inputs)
            '()
            (if (= (car inputs) 1)
                (cons (car inputs) (son-1 (cdr inputs)))
                (son-1 (cdr inputs))
                )
            )
        ))
    (define/public procesar!
      (lambda (inputs)
        (let* ((total-1 (length (son-1 inputs)))
               (total-0 (- (length inputs) total-1))
               )
          (set! 
           estado
           (cond
             ((> total-1 total-0) 1)
             ((> total-0 total-1) 0)
             (else estado)
             )
           )
          )
        ))
    (super-new) ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define red-celular%
  (class object%
    (init-field
     (ff 0)
     (cc 0)
     )
    (define haz-automata
      (lambda ()
        (let ((cell (make-object automata-celular%))
              (valor-e (random 2))
              )
          (send cell set-estado valor-e)
          cell
          )
        ))
    (define set-matriz-automatas
      (lambda (matriz)
        (let rows ((i 0)
                   (j ff))
          (if (= i j)
              matriz
              (let columnas ((m 0)
                             (n cc))
                (if (= m n)
                    (rows (add1 i) j)
                    (begin
                      (matriz-set! matriz i m (haz-automata))
                      (columnas (add1 m) n))
                    )
                )
              )
          )
        ))
    (define es-configuracion
      (lambda ()
        (map
         (lambda (fila)
           (map
            (lambda (obj)
              (send obj get-estado)
              )
            (vector->list fila))
           )
         (vector->list matriz-automatas)
         )
        ))
    (field
     (matriz-automatas
      (set-matriz-automatas
       (make-matriz ff cc)) )
     (configuracion (es-configuracion))
     )    
    (define/public get-matriz
      (lambda ()
        matriz-automatas ))
    (define/public get-configuracion
      (lambda ()
        configuracion ))
    (define/public configuracion-inicial
      (lambda (conf)
        (let go ((i 0)
                 (j ff)
                 )
          (if (= i j)
              (set! configuracion (es-configuracion))
              (let salta ((m 0)
                          (n cc)
                          )
                (if (= m n)
                    (go (add1 i) j)
                    (begin
                      (send
                       (matriz-ref matriz-automatas i m vector-ref)
                       set-estado
                       (matriz-ref conf i m list-ref)
                       )
                      (salta (add1 m) n)
                      )
                    )
                )
              )
          )
        ))
    (define/public procesar!
      (lambda ()
        (let rows
          ((i 0)
           (j filas)
           )
          (if (= i j)
              (set! configuracion (es-configuracion))
              (let columns
                ((m 0)
                 (n columnas)
                 )
                (if (= m n)
                    (rows (add1 i) j)
                    (let*-values
                        ([(v1 v2 v3 v4 v5 v6 v7 v8) (Moore i m filas columnas)]
                         [(estado-v1)
                          (matriz-ref 
                           configuracion (car v1) (cdr v1) list-ref)]
                         [(estado-v2)
                          (matriz-ref 
                           configuracion (car v2) (cdr v2) list-ref)]
                         [(estado-v3)
                          (matriz-ref 
                           configuracion (car v3) (cdr v3) list-ref)]
                         [(estado-v4)
                          (matriz-ref 
                           configuracion (car v4) (cdr v4) list-ref)]
                         [(estado-v5)
                          (matriz-ref 
                           configuracion (car v5) (cdr v5) list-ref)]
                         [(estado-v6)
                          (matriz-ref 
                           configuracion (car v6) (cdr v6) list-ref)]
                         [(estado-v7)
                          (matriz-ref 
                           configuracion (car v7) (cdr v7) list-ref)]
                         [(estado-v8)
                          (matriz-ref 
                           configuracion (car v8) (cdr v8) list-ref)]
                         [(todos)
                          (list estado-v1 estado-v2 estado-v3 estado-v4
                                estado-v5 estado-v6 estado-v7 estado-v8)]
                         )
                      (send 
                       (matriz-ref matriz-automatas i m vector-ref) 
                       procesar! todos)
                      (columns (add1 m) n)
                      )
                    )
                )
              )
          )
        ))
    (super-new)
    ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define red (make-object red-celular% (add1 filas) (add1 columnas)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LAS FUNCIONES DE DIBUJO
;;; LAS HERRAMIENTAS GRÁFICAS
(define brocha-roja
  (make-object brush%
    "red"
    'solid))
(define brocha-blanca
  (make-object brush%
    "white"
    'solid))
;;; La ventana
(define ventana
  (make-object frame% 
    "Monitor del Juego de la vida" 
    #f 
    (+ 10 (* 10 (add1 columnas))) (+ 30 (* 10 (add1 filas)))
    1200 0))
;;; El lienzo
(define lienzo
  (instantiate canvas%
    (ventana)
    (style '(border))
    ))
(define dc (send lienzo get-dc))
;;; PROCEDIMIENTOS DE DIBUJO
(define pinta-una-fila
  (lambda (output x y hoffset)
    (cond
      ((null? output) )
      ((= (car output) 1)
       (send dc set-brush brocha-roja)
       (send dc draw-ellipse x y 10 10); x y x y);
       (pinta-una-fila (cdr output) (+ x hoffset) y hoffset))
      (else
       (send dc set-brush brocha-blanca)
       (send dc draw-ellipse x y 10 10);x y x y);
       (pinta-una-fila (cdr output) (+ x hoffset) y hoffset))
      ) ))
(define pinta-configuracion
  (lambda (configuracion)
    (do
        ((voffset 0 (+ voffset 1)) 
         (config configuracion (cdr config))
         )
      ((null? config) #t)
      (pinta-una-fila (car config) 0 (* voffset 10) 10)
      )
    ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define grid
  (lambda (dc)
    (let* ((lapiz0 (send dc get-pen))
           (lapiz1 (make-object pen% "black" 4 'solid))
           (x1 (/ (* 10 (add1 columnas)) 2))
           (y1 (* 10 (add1 filas)))
           (x2 (* 10 (add1 columnas)))
           (y2 (/ (* 10 (add1 filas)) 2))
           )
      (send dc draw-line x1 0 x1 y1)
      (send dc draw-line 0 y2 x2 y2)
      )
    ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define driver
  (lambda (dc)
    (let go ((i 0)
             (j 50))
      (if (= i j)
          #t
          (begin
            (pinta-configuracion (send red get-configuracion))
            (if (< i 5)
                (begin (printf "Iteración: ~a~n" (add1 i)) (read-char) )
                #t
                )
            (send red procesar!)
            (sleep/yield (/ 1 columnas)); 0.2)
            (go (add1 i) j)
            )
          )
      )
    ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define configuracion-inicial-clock
  (ubica-figura-ini 19 13 oscilador))
(define configuracion-inicial-glider
  (ubica-figura-ini 23 24 glider))
(define configuracion-inicial-xor
  (ubica-figura-ini 21 20 xor-ini))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(send ventana show #t)
(sleep/yield 1)
;(grid dc)

(driver dc)
(sleep/yield 2)

;(send red configuracion-inicial configuracion-inicial-clock)
;(driver dc)
;(sleep/yield 2)
;
;(send red configuracion-inicial configuracion-inicial-glider)
;(driver dc)
;(sleep/yield 2)
;
;(send red configuracion-inicial configuracion-inicial-xor)
;(driver dc)
