Para no hacer offtopic pregunto acá.

1- ¿Por qué alguien haría un archivo tan grande que luego le sea un problema abrirlo? ¿cómo es posible que hayan hecho eso? ¿fue una IA?

2- ¿Por qué alguien querría enseñar a que otros no puedan aprender de mirar sus códigos?
Si quiere enseñar, no debería tener problema en que vean sus códigos.
Si quiere ocultar lo que sabe, no le veo mucho la lógica a que diseñe un tutorial.
¿Cual es la explicación de que alguien actúe así?

Al googlear best dos games 1982 aparecen juegos que en otros sitios no figuran como de DOS, entonces no me sirve hacer eso. Por ejemplo aparece Wizardry II: The Knight of Diamonds, pero aquí no figura que sea de DOS:
https://www.mobygames.com/game/1304/wizardry-knight-of-diamonds-the-second-scenario/releases/
Además es un poco confuso que el 2 me aparezca antes que el 1.
Yo confío más bien en la lista de Moby Games:
https://www.mobygames.com/game/platform:dos/sort:date/page:1/
...pero no quiero elegir cualquiera de esos ni probar uno por uno hasta encontrar uno interesante, y si ordeno la lista por mejor calificación me aparecen unos 2 nomás, la mayoría de esos no tiene calificación. Por eso quiero recomendaciones.

En los juegos que busco se deben poder contar cosas, no sólo el tiempo. Por ejemplo este (aunque no es de DOS) me gusta pero quedaría descartado por eso:
https://www.youtube.com/watch?v=sTVX6h6v1OU
Porque en el fondo sólo se puede contar la cantidad de acciones innecesarias, o quizá las veces que se apagó un fuego que no era el que estaba más arriba, pero en fin, no hay muchas opciones. En Mario, por ejemplo, se puede contar la cantidad de saltos, de monedas agarradas, de enemigos vencidos, etc.

Una de las dudas más sencillas es: ¿Qué número es > 0?

Se puede expresar como: ... > 0
entendiendo que en los puntos suspensivos hay que poner un número.
Es lo mismo decirlo así: 0 < ...
Hay 1 número conocido, 1 comparador conocido, y 1 número que debe elegirse. Estructuralmente es A B C. Es una condición que debe cumplirse mediante elegir cierto valor, que según la duda puede ser A o C, pero como son lo mismo como ya expliqué, para simplificar asuman que lo elegible es A.

La duda también podría ser algo como 0 ... 2, en tal caso lo que debe elegirse sería un comparador, podemos decirles B A C.
C A B sería lo mismo.

Esas dudas se pueden complicar un poco si las condiciones que deben cumplirse son 2. Sin agregar valores ni comparadores las posibilidades son:

1a:
A B C
y/o
A C B
La y/o significa que la duda se resuelve si se cumple una condición y/o la otra.
En este caso cada cosa es un comparador (A el único elegible), pero cuando se compara es texto, por ejemplo:
... == "=="
... == "=="
Otras posibilidades pueden ser como esta en ese sentido o no. En estos casos los comparadores sólo pueden ser == o <>.

1b:
A B C
y
A C B
La y significa que deben cumplirse ambas condiciones.

2a:
A B C
y/o
B A C

2b:
A B C
y
B A C

3a:
A C B
y/o
B A C

3b:
A C B
y
B A C

¿De acuerdo? Es difícil para mí tener mucha idea de si lo que digo sobre esto tiene sentido o no, pero básicamente tenemos que lo de la derecha es igual a lo de la izquierda:
ABC   CBA
ACB   BCA
BAC   CAB
Lo que nos deja con 3 posibilidades, que al formar pares sólo pueden ser 3, y hay 2 relaciones posibles, por lo que son 3*2 posibilidades tal como en la lista que puse.

Ahora sería lo mismo pero agregando 1 valor, por ejemplo:
A B C
y/o
A D C
Pero en ese par de condiciones sólo puede haber una redundancia o una contradicción ¿no? Ejemplo de redundancia en relación y/o:
... <= 10
y/o
... < 10
Si B y C son conocidos entonces la condición alternativa no aporta, es más restrictiva que la anterior, está incluída en ella, no tiene sentido decirla.
Ejemplo de redundancia en relación y:
... < 10
y
... <= 10
Aquí es al revés: La condición más amplia no sirve, si A debe ser < 10 entonces no tiene sentido decir que también puede ser == 10.
Ejemplo de contradicción:
... < 10
y
... > 10
No puede ser < y > al mismo tiempo, es una contradicción. En una relación y/o esto debería convertirse a una única condición con comparador <>.

Teniendo en cuenta eso ¿cuales pares de estructuras de condiciones son válidas? ¿qué condiciones o reglas deben cumplir?

Se me ocurren:
- Si se mencionó la relación entre 2 variables, no hay que mencionar otra relación entre esas 2. Para las condiciones y/o mencionar la menos restrictiva y para las y mencionar las más.
- Si se dice que una incógnita es igual a una variable, no hay que dar más datos de la incógnita.

¿Qué otras se les ocurren?

Hace años en distintas circunstancias puse archivos en archivos rar y ya no recuerdo los passwords.

Googlé sobre eso, entré a una página que se veía sospechosa porque era promocional, recomendó Passper, se descargó free, y al momento de usarlo me querían cobrar.

Luego hice una búsqueda en el foro mostrando sólo temas y ordenando por lo más reciente 1ero, aquí está el resultado:
https://foro.elhacker.net/index.php?dummy=1;action=search2
Raro el link, pero en fin, lo que mejor me parece que se ajusta es esto:
https://foro.elhacker.net/buscador-t455711.0.html

https://foro.elhacker.net/buscador-t440262.0.html
o
https://foro.elhacker.net/buscador2-t440262.0.html;msg2033301#msg2033301
o
https://foro.elhacker.net/buscador-t440251.0.html

O podría ser esto:
https://foro.elhacker.net/buscador-t423741.0.html

Pero mejor confírmenme que siguen sirviendo, gratis, o díganme otro, gracias.

Si el código está en un archivo convertido a binario quizá sea complicado, pero imaginen esto:
Si es la 1era vez que el mouse se mueve:
  Anotar cuando se movió.
Si es la 1era vez que se hace clic:
  Anotar cuando se cliqueó.
etc, etc, chequeándose hasta... ¿que el programa se cierre, o qué? Supongan que se quiere saber cuando fue el 1er caso de cada evento, hasta que no ocurran todos o no termine el juego o lo que sea, no hay fin, a menos que se ponga otro if para que cuando hayan ocurrido todos los eventos deje de ejecutar todo ese código.

Sería bueno poder hacer:
Si es la 1era vez que el mouse se mueve:
  Anotar cuando se movió.
  Borrar este if.
Si es la 1era vez que se hace clic:
  Anotar cuando se cliqueó.
  Borrar este if.
etc, etc, es decir, puede ser que cuando va a ejecutarse el código, se haga una copia del mismo, y se borren cosas de esa copia; el código real queda intacto. ¿Es posible hacer eso en algún lenguaje?

En Flash hay una forma que se me acaba de ocurrir, pero es un poco impredecible cómo funciona:
Cuando se llega al punto de querer chequear cuando ocurre el 1er evento de algo, se inserta una película que tiene el if. Cuando el if se cumple, la película se autoelimina. La película puede ser vacía y sólo tener código, así que es algo ligero. Lo que digo que es impredecible es que no sé si su código se ejecuta antes o después del "main", pero en este caso no importa. Pruebo y les cuento.

Edit:
Correcto, así lo hice:
- Crear una película vacía y llamarle "Vacía".
- Crear otra, llamarle "Captar 1er movimiento", y ponerle la Vacía.
- A esa vacía ponerle el if para captar el 1er movimiento y que al cumplirse remueva a su padre (que es "Captar 1er movimiento").
- Donde se necesite, insertar (con attach, sino no es removible) "Captar 1er movimiento".

Para captar otras cosas repetir desde el 2ndo paso cambiando los nombres y códigos.

El problema es que, tal como lo programé, se deja de contar cuando se detecta que se dejó de presionar una tecla, así que si hay otra presionándose no la cuenta, o más o menos es lo que pasa:
Caso A: Presiono "A" y no la suelto, presiono "S" y no la suelto, suelto "A", deja de contar, luego reempieza.
Caso B: Presiono "A" y no la suelto, presiono "S" y no la suelto, suelto "S", deja de contar.

Quiero que el programa detecte cuántas teclas se están presionando, que cuente todas las presiones por frame en una misma variable (si hay 2 teclas presionándose, debe aumentar 2, por ejemplo), y que al soltar una deje de contar esa, no las demás. ¿Cómo puedo hacer?

Ah, importante: En el programa se distingue una presión, de los frames presionándose, es decir, si una tecla se presiona, eso cuenta como "Clac", presiones, pero la cantidad de clacs sólo aumenta si se suelta y se vuelve a presionar, en cambio "FramesClaqueando" aumenta en cada frame si se está presionando una tecla. Básicamente lo que me interesa es eso último, lo demás está bien. Miren lo relativo a Claqueando:

onClipEvent (load) {
	Moviendose = "No";
	Cliqueando = "No";
	Claqueando = "No";
	ActualXMouse = _level0._xmouse;
	ActualYMouse = _level0._ymouse;
}
onClipEvent (enterFrame) {
	// Frames:
	_level0.Frames = _level0.Frames+1;
	// Movimiento:
	// Si el mouse se movió:
	if (ActualXMouse != _level0._xmouse or ActualYMouse != _level0._ymouse) {
		_level0.FramesMoviendose = _level0.FramesMoviendose+1;
		// Si el mouse estaba quieto:
		if (Moviendose == "No") {
			Moviendose = "Sí";
			_level0.Movimientos = _level0.Movimientos+1;
		}
	} else if (Moviendose == "Sí") {
		// No se movió pero estaba moviéndose:
		Moviendose = "No";
		_level0.Frenadas = _level0.Frenadas+1;
	}
	ActualXMouse = _level0._xmouse;
	ActualYMouse = _level0._ymouse;
	// FramesCliqueando:
	if (Cliqueando == "Sí") {
		_level0.FramesCliqueando = _level0.FramesCliqueando+1;
	}
	// FramesClaqueando:
	if (Claqueando == "Sí") {
		_level0.FramesClaqueando = _level0.FramesClaqueando+1;
	}
}
onClipEvent (mouseDown) {
	Cliqueando = "Sí";
	_level0.Clics = _level0.Clics+1;
}
onClipEvent (mouseUp) {
	Cliqueando = "No";
	_level0.Desclics = _level0.Desclics+1;
}
onClipEvent (keyDown) {
	if (Claqueando == "No") {
		Claqueando = "Sí";
		_level0.Clacs = _level0.Clacs+1;
	}
}
onClipEvent (keyUp) {
	if (Claqueando == "Sí") {
		Claqueando = "No";
		_level0.Desclacs = _level0.Desclacs+1;
	}
}

Tengo varios, son fotos de algún emulador de NES. Quiero abrirlos a ver si los borro o no. Antes los abría sin problema, ahora ni con el visualizador de imágenes, ni Paint, ni Chrome, ni Flash. Abrí uno con un visualizador online, todo bien, pero no quiero abrir tantos así. Descargué Microsoft Photo Editor, que yo solía tener, y me dice que el formato es desconocido.

¿Hay alguna manera de cambiarle las extensiones a JPEG o algo así normal y que funcionen? ¿o qué programa debo usar? Yo nunca tuve Photoshop, no quiero algo pesado.

Intento hacer un generador de dibujos cada vez de más píxeles (2x2, 3x3, etc), por ahora solo negros con fondo blanco. Aquí se ve algo parecido:
https://www.youtube.com/watch?v=0x5fEw8LGP4

Quiero evitar que se generen dibujos repetidos. Para eso exijo a los dibujos 2 cosas (no es suficiente pero 1ero debo resolver esto):
1- La cantidad de píxeles pintados debe ser >= Píxeles que entran en el largo de la hoja. Si en la hoja puede haber 2x2, debe haber mínimo 2.
2- La cantidad de nuevos pixeles pintados debe ser > 0. Cuando la hoja es de 2x2, los nuevos (N) son:
ON
NN
Cuando es de 3x3 son:
OON
OON
NNN
Es decir, los del extremo derecho y los inferiores.

Intento que los cuente para así determinar si debe mostrar el dibujo o salteárselo, pero llega un punto en que la cifra no disminuye o aumenta cuando no debe, no sé, estoy viendo cual puede ser el problema.

   actions for fotograma 1
      PixelesdeLargo = 1;
      // En F3 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));
            trace ("Se pintó el pixel "+PixelaModificar);
            // 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;
            }
            trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
            // ¿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;
               trace ("\tMostrando dibujo.");
               // trace ("SumadePintados: "+SumadePintados);
               trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
               play ();
            } else {
               // No, el dibujo es repetido, no mostrarlo y hacer otro:
               Puntero = MaxPosiciondePuntero;
               trace ("\tRepetido, salteándolo.");
               // trace ("SumadePintados: "+SumadePintados);
               trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
               Variar();
            }
         } else {
            // El pixel no puede cambiar de color, resetearlo:
            set (PixelaModificar, 0);
            Col = new Color("Pixel"+Puntero);
            Col.setRGB(parseInt("FFFFFF", 16));
            trace ("Se reseteó el pixel "+PixelaModificar);
            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;
            }
            trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
            // ¿Hay un pixel anterior?
            if (Puntero>1) {
               // Sí, apuntar a ese:
               Puntero = Puntero-1;
               // Continuar haciendo el dibujo:
               trace ("\tHaciendo dibujo, apuntando al pixel anterior.");
               // trace ("SumadePintados: "+SumadePintados);
               trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
               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;
      // Esta variable parece eliminable pero antes era-1,
      // y podría ser que deba aumentar en ciertos casos:
      MinSumadePintados = PixelesdeLargo;
      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);
 

¿Cómo lo soluciono?

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