{- Animaciones 2D y 3D. Al ejecutar, ajustar el zoom y la velocidad, si es necesario. -} 

incluir Predefinido

{- Animacion 1 en 2D: Escribir una funcion movFigSec que dada una figura y una secuencia de puntos, mueve la figura a cada uno de los puntos de la secuencia -}
         
movFigSec :: Fig X (R X R)* -> Fig*
movFigSec (fig, secp) = [] si secp == []
                        o mover (fig, primero(secp)) : movFigSec (fig, resto(secp))   
                        
{- Ejemplo movFigSec ((color(circ(0.2), Azul)), [(0,0),(1,1),(1.5,1.5),(2,2),(2.5,2.5)] )  -}
   
{- se define ej1 definiendo la lista de puntos localmente con la funcion parab para que se facil cambiarla -}
   
parab :: N X R -> (R X R)*
parab (n, x) = (x, x^2 - 4) : parab(n-1, x+1)  si n > 0
          o []    

{- recorre  10 veces la parabola y = x^2 - 4 desde x = -5 -}

ej1 :: () -> Fig*
ej1 () =  movFigSec ((color(circ(0.2), Azul)), ls) 
    donde ls = parab(10,-5)  
       
{- se define una funcion xs que devuelve una lista de puntos de una parabola   -}       

{- La funcion secPares toma dos secuencias y devuelve la lista de los pares formados por los elementos de cada secuencia (primero,primero), (segundo, segundo), etc -}   

secPares :: Z* X Z* -> (Z X Z)*
secPares (as,bs) = [] si as == []
                 o [] si bs == []
                 o (primero(as),primero(bs)) : secPares (resto(as), resto(bs))
  
{- en ej3 la figura recorre los puntos dados por secPares -}
ej3 :: () -> Fig*
ej3 () = movFigSec  ((color(circ(0.2), Azul)), ls) 
       donde ls = secPares(multiplos(3,20), rango(1,20,1))
          
{- Como ejemplos, puede variarse la figura a desplazar, el color, la recta o la curve de la trayectoria, etc. 
Se pueden poner esos elementos como variables a pasar como parametros (abstraer)  -}   

{- Animacion en 3D: Escribir una funcion orbita que rote dos esferas en el rango de 0 a 360. El entero indica cuantas veces debe completar la orbita. 
Prober por ejemplo con orbita (10). -}   
                        
orbita :: Z -> Fig3D*
orbita (n) = rotarEsferas(rango(0,360,360/n))

rotarEsferas :: R* -> Fig3D*
rotarEsferas (rs) = [] si rs == []
                  o rotar3D(esferas(),(primero(rs),0,0)):rotarEsferas(resto(rs))

{- La funcion esferas es  -}

esferas :: () -> Fig3D
esferas () = juntar3D(color3D(esfera(2),Amarillo)
                     ,mover3D(color3D(esfera(1),Azul),(0,5,0)))



{- Probar con por ejemplo:  projectile(45,10,0,0,0.1). 45 es el angulo y el resto las posiciones de x e y -}

g :: () -> R
g () = 9.8

conj RPos = { x en R | x >= 0 }

posX :: R X RPos X RPos -> R
posX (alpha,v0,t) = v0 * cos(alpha) * t  
  
posY :: R X RPos X RPos X RPos -> R
posY (alpha, v0, y0, t) 
  = y0 + v0 * sen(alpha) * t - g() * t^2 / 2
  
  
projectile :: R X RPos X RPos X RPos X RPos -> Fig*
projectile (alpha, v0, t, y0, dt) 
   =  [] si y < 0
   o mover(color(circ(0.3),Rojo),(x,y)) 
       : projectile(alpha, v0, t + dt, y0, dt)
   donde x = posX(alpha, v0, t)
         y = posY(alpha, v0, y0, t)    
    


{----------------------- Programa: Jugador de basquetbol invisible -----------------------}
{--- Sugerencias: ejecutar moviendo() a la velocidad más lenta (60 ms)---}
{----------------------------------------------}
{- Definimos plano, aro, cancha (plano + aro) y pelota -}
{----------------------------------------------}
plano :: () -> Fig3D
plano () =  mover3D(color3D(prisma(20,0.1,20),rgb(238,208,157)),(0,0,-0.6))
{----------------------------------------------}
aro :: () -> Fig3D
aro () = juntar3D(aro3D,cilindro3D)
donde 	aro3D = mover3D(rotar3D(anillo(0.5,2,2),(0,90,0)),(0,4,6))
		cilindro3D = mover3D(juntarFigEn3D(circ(0.2), circ(0.2), 6),(0,6,3))
{----------------------------------------------}
cancha :: () -> Fig3D
cancha () = juntar3D(plano(),aro())
{----------------------------------------------}
pelota :: () -> Fig3D
pelota () = color3D(esfera(0.5), rgb(255,128,0))
{----------------------------------------------}
{- Funcion que describe la trayectoria de la pelota (como se va a mover)-}
trayectoria :: R -> R
trayectoria(x) = 0 si x < -6
      o -5 * (x + 6) * (x + 4) si (x >= -6 , x < -4)
      o -5 * (x + 4) * (2 + x) si (x >= -4, x < -2)
      o -0.5 * (x + 2) * (x - 6)
{----------------------------------------------} 
{- Funcion que indica la posicion de la pelota segun su trayectoria (como se mueve) -}
coordMov :: R* -> (R X R)*
coordMov(lista)= [] si lista == []
     o (primero(lista), trayectoria(primero(lista))):coordMov(resto(lista))
{----------------------------------------------}     
{- Animación de la pelota en la cancha -}
animacion::(R X R)* -> Fig3D* 
animacion(lista)=[] si lista == []
     o juntar3D(mover3D(pelota,(1,primero(lista)!1, primero(lista)!2)),cancha) : animacion(resto(lista))
donde pelota = pelota()
      cancha = cancha()
{----------------------------------------------}     
{- Programa principal -}
moviendo :: () -> Fig3D*
moviendo() = animacion(coordMov(a))
donde a = rango(-6,6,0.2)
{----------------------------------------------}

{-----------------------------------------------------------------------}


{- Otro de jugadores: PARA VER LA ANIMACIÓN EJECUTAR "animar()" EN EL INTÉRPRETE -}

forma:: R X R X R -> Fig3D*
forma(ancho,grado,color) = rotar3D(color3D(prisma(ancho,ancho,ancho),rgb(color,0,0)),(0,45,grado)) : forma(ancho,grado-1,color-5) si grado>0 o [] 

forma2:: R X R X R -> Fig3D*
forma2(ancho,grado,color) = mover3D(color3D(esfera(ancho),rgb(0,color,0)),(0,0,grado)) : forma2(ancho,grado-1,color-5) si grado>0 o [] 

animacion_:: R -> Fig3D*
animacion_(x) = 
unir(
mover3D(color3D(prisma(40,0.1,40),Verde),(10,10,0)):
mover3D(color3D(prisma(40,0.1,0.1),Blanco),(0,10,0)):
mover3D(color3D(prisma(23,0.1,0.1),Blanco),(8,3.5,0)):
mover3D(color3D(prisma(0.1,0.1,8),Blanco),(4,-8,0)):
mover3D(color3D(prisma(0.1,0.1,8),Blanco),(4,15,0)):
mover3D(color3D(prisma(7.1,0.1,0.1),Blanco),(0,3.5,2.5)):
mover3D(color3D(prisma(0.1,2.5,0.1),Blanco),(0,0,1.25)):
mover3D(color3D(prisma(0.1,2.5,0.1),Blanco),(0,7,1.25)):
rotar3D(mover3D(color3D(prisma(0.6,1.9,0.6),Azul),posGolero(x)),giroGolero(x)):
mover3D(color3D(prisma(0.6,1.7,0.6),Rojo),posJ01(x)):
mover3D(color3D(prisma(0.6,1.6,0.6),Rojo),posJ02(x)):
mover3D(color3D(prisma(0.6,1.8,0.6),Rojo),posJ03(x)):
mover3D(color3D(prisma(0.6,1.6,0.6),Rojo),posJ04(x)):
mover3D(color3D(esfera(0.22),Blanco),posPelota(x)):
mover3D(color3D(prisma(0.6,1.6,0.6),rgb(81,209,246)),posJ(x)):
[]
)
: animacion_(x-1) si x>0 o []


unir:: Fig3D * -> Fig3D
unir(l) = primero(l) si resto(l)==[]
o
juntar3D(primero(l),unir(resto(l)))


posPelota:: R -> R X R X R
posPelota(x) = (-1,6,2) si x<10 o 
(0,6.5,2) si x<12 o
(1.4,7,2) si x<20 o
(2.8,7.5,2) si x<30 o
(4.2,8,2) si x<40 o
(5.6,8.5,2) si x<50 o
(7,9,1.75) si x<60 o
(8.4,9,1.5) si x<70 o
(9.8,8.5,1.25) si x<80 o
(11.2,8,1) si x<90 o
(12.6,7.5,0.75) si x<100 o
(13,7,0.5) si x<103 o
(14,6,0.22)



posJ:: R -> R X R X R
posJ(x) = (14.3,6.3,0.8) si x<5
o
(14.3,6.3,1.2) si x<10
o
(14.3,6.3,0.8) si x<105
o
(15,6.8,0.8) si x<110
o
(16,7.3,0.8)

giroGolero:: R -> R X R X R
giroGolero(x) =(270,0,0) si x<10
o
(135,0,0) si x<20
o
(0,0,0)

posGolero:: R -> R X R X R
posGolero(x) =(0,5.7,0.3) si x<10 o
(0,5.5,0.95) si x<25 o
(0,4,0.95) si x<35 o
(0,3,0.95)

posJ04:: R -> R X R X R
posJ04(x) =(10,5,0.8) si x<70
o
(10,5,1.2) si x<82
o
(10,5,1)

posJ03:: R -> R X R X R
posJ03(x) =(10,5.65,0.9) si x<71
o
(10,5.65,1.2) si x<81
o
(10,5.65,0.9)

posJ02:: R -> R X R X R
posJ02(x) = (10,6.3,0.8) si x<68
o
(10,6.3,1.1) si x<80
o
(10,6.3,0.8)

posJ01:: R -> R X R X R
posJ01(x) = (10,7,0.85) si x<70
o
(10,7,1) si x<82
o
(10,7,0.85) 


animar:: () -> Fig3D*
animar() = animacion_(115)