Reconocedor de gestos táctiles: toques, deslizamientos, pellizcos y giros

1const lineas = require("fs").readFileSync(0, "utf8").split("\n");
2
3const MOVIMIENTO_MIN = 10;          // px: con menos, el dedo no se ha movido (es un toque)
4const PULSACION_LARGA = 500;        // ms
5const DOBLE_TOQUE_MS = 300;         // ms entre el final del primer toque y el principio del segundo
6const DOBLE_TOQUE_PX = 30;
7const VELOCIDAD_DESLIZAR = 0.5;     // px/ms: más rápido es deslizar; más lento, arrastrar
8const GIRO_MIN = 15;                // grados
9const ESCALA_AMPLIAR = 1.2, ESCALA_REDUCIR = 0.8;
10
11const coma = (x) => x.toFixed(2).replace(".", ",");
12const DIRECCIONES = { derecha: "hacia la derecha", izquierda: "hacia la izquierda", arriba: "hacia arriba", abajo: "hacia abajo" };
13
14/** El eje que domina el movimiento; en pantalla, la y crece hacia abajo. */
15const direccion = (dx, dy) => DIRECCIONES[Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? "derecha" : "izquierda") : dy > 0 ? "abajo" : "arriba"];
16
17/** Agrupa las líneas en gestos: cada uno, una lista de puntos [t, x, y] o [t, x1, y1, x2, y2]. */
18function leerGestos() {
19  const gestos = [];
20  lineas.forEach((bruta, i) => {
21    const linea = bruta.trim();
22    if (!linea) return;
23    if (linea === "gesto") {
24      gestos.push({ puntos: [], valido: true });
25      return;
26    }
27    const g = gestos[gestos.length - 1];
28    if (!g) {
29      console.log(`Línea ${i + 1}: fuera de un gesto`);
30      return;
31    }
32    const nums = linea.split(/\s+/).map(Number);
33    const anterior = g.puntos[g.puntos.length - 1];
34    if ((nums.length !== 3 && nums.length !== 5) || nums.some((n) => !Number.isFinite(n)) || (anterior && (anterior.length !== nums.length || nums[0] <= anterior[0]))) {
35      g.valido = false;
36    }
37    g.puntos.push(nums);
38  });
39  return gestos;
40}
41
42/** Un dedo: toque, pulsación larga, deslizar o arrastrar. */
43function unDedo(puntos) {
44  const [t0, x0, y0] = puntos[0], [t1, x1, y1] = puntos[puntos.length - 1];
45  const dur = t1 - t0, dx = x1 - x0, dy = y1 - y0, d = Math.hypot(dx, dy);
46  if (d < MOVIMIENTO_MIN) {
47    if (dur >= PULSACION_LARGA) return { texto: `pulsación larga en (${x0}, ${y0}) (${dur} ms)` };
48    return { toque: true, x: x0, y: y0, t0, t1, texto: `toque en (${x0}, ${y0})` };
49  }
50  const v = d / dur;
51  if (v >= VELOCIDAD_DESLIZAR) return { texto: `deslizar ${direccion(dx, dy)} (${Math.round(d)} px en ${dur} ms, ${coma(v)} px/ms)` };
52  return { texto: `arrastrar de (${x0}, ${y0}) a (${x1}, ${y1}) (${Math.round(d)} px en ${dur} ms)` };
53}
54
55/** Dos dedos: girar, pellizcar o desplazar, según cómo cambia el segmento que los une. */
56function dosDedos(puntos) {
57  const [, a1, b1, a2, b2] = puntos[0], [, c1, d1, c2, d2] = puntos[puntos.length - 1];
58  const antes = [a2 - a1, b2 - b1], despues = [c2 - c1, d2 - d1];
59  const largoAntes = Math.hypot(...antes), largoDespues = Math.hypot(...despues);
60  if (largoAntes === 0 || largoDespues === 0) return null;
61  let giro = ((Math.atan2(despues[1], despues[0]) - Math.atan2(antes[1], antes[0])) * 180) / Math.PI;
62  if (giro > 180) giro -= 360;
63  if (giro <= -180) giro += 360;
64  const escala = largoDespues / largoAntes;
65  // el centro de los dos dedos: si se mueve sin girar ni pellizcar, es un desplazamiento
66  const mx = (c1 + c2) / 2 - (a1 + a2) / 2, my = (d1 + d2) / 2 - (b1 + b2) / 2;
67  if (Math.abs(giro) >= GIRO_MIN) return { texto: `girar ${Math.round(Math.abs(giro))}° en sentido ${giro > 0 ? "horario" : "antihorario"}` };
68  if (escala >= ESCALA_AMPLIAR) return { texto: `pellizcar para ampliar (×${coma(escala)})` };
69  if (escala <= ESCALA_REDUCIR) return { texto: `pellizcar para reducir (×${coma(escala)})` };
70  if (Math.hypot(mx, my) >= MOVIMIENTO_MIN) return { texto: `desplazar con dos dedos ${direccion(mx, my)}` };
71  return { texto: "dos dedos sin gesto reconocido" };
72}
73
74function main() {
75  const gestos = leerGestos();
76  let previo = null;              // el último toque suelto, por si llega el segundo de un doble toque
77  let pendiente = null;           // su línea, que aún no se ha escrito
78  const escribir = (l) => {
79    if (pendiente) console.log(pendiente);
80    pendiente = null;
81    previo = null;
82    console.log(l);
83  };
84  gestos.forEach((g, i) => {
85    const n = i + 1;
86    if (!g.valido) return escribir(`Gesto ${n}: datos no válidos`);
87    if (g.puntos.length < 2) return escribir(`Gesto ${n}: hacen falta al menos 2 puntos`);
88    const r = g.puntos[0].length === 3 ? unDedo(g.puntos) : dosDedos(g.puntos);
89    if (!r) return escribir(`Gesto ${n}: datos no válidos`);
90    if (r.toque && previo && r.t0 - previo.t1 <= DOBLE_TOQUE_MS && Math.hypot(r.x - previo.x, r.y - previo.y) <= DOBLE_TOQUE_PX) {
91      pendiente = null;
92      escribir(`Gestos ${previo.n} y ${n}: doble toque en (${previo.x}, ${previo.y})`);
93      return;
94    }
95    if (r.toque) {
96      if (pendiente) console.log(pendiente);
97      previo = { ...r, n };
98      pendiente = `Gesto ${n}: ${r.texto}`;
99      return;
100    }
101    escribir(`Gesto ${n}: ${r.texto}`);
102  });
103  if (pendiente) console.log(pendiente);
104  console.log(`Gestos leídos: ${gestos.length}`);
105}
106
107main();