Un jugador de tenis debe hacer un servicio pero con una técnica le bajaron la fuerza. Inicialmente el cálculo de las velocidades de la bola es:

Norma = Math.sqrt(DistanciahastaObjetivoX*DistanciahastaObjetivoX+DistanciahastaObjetivoY*DistanciahastaObjetivoY);
BallXSpeed = DistanciahastaObjetivoX/Norma*-AlexFuerzadetiros;
BallYSpeed = DistanciahastaObjetivoY/Norma*-AlexFuerzadetiros;
BallZSpeed = 0;

y se aplica este diagrama que queremos mejorar:

Chispa = Inicio.
Verde = True.
Rojo = False.
Azul = Flujo incondicional.
Zona dentro de circulo = El caso que queremos resolver.
Edit: Veo que debería decir cosas como "¿Pasará?", porque el tiro aún no se hizo, la máquina está calculando cómo debe hacerse, pero pronto debo irme así que no quiero editar eso.
También dice tiros VP pero entiéndanlo como V, V importa más que P, abajo explico.

Normalmente la bola pasaría la red, pero en este caso no. En el juego hay en principio 2 tipos de servicio: Veloz y Profundo. En casos como este, en un tiro V las velocidades serían recalculadas de modo que el tiro pase y sea in, no importa cuan profundo bote. En los P sí, se quiere profundidad, por lo que el tiro podría ser más lento y elevado. El ángulo se conserva a menos que no haya otra manera de que el tiro sea in, eso viene más adelante.

Pensando cómo resolver este caso para un tiro V, hice esto:

En la 2nda fila dice que con fuerza 1 lanzando desde punta a punta y con la máxima altura que puede el jugador, la bola pasaría por la red a una altura de -307.05, lo cual significa que no llegaría, no pasaría.
Ese número queremos que sea lo más cercano posible a 18.6, es la mínima altura conque la bola puede llegar a la red sin tocarla. Si es > que eso entonces parte de la fuerza se usó mal (recuerden lo del tiro tipo V), en lo posible no debe ocurrir, pero eso es mejor que obtener uno más bajo.

Fuerza está asignada en el juego.

BallZ when striked (ZInicial), es qué tan arriba se golpea a la bola.

Norma puse arriba cómo se calcula, depende de hacia a donde apunte el humano que juegue.

BallX Speed, BallY Speed y BallZ Speed también las dije arriba.

Duración hastared = REDONDEAR.MAS(248/VelocidadY), donde 248 es la distanciaY hasta la red.

BallZ when Reach Red = ZInicial-Duración*(Duración+1)/200+BallZSpeed*Duración
La velocidad de la bola hacia abajo (Z) aumenta 0.01 por frame, las fórmulas de Física no funcionan aquí porque por lo que vi en esas la 1era vez la velocidad disminuye la mitad de lo normal.

En las filas de abajo se modifica la duración y se recalculan las velocidades. Buscando el valor más óptimo de "BallZ when Reach Red".
Cuando la duración "incrementa 0", el resultado no puede empeorar, lo que sucede es que como en el juego sólo importan ciertos instantes (frames), entonces si la bola llegó un poco antes, digamos en 1.45 segundos, es irrelevante porque sólo se considerará el 1.4, 1.5, etc, entonces bajar un poco las velocidades XY da el mismo resultado y eso permite aumentar un poco la velocidad Z, haciendo que la bola vaya un poco más hacia arriba. Es lo que se quiere en este caso al fin y al cabo, que pase más arriba.
Resultado con fondo verde = El mejor hasta ahora (se mira desde arriba a abajo, el mejor de todos es el verde de más abajo).
Con fondo rojo = Empeoró.
Fondo amarillo = Mejoró pero no es lo mejor obtenido hasta ahora.
El método no lo programé pero sería algo como:
Si el resultado mejora:
  A la duración incrementarle el doble de lo que se incrementó antes.
sino
  Usar la duración intermedia entre la que dió el mejor resultado y la...
Pero este método parece muy largo, o puede serlo, además es medio en vano parece hacer tantos cálculos si no hay modo de que pase, habrá que acercar el target (apuntar más al medio y abajo), así que ¿qué otro puedo usar?

Supuestamente es este:
https://archive.org/details/isbn_9780022742928_0/mode/1up

Ahí parece que me pide registrarme, en otros lados no encontré por ahora.

Hay que pagar:
https://www.amazon.com/Using-Energy-Macmillan-McGraw-Hill-Science/dp/002276142X

Al cliquear en Want read me pide registrarme y dudo que sirva:
https://www.goodreads.com/book/show/1489831.Using_Energy_Unit_42_Macmillan_McGraw_Hill_Science_grade_8

Cliquear en See 1 Edition fue casi inútil, no veo cómo leerlo.
https://www.thriftbooks.com/w/using-energy-unit-42-macmillan-mcgraw-hill-science-grade-8-science-turns-minds-on_mary-atwater/1016035/#edition=5866172

Un genio el muchacho, yo ni siquiera puedo encontrar el libro xD

En realidad no me refiero a algo tan profundo sino más bien a lo siguiente: Supongan un programa que en cierto punto tiene:

Ese "Mucho código" ¿la PC lo leyó desde que el programa se ejecutó o va cargando línea por línea sólo si lo necesita? El concepto de "lo leyó" es un poco vago, pero me imagino que algo de eso hay, no sería lo mismo esto:
"El programador me dice que si A==1 haga ciertas cosas, leeré cuales si es necesario: ¿A==1? No".
que esto:
"El programador me dice que si A==1 haga *lee rapidísimo un montón de cosas, medio así
https://youtu.be/AwC4sNXYXLA?t=3445 *
¿A==1? No, ah tonces leí en vano".
No es lo mismo darle un link que darle una base de datos enorme...

Supongan también que todo ese código, es decir incluyendo el if, se va a ejecutar muchas veces.

Si las instrucciones dentro de un if se cargan o leen aunque no se usen ¿entonces es mejor que estén en un archivo externo, o en una función, o da igual?

En archivo externo:
Ahí lo que va a leer es poco salvo que deba cargar el archivo. Supongo que si el if se chequea mucho pero ocurre poco entonces conviene, pero cargar un archivo externo es más lento que si las instrucciones están en el código ¿no?

En una función:
Ahí no sé si (cuando el programa se transforma en código) donde dice función se sustituye por lo que sea esa función, para que sea más rápido, o no, para que ocupe menos espacio. Quizá depende del lenguaje, compilador, no sé ¿en general cómo es? ¿y en Macromedia Flash 5?
Si sólo se carga o lee "el link" ¿entonces es parecido a cargar un archivo externo? Pareciera, pero la función está en la RAM ¿no? ¿entonces convertirlo en función es incluso peor que dejarlo así nomás, ya que al definir la función se le da un nombre (ergo ocupa más memoria que sin nombre)?

El tema es que en Flash se cargan o leen frames y no quiero que se cargue o lea a cada rato más de lo necesario.

Respuesta de GPT:

¿Está bien seguir programando "normal" entonces?

En una duda como:
"En 1 < C ¿qué valor sería correcto dar a C?"
...hay una estructura de 2 variables y 1 candidato.

Un candidato es esencial en una duda, es lo que la resuelve. Si hubiera sólo variables no sería posible una duda de esa manera: "En 1 < 2 ¿qué valor sería correcto dar a C?", porque no hay C que deba cumplir algo. Sería posible una así:
"1 < 2 ¿es V o F?"
...pero no les veo la gracia, y son más complejas por tener 3 variables y 1 candidato.

Así, esta es la duda más simple que pude imaginar:
"En C C C ¿qué valor sería correcto dar a C?"
...porque la estructura en cantidad es la misma, pero sólo hay 1 tipo de cosa.
Puede haber algo de incoherente en esto porque la parte 2 se puede tomar "literal", es decir, así seria una solución: "==" == "=="
...pero me parece aceptable.

Quiero hacer un generador de dudas así, sé cómo generar una lista así:
1: C1 C1 C1
2: C1 C1 C2
3: C1 C1 C3
4: C1 C2 C1
5: C1 C2 C2
6: C1 C2 C3
etc
...pero hay muchas de esas dudas que serían iguales entre sí, quiero evitar que se generen iguales, además por ejemplo no tiene sentido que haya un C3 si no hay un C2. Y una duda en que todos los C sean distintos no tiene gracia (al menos según lo que vi) así que tampoco quiero de esas.

La ista la generaría haciendo algo como:
¿Cómo pongo las restricciones?

Es posible insertar tablas en Word, como las de Excel u otras. Yo uso esas otras a veces para menejar cómodo 2 textos como si fuesen 2 columnas, porque la función de usar 2 columnas suele darme problemas.

Así lo tengo con imágenes y textos que borré:


Imagen - Texto
Texto - Imagen
etc

En la 3era fila también tengo una imagen en la izquierda.

El tema es que quiero poner distintos tamaños a las columnas, y como ven eso ocurre en la 1er y 2nda fila, tienen columnas de tamaños distintos, pero cuando cambio el tamaño de la 2nda me cambia también el de la 4ta y cuando cambio el de la 3era me cambia el de la 5ta, no parece tener sentido. ¿Hay algún modo de que eso no ocurra, que pueda cambiar el tamaño de la que quiera sin que me cambien el tamaño de los demás?

Creo que si las separo, les cambio los tamaños y las vuelvo a unir quedan con tamaños independientes, así fue como logré que la 1era y 2nda sean diferentes, pero que la 2nda se haya conectado con la 4ta sin haberse conectado con la 3era es como medio random, además no recuerdo haberlas puesto del mismo tamaño, quizá cuando cambias una y otra es de tamaño parecido te la cambia también.
Sin embargo no quiero repetir ese proceso no sé cuántas veces cada vez que no se sabe por qué al programa se le antoje igualar los anchos.

¿Alguna otra alternativa?

A y B son casas de mis vecinos, M mi casa: ABM

Hace entre 2 y 3 días, robaron en la casa A.
Ayer o hoy, robaron en B.

Sí, es cierto, así es probable que roben en la mía, cosa que de hecho ocurrió más de una vez. Siempre tuve la duda de qué pasa en ese caso con mis cuentas. Yo entro en Chrome y estoy logeado. ¿Es algo que depende sólo del PC o para que ocurra debe ser también con el mismo router? Es decir, si me roban el PC y lo usan con otro router ¿mi cuenta estará activa, "estaré" logeado (aunque no sea yo)? ¿o al cambiar de router se pierde el logeo automático?

Si dejo de postear es porque tuve algún problema, es algo sobre lo que he leído alguna vez, que si a un forero le pasa algo ¿los otros lo sabrían? Yo no tengo familiares que sepan que hablo por aquí, por ejemplo, uds no se enterarían. Aquí hay casos de foreros que hace mucho que no veo postear. Uno supe que murió, tenía un avatar de Batman, espero que los demás estén bien.

Pensando la manera de jugar cierto juego (The Wizard's Castle, DOS, 1981) arriesgándose lo menos posible, y cómo describir eso, escribí esto:
Está incompleto, claro, mi lío para empezar es con los pisos. Normalmente se diría:
¿No?

¿Es posible dar esas instrucciones usando estados como puse antes, cómo, o no?

Estado 2: Te faltan ítems seguros y aún no has revisado todos los pisos.
La 2nda parte de eso es redundante, si te faltan no has revisado, pero de algún modo debo decir que debe irse a otros pisos cuando se tengan los ítems S del actual.

Lo reintento:

Estado 2: Te faltan ítems seguros (y aún no has revisado todos los pisos).

m, retry:

Estado 2: Te faltan ítems seguros del piso actual:
- Agarrarlos y luego ir al siguiente piso.

Estado 3: Has recorrido todos los pisos (ergo deberías tener todos los ítems S):

m, retry:

Estado 2: No has recorrido todos los pisos (ergo te faltan ítems S) y te faltan ítems seguros del piso actual:
- Agarrarlos e ir al siguiente piso.

Listo.

Es decir, parece que algo como:
Se convertiría en:
No me doy cuenta, puse cosas distintas.

Tenía:
Y se convierte en:
Estado 2: No has recorrido todos los pisos (ergo te faltan ítems S) y te faltan ítems seguros del piso actual:

¿Cual es la lógica, si es que la hay, tiene que ver una cosa suficiente con la otra o...?

A ver algo más simple:
Pero esto en realidad puede ser un sólo while con 2 condiciones... ¿lo mío también?


Ya... ¿entonces "programar" con estados es tan parecido a usar whiles, por qué al principio no parecía? 

A continuación 2 funciones iguales hasta la marca roja y que son usadas en un mismo programa:

Obviamente no se ve todo, pero no creo que importe, lo importante es que quiero convertir lo repetido (verde y amarillo) en una misma función, pero así como está termina (rojo) en medio de un if (que empezó en la zona amarilla, donde todo aún es igual). ¿Es posible hacer una función que incluya lo amarillo o debo conformarme con incluir sólo lo verde?

Por si a alguien le interesa, las diferencias entre los códigos son:
1- El izquierdo crea variables en ciertos casos, hasta llegar a 15, y el otro nunca.
2- El izquierdo en cierto punto deja de ejecutarse y ejecuta al otro. Ese cuando deja de ejecutarse da un mensaje y termina el programa.
Básicamente eso.

Hace poco hice un tema similar:
https://foro.elhacker.net/programacion_general/iquestcomo_los_numeros_se_producirian_mas_rapido_en_mflash_5-t520859.0.html
Pero este no es tanto sobre Flash, aquél más o menos ya lo resolví.

Este código produce dibujos negros y blancos:

   actions for fotograma 1
      PixelesdeLargo = 1;
      // En el frame 3 se repite:
      function Variar () {
         PixelaModificar = "ColordePixel"+Puntero;
         ColordePixelaModificar = eval(PixelaModificar);
         // ¿El pixel puede cambiar de color?
         if (ColordePixelaModificar<1) {
            // Sí, hacer los cambios:
            set (PixelaModificar, ColordePixelaModificar+1);
            Col = new Color("Pixel"+Puntero);
            Col.setRGB(parseInt(0, 16));
            // Para juzgar: ¿El dibujo es repetido?
            SumadePintados = SumadePintados+1;
            // ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
            if (Puntero/PixelesdeLargo == Math.floor(Puntero/PixelesdeLargo) or Puntero>MinPixelInferior) {
               // Sí, actualizar SumadePintadosNuevos:
               SumadePintadosNuevos = SumadePintadosNuevos+1;
            }
            // ¿El dibujo tiene píxeles donde no había en una hoja más chica...
            // y son al menos (PixelesdeLargo) píxeles?
            if (SumadePintadosNuevos>0 && SumadePintados>MinSumadePintados) {
               // Sí, hacer dibujo y dar tiempo para verlo:
               Puntero = MaxPosiciondePuntero;
               play ();
            } else {
               // No, el dibujo es repetido, no mostrarlo y hacer otro:
               Puntero = MaxPosiciondePuntero;
               Variar();
            }
         } else {
            // El pixel no puede cambiar de color, resetearlo:
            set (PixelaModificar, 0);
            Col = new Color("Pixel"+Puntero);
            Col.setRGB(parseInt("FFFFFF", 16));
            SumadePintados = SumadePintados-1;
            // ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
            if (Puntero/MaxPosiciondePuntero == Math.floor(Puntero/MaxPosiciondePuntero) or Puntero>MinPixelInferior) {
               // Sí, actualizar SumadePintadosNuevos:
               SumadePintadosNuevos = SumadePintadosNuevos-1;
            }
            // ¿Hay un pixel anterior?
            if (Puntero>1) {
               // Sí, apuntar a ese:
               Puntero = Puntero-1;
               // Continuar haciendo el dibujo:
               Variar();
            } else {
               // No, aumentar tamaño de hoja y reiniciar.
               gotoAndPlay (2);
            }
         }
      }
   actions for fotograma 2
      PixelesdeLargo = PixelesdeLargo+1;
      // Colocados:
      Pixeles = 0;
      DistanciaEntrePixeles = 384/PixelesdeLargo;
      PosicionX = 64-DistanciaEntrePixeles;
      EnlaFilaActual = 0;
      PosicionY = 0;
      MaxPosiciondePuntero = PixelesdeLargo*PixelesdeLargo;
      Puntero = MaxPosiciondePuntero;
      // Píxeles pintados:
      SumadePintados = 0;
      MinSumadePintados = PixelesdeLargo-1;
      MinPixelInferior = PixelesdeLargo*(PixelesdeLargo-1);
      // Píxeles pintados que no estaban en hojas de menos píxeles:
      SumadePintadosNuevos = 0;
      // Agregar píxeles en blanco:
      do {
         Pixeles = Pixeles+1;
         if (EnlaFilaActual<PixelesdeLargo) {
            EnlaFilaActual = EnlaFilaActual+1;
            PosicionX = PosicionX+DistanciaEntrePixeles;
         } else {
            PosicionX = 64;
            EnlaFilaActual = 1;
            PosicionY = PosicionY+DistanciaEntrePixeles;
         }
         trace ("El pixel "+Pixeles+" se colocó en "+PosicionX+", "+PosicionY);
         attachMovie("mPixel", "Pixel"+Pixeles, Pixeles);
         setProperty ("Pixel"+Pixeles, _x, PosicionX);
         setProperty ("Pixel"+Pixeles, _y, PosicionY);
         setProperty ("Pixel"+Pixeles, _width, DistanciaEntrePixeles);
         setProperty ("Pixel"+Pixeles, _height, DistanciaEntrePixeles);
      } while (Pixeles<MaxPosiciondePuntero);
      stop ();
   actions for fotograma 3
      stop ();
   actions for Vacío
      onClipEvent (enterFrame) {
         _level0.Variar();
      }
   actions for fotograma 4
      stop ();
   actions for fotograma 5
      gotoAndPlay (3);

La función se repite dentro de si misma, supongo que un do while sería mejor, no me di cuenta, pero ese no es el tema, el tema es que hago algo así:
Si ColordePixel4 puede colorearse, hacerlo y mostrar dibujo.
sino resetearlo. Si el 3 puede colorearse, hacerlo y mostrar dibujo.
sino resetearlo. Si el 2...
Y así hasta el 1.
Cuando hay más píxeles, eso se repite más veces.

¿Qué otro método más rápido sería mejor? ¿es posible, cómo? Me refiero a algo que varíe todo lo necesario sin tener que variar un puntero y repetir un while y estar reseteando 1 cosa a la vez...

Si un humano quiere escribir una lista así:
0001
0010
0011
0100
etc
No sé bien cómo se hace, pero es como que se mira dónde hay que sumar y si los valores a la derecha están al máximo se resetean. O sea, desde la izquierda se busca el 1er valor que no esté al máximo, se lo aumenta y se resetean los a la derecha suyo. Pero nosotros los humanos es como que no necesitamos mirar desde la izquierda, ya más o menos podemos anticipar en dónde estará el próximo número que debe aumentarse ¿o no?

No sé, a mí esa manera me resulta muy lenta, variando las cosas de a una, siento que debe haber algo mejor.

Una posibilidad sería hacer sumas normales y luego convertirlo en el valor que se precisa:
0 -> 0000
1 -> 0001
2 -> 0010
Hacer la conversión no creo que tarde mucho ¿pero si los posibles valores fuesen más de 9 o de 10? Por eso uso varias variables, no sólo 1. Uds supongo que usan arrays, pero creo que en el fondo es igual. Si son menos de 9 o 10 posibles valores la conversión es literal:
ColordePixel4 = Caracter4
ColordePixel3 = Caracter3
etc
Sino creo que se deben hacer operaciones matemáticas para cada uno y eso implica usar un do while...

Hay que inventar algo mejor o díganme qué hay que no sé xD

Para colmo, en el caso particular de los dibujos, tengo que variar unas variables y luego debo variar colores en base a ellas, creo que lo puedo hacer más rápido, pero el punto es que tendría que usar un do while también (edit: quizá no, probaré).

Tampoco es cuestión de estar haciendo los dibujos desde 0 en cada caso, yo intento que se varíen sólo los pixeles que deben variarse.

¿Ideas, info?

- Casos de (dar una instrucción mediante presionar cierto botón o algo similar):
En general: Mide la velocidad promedio conque el jugador presiona cierto botón.
El conteo es pausado (me refiero a que sólo cuenta como "caso" el momento en que se presionó un botón o se movió el mouse; si se presionó o movió y no se dejó de hacerse sólo cuenta como 1 caso, debe haber una pausa entre los "casos").
Ejemplo en que más valor implica más habilidad: Veces que aprendió o se burló del oponente (asumiendo que mientras lo hace se pone a si mismo en riesgo).
Ejemplo en que más valor implica menos habilidad: Veces que recurrió a activar un escudo.

- 1er frame (frame = instante con cierta duración, es una forma de medir el tiempo) en que ocurrió un caso de:
General: Cuánto tardó en presionar cierto botón por 1era vez.
Conteo pausado.
Habilidoso: Qué tan rápido empezó a correr luego de la señal.
Negativo: Qué tan rápido tuvo que frenar antes de llegar a la meta.

- Último frame en que ocurrió un caso de:
General: Cuánto tardó en presionar cierto botón por última vez.
Conteo pausado.
Habilidoso: Cuánto tiempo resistió antes de escapar, o cuan cerca estuvo de presionar el botón en el último momento posible (en juegos de Golf suele haber algo parecido a eso).
Negativo: Cuánto tiempo tardó en presionar el botón de aprender (si sobrevivió).

- Frames en que ocurrió un caso de:
General: Tiempo en que se estuvo presionando algo.
Conteo normal: Diferencias con respecto a "Casos de":
1: Si se hace una misma cosa más de una vez en un mismo frame (lo cual es casi imposible porque los frames cambian muy rápido; es posible por ejemplo si lo que se mide son los botones diferentes presionados al mismo tiempo, porque en ese caso pueden ser más de 1 a la vez), sólo cuenta como 1.
2: Aquí dejar presionado 1 botón durante 5 frames, por ejemplo, cuenta como 5 casos, no se necesita presionar-soltar.
Habilidoso: Si mantener presionado el botón implica desactivar un escudo.
Negativo: Si implica activarlo.

- Mínima duración de un caso de:
General: Se explica solo.
Conteo normal.
Habilidoso: Es así generalmente, presionar y rápidamente tener listo el dedo para presionar otra cosa, pero podría ser especialmente positivo si se debe golpear algo lo más suavemente posible y depende de cuánto tiempo se haya presionado el botón.
Negativo: Similar a lo anterior, difícilmente resulta negativo, el ejemplo podría ser en un juego en que se deba dar mucha energía a algo (mantener el botón presionado un tiempo) y darle poca sea un desperdicio (en juegos de automóviles no vale mucho porque, incluso acelerar durante un poquito es mejor que no acelerar).

- Máxima duración de un caso de:
General: Parece igual que "Frames en que ocurrió un caso de" pero eso cuenta la duración total y esto la máxima antes de una pausa.
Conteo normal.
Habilidoso: Si mantener presionado el botón implica desactivar un escudo.
Negativo: Si implica activarlo.

- Por frames, mínimos casos de:
General: Mínima velocidad de presión. Para hacer esto, cuando hay un frame en que no hubo presión se empieza a contar en cuántos más seguidos no la hubo. El conteo que resulte mayor es X. El resultado será "0 casos en X frames". Si se presionara en absolutamente cada frame (lo cual se supone imposible como ya expliqué), el resultado sería "X casos en X frames", y si además de eso a veces se presionara varias veces por frame, sería "VECES casos en 1 frame". Todo esto puede ser confuso pero es la mejor forma que se me ocurrió de hacerlo.
Conteo pausado.
Habilidoso (como de costumbre: Mayor valor es mejor): Cuando presionar rápido un botón hace que un golpe sea más fuerte.
Negativo: Dar la misma orden varias veces (asumiendo que es innecesario).

- Por frames, máximos casos de:
General: Máxima velocidad de presión. Para hacer esto, cuando hay un caso se empieza a contar cuántos frames se tardó en ocurrir otro. El conteo que resulte menor es N. El resultado será "2 casos en N frames". Si el caso ocurriera en cada frame, sería "X casos en X frames", y si además de eso a veces el caso ocurriera varias veces por frame, sería "VECES casos en 1 frame".
Conteo pausado.
Los ejemplos de antes son válidos.

- Mínima/máxima distancia (en frames) entre 2 casos de:
Este es un método peor de medir la velocidad mínima/máxima de eventos, ya que uno podría ocurrir en un mismo frame más de 1 vez. No le veo sentido a usarlo.

- En un mismo frame mínimos/máximos casos de:
Por si mismo es poco útil pero es complementario de lo anterior, pero el método que puse más arriba combina ambos, ergo tampoco le veo sentido a usar este.

Luego hay relaciones como:
Mínima distancia (en frames) entre una instrucción A y una B (asumiendo que puede ser 0 si ambas ocurrieron en un mismo frame).

Condiciones como:
Casos de A mientras A<B
donde A es una instrucción (presión de botón, etc).
e B es un número fijo u otra instrucción.

Y lo podemos mezclar con propiedades, como:
Casos de A mientras el largo de A<B

...pero eso lo pensaré luego.

En resúmen es:
- Casos en que se da cierta instrucción (debe haber pausa).
- 1er momento en que se da.
- Último momento en que se da.
- Tiempo en que se da la instrucción.
- Mínima duración conque se repite.
- Máxima duración conque se repite.
- Mínima velocidad conque se repite (debe haber pausa).
- Máxima velocidad conque se repite (debe haber pausa).

¿Qué me falta?