/* ==========================================================
   LA BOLIVAR CON VOS · MOVIMIENTO
   Todo lo que se mueve: las animaciones (`@keyframes`), el paso de una
   pantalla a otra, la apertura y el ultimo repaso de «menos
   movimiento», que apaga el movimiento para quien lo pidio.

   Es la hoja 12 de 12 de la base, y la base la cargan TODAS las
   pantallas. El orden importa: van siempre en el orden numerado de
   `css/base/`, entre `tokens.css` y la hoja de cada pantalla.
   ========================================================== */

/* ============================================================
   APERTURA · la animacion de cuando abris la app
   Dura poco menos de un segundo y se va sola. Se ve una vez por
   visita, no cada vez que cambias de pantalla.
   ============================================================ */
/* El logo animado de la Agrupacion, traido del proyecto de Claude Design
   "Animación logo Simón Bolívar". Son tres capas apiladas (el contorno de
   Sudamerica, SIMON y BOLIVAR) sobre el amarillo de la marca. El dibujo
   completo mide 1080x1350, y la tinta ocupa 805x664 en el centro: por eso
   la escala se calcula contra esas medidas y no contra el lienzo.
   La coreografia (que capa entra cuando) esta en index.html. */
.apertura{
  position:fixed;inset:0;z-index:200;overflow:hidden;
  /* Amarillo PLENO, no el suave: es el fondo con el que fue dibujado
     el logo, y las tres capas estan hechas para ese amarillo. */
  background:var(--amarillo);
  display:flex;align-items:center;justify-content:center;
  transition:opacity var(--t-hoja) var(--sale)
}

.apertura::before{
  content:'';position:absolute;inset:0;pointer-events:none;
  background:radial-gradient(130% 100% at 50% 42%,
    rgba(255,255,255,.14) 0%, rgba(255,255,255,0) 60%, rgba(182,39,37,.07) 100%)
}

/* ============================================================
   ESQUELETOS DE CARGA

   Reemplazan al texto "Cargando...". La diferencia no es estetica:
   un cartel que dice cargando obliga a esperar sin saber que viene,
   mientras que ver la forma del contenido antes de que llegue hace
   sentir la espera mas corta, aunque dure lo mismo.

   La regla: el esqueleto tiene que tener la MISMA forma que lo que
   va a aparecer. Si no, cuando llega el contenido la pantalla salta.

   POR QUÉ EL BRILLO SE MUEVE CON transform Y NO CON background-position.

   Esto no es un detalle de purista: era el error más caro de la app.
   Antes el brillo era un degradado al que se le movía la posición de
   fondo. Mover un fondo obliga al navegador a REPINTAR el elemento
   entero en cada cuadro, y no hay forma de mandar eso a la placa de
   video. En la pantalla de inicio hay veintitrés esqueletos a la vez:
   eran veintitrés repintados por cuadro, sesenta veces por segundo,
   justo en el momento en que el teléfono está bajando y armando cuatro
   consultas. O sea que la animación puesta para que la espera se
   sintiera más corta era lo que la hacía más larga.

   Ahora el degradado vive en un ::after que cruza el bloque con
   translateX. Eso lo resuelve el compositor solo, sin repintar nada, y
   el hilo principal queda libre para lo único que importa mientras se
   carga: traer el contenido.
   ============================================================ */
@keyframes esqueleto-brillo{
  from{transform:translateX(-100%)}
  to  {transform:translateX(100%)}
}

/* Al terminar un bloque avisa la tarjeta entera. Nada de sonido: esto
   se usa en la biblioteca y en el aula.

   Antes era el borde titilando en rojo 2,4 segundos —tres vueltas de
   800 ms. Dos problemas. Uno: un borde de 1,5 px cambiando de color es
   casi invisible con el ojo puesto en otro lado, que es exactamente
   dónde está el ojo de alguien que estuvo veinticinco minutos leyendo.
   Dos: 2,4 segundos de titileo son largos como para ignorarlos y
   cortos como para atender, así que terminan molestando sin avisar.

   Ahora es un solo golpe: la tarjeta se levanta y se asienta, en
   400 ms. Un movimiento de la pieza completa se ve de reojo; un borde
   que cambia de color, no. Y el rojo se queda un momento más para que
   quien miró tarde entienda qué acaba de pasar.

   Es de los pocos lugares de la app donde el movimiento puede
   permitirse algo de gracia: pasa cada veinticinco minutos, es una
   pequeña celebración, y no hay nada que se esté interrumpiendo. */
@keyframes pomo-avisa{
  0%   {transform:scale(1)}
  38%  {transform:scale(1.025)}
  100% {transform:scale(1)}
}

/* ---- La aparición al desplazar ----
   Sin librerías: un IntersectionObserver y dos propiedades que la placa
   de video puede animar sola (transform y opacity). Nada de height ni
   top, que obligan a recalcular la página en cada cuadro.

   POR QUÉ BAJÓ DE 550 A 260 MILISEGUNDOS.

   Este es el movimiento que más se ve en toda la app: cada párrafo de
   «Quiénes somos» y del Consejo pasa por acá. Y llega en el peor
   momento posible —después de que la persona ya esperó a que bajara el
   contenido. Medio segundo más de espera, encima de una espera, se
   siente como que la app está lenta, no como que es elegante.

   Había además un error de curva: la opacidad usaba `ease`, que empieza
   despacio. O sea que en el primer tercio del recorrido casi no pasaba
   nada visible, y recién ahí el texto empezaba a aparecer. Arrancando
   rápido y frenando suave, 260 ms se leen como más presentes que 550
   con la curva blanda. No es una impresión: es que la persona ya puede
   empezar a leer mientras el otro todavía está apareciendo.

   El desplazamiento también bajó, de 18 a 10 píxeles. Con la duración
   corta, 18 se sentían como un empujón.

   EL ESCALONADO SE FUE DEL CSS. Estaba escrito con :nth-child, que
   cuenta TODOS los hermanos, no solo los que se animan: en el Consejo
   los .aparece están mezclados con elementos que no lo son, así que
   los retardos caían en la pieza equivocada, y del quinto en adelante
   ninguno tenía retardo y disparaban todos juntos con el primero.
   Ahora lo pone lectura.js, contando de verdad y solo entre las piezas
   que entran en la misma pantallada. */
.aparece{
  opacity:0;transform:translateY(10px);
  transition:opacity var(--t-hoja) var(--sale),
             transform var(--t-hoja) var(--sale)
}

.aparece.visible{opacity:1;transform:none}

/* Menos movimiento: se queda el fundido, se va el desplazamiento. La
   pieza igual avisa que llegó, pero no se corre de lugar. */
@media (prefers-reduced-motion:reduce) {
.aparece{transform:none;transition:opacity var(--t-medio) var(--sale)}

.aparece.visible{opacity:1}
}

/* AL IMPRIMIR, TODO SE VE.
   Estas dos pantallas son las que alguien imprime o guarda como PDF
   para pegar en la cartelera del centro. Al imprimir, el navegador no
   corre el observador: lo que no se reveló sale en blanco. Se imprimían
   dos hojas vacías con la cabecera arriba. */
@media print {
.aparece{opacity:1 !important;transform:none !important;transition:none !important}
}

@keyframes chat-late{0%,60%,100%{opacity:.3}30%{opacity:1}}

/* ============================================================
   EL MOVIMIENTO DE ESTUDIEMOS (13/9)

   Pedido por Máximo mirando una landing de referencia: no el diseño,
   el LENGUAJE de movimiento. Vive solo en esta pantalla, colgado de
   `.mov`, y a propósito no toca las curvas del resto.

   ESTO ROMPE UNA REGLA DE ARRIBA, Y ES A SABIENDAS. En :root dice
   «nada de interfaz pasa de 300 ms». Eso sigue valiendo para la
   interfaz —menús, hojas, lo que la persona abre—. Lo de acá no es
   interfaz: es la entrada a la pantalla y cosas que se revelan al
   leer, y lo pedido son 0,8 s para lo destacado. Si se siente lento en
   un celular real, se baja `--mov-destacada` y nada más.

   SIN GSAP. La referencia usa GSAP con ScrollTrigger, que son unos
   70 KB, y esta app ya baja 135 KB de código para mostrar 5 de datos:
   el navegador del lanzamiento es el de Instagram en un celular. Lo
   que hace ScrollTrigger acá son cuarenta renglones en la pantalla.

   Las duraciones, las curvas y las distancias son las de la
   referencia, en variables, para que no se escriban de nuevo a mano.
   ============================================================ */
/* En `.mov-entra` también: en Inicio lo que entra al llegar vive fuera
   de `.mov` (la zona de fondo), y sin esto la transición no tendría
   duración ni curva. */
.mov,.mov-entra{
  --mov-micro:    .2s;
  --mov-estandar:  .45s;
  --mov-destacada: .8s;
  --mov-bloque:    .35s;  /* era .6: es una lista donde se busca, no un hero */
  --mov-entra: cubic-bezier(0.16, 1, 0.3, 1);   /* lo que llega       */
  --mov-hover: cubic-bezier(0.4, 0, 0.2, 1);    /* lo que se va, hover */
  --mov-paso:  .08s;                             /* entre hermanos     */
}

/* La máscara del titular. `display:block` en las dos capas: el
   transform no se aplica bien sobre un inline. */
.mov-renglon,.mov-renglon > span{ display:block }

.mov-renglon{ overflow:hidden }

@media (prefers-reduced-motion:no-preference) {
/* 1. LA ENTRADA, SIN SCROLL. Primero el titular, después la bajada y
     el buscador (a 0,25 s), y al final las tarjetas del riel.
     `backwards` y no `both`: terminada la entrada, el transform vuelve
     a ser del hover. Con `both` la tarjeta quedaría clavada en su
     último cuadro y el hover dejaría de moverla. */
.mov .mov-renglon > span{
    animation:mov-sube-renglon var(--mov-destacada) var(--mov-entra) backwards
  }

/* Un titular de varios renglones (el grito de Inicio) entra de a uno. */
.mov .mov-renglon:nth-child(2) > span{ animation-delay:.08s }

.mov .mov-renglon:nth-child(3) > span{ animation-delay:.16s }

/* Lo que entra después va marcado en el HTML con su turno, y no
     colgado de la estructura: en Fichas hay una segunda bajada más
     abajo, y con `.mov > .bajada` también «entraría» esa. */
.mov [data-entra]{
    animation:mov-sube var(--mov-destacada) var(--mov-entra) .25s backwards
  }

.mov [data-entra="2"]{ animation-delay:.33s }

.mov [data-entra="3"]{ animation-delay:.41s }

/* La imagen o las tarjetas del hero: al final, asentándose. */
.mov [data-entra="final"]{
    animation:mov-asienta var(--mov-destacada) var(--mov-entra) .5s backwards
  }

/* Las herramientas NO usan la duración destacada (13/9, revisión de
     animaciones): son las puertas que se vienen a tocar, y con 0,5 s de
     espera y 0,8 de viaje la última se asentaba al segundo y medio. */
.mov .herramienta{
    animation:mov-asienta .35s var(--mov-entra) backwards;
    animation-delay:calc(.15s + var(--i, 0) * 40ms);
    transition:transform var(--mov-micro) var(--mov-hover),
               box-shadow var(--mov-micro) var(--mov-hover)
  }

.mov .herramienta:nth-child(2){ --i:1 }

.mov .herramienta:nth-child(3){ --i:2 }

.mov .herramienta:nth-child(4){ --i:3 }

/* 3. LOS BLOQUES QUE ENTRAN AL LLEGAR, UNA SOLA VEZ. La clase la pone
     el JS y la saca apenas terminó: mientras está puesta pisa la
     transición de la tarjeta, y el hover tiene que volver a ser suyo. */
.mov-entra{
    opacity:0;transform:translateY(12px);
    transition:opacity var(--mov-bloque) var(--mov-entra),
               transform var(--mov-bloque) var(--mov-entra)
  }

.mov-entra.mov-visto{ opacity:1;transform:none }
}

@keyframes mov-sube-renglon{ from{ transform:translateY(100%);opacity:0 } }

@keyframes mov-sube{ from{ transform:translateY(24px);opacity:0 } }

@keyframes mov-asienta{ from{ transform:scale(.96);opacity:0 } }

/* Al imprimir no corre nada: lo que no se reveló saldría en blanco. */
@media print {
.mov-entra{ opacity:1 !important;transform:none !important }

.mov-palabra{ opacity:1 !important }
}

/* El sello del ingreso se pega y la estrella salta (11/11/2026). Ver
   `.sello.se-pega` en 05-secciones. */
@keyframes sello-pegar{
  from{opacity:0;transform:rotate(-8deg) scale(1.12)}
  60%{opacity:1;transform:rotate(-1.5deg) scale(.985)}
  to{transform:rotate(-2.5deg) scale(1)}
}

@keyframes sello-chispa{
  from{transform:scale(0) rotate(-70deg)}
  70%{transform:scale(1.15) rotate(8deg)}
  to{transform:scale(1) rotate(0)}
}
