No tengo idea cómo creaste un juego de esos, pero si editaste uno preexistente prueba editarle menos cosas, editarle de a una, probarlo, y así sucesivamente hasta que te falle. Cuando eso suceda, no necesariamente es por el último cambio, puede ser por 2 cosas que combinaste, es decir, quizá si sólo cambies esa sí funcione. Es una teoría, quizá me equivoco. Igual, puede que deje de funcionar casi al final, si es tan complicado no parece buena idea hacer juegos así.

Oí de algunos llenos de bugs, y yo descargué uno con un ips que, llegué casi al final y ya no puedo avanzar, no sé si hice algo mal, está traducido a medias, y sólo usé un save state así que me jodí... Uchiha cosmos o algo así se llama.

La flechita no me molesta, aunque tienes razón.

¿Qué opciones hay en AWicons?

Decidí tener distintos íconos porque no veo bien las letras y en definitiva así podría distinguir mejor qué es cada acceso directo, el problema es que muchas veces el resultado me resulta como una mancha digamos, no distingo qué es, es demasiado pequeño.

Ahora necesito uno que sea un medidor. Busqué imágenes y al achicarlas ya no veo la aguja ni casi nada. ¿Sugerencias en ese caso y en general?

Aquí se ven algunos de mis íconos:

Sólo me gusta el de la lupa y el de los cuadros negros, los demás son lo que quedó por ahora.

Uno es un caballo de ajedrez, un trofeo y un tubo de ensayo. Antes estaba en un fondo con una cascada así que el caballo se veía bien. Mejoraré alguna calidad cuando pueda.

Otro es una hoja con un burro delante. Le puse un borde blanco y otro negro al burro para que se vea mejor, originalmente lo hice transparente pero en el fondo que tenía no lo veía bien. La idea sería mejor un libro que en la tapa tenga al burro, pero me pareció imposible que pueda ver eso.

El de abajo es muchos libros y una mano, pero yo nada veo digamos, debo arreglarlo, poner sólo 1 pila de libros, la mano no, yo que sé.

Al billete le puse fondo amarillo porque transparente no lo veía en el fondo que tenía antes. Aún no probé ponerle muchos bordes, pero igual el signo de $ no lo veo bien.

El martillo, lo veo, pero el fondo que le puse no tiene mucho sentido, debo probarlo con transparencia y más contorno.

El robot pensando, no lo veo ni a palos. El fondo tampoco tiene mucho sentido.

Con el de Química Flash no publicaba la letra, así que después de luchar quedó pero así, igual no sé bien cómo mejorarlo, algunos detalles que le puse no se ven, bah.

Al de Cíclope debo ver cómo queda sin su fondo.

EDIT: Bueno, ya tengo un medidor. He aquí algunas claves, unas menos obvias que otras:
- Agregar ícono en la palabra a buscar puede ayudar.
- Reducir el zoom del navegador ayuda mucho ya que, de ese modo las imágenes se verán como se verían achicadas así que no hay que copiarlas, pegarlas, etc. Además ves muchas más imágenes enseguida.

Las cosas suelen ser más difíciles de lo que pensé, aunque luego parezca que no.

El programa genera dibujos en varios cuadros, separados con verde:

Hay 4x4 dibujos.

Luego, cuando el usuario cliquea un dibujo, se transmite a los demás pero con algunas mutaciones. Los de arriba-izquierda mutan menos y los de abajo-derecha mutan más (el cálculo para determinar cuántos mutan en cada dibujo me lo dijeron matemáticos, no lo entiendo bien, pero no importa aquí).

Creo que funciona bien, aquí está el código del clic:
Nota: Es importante diferenciar cuadro de cuadradito: Los cuadros son los dibujos separados con verde, los cuadraditos son digamos los píxeles (pero más grandes que un pixel) que contiene cada dibujo.

on (release) {
	// Los dibujos serán como el de encima de este botón:
	Dibujo = 1;
	ModificacionesRequeridas = 1;
	// Repetir para el dibujo 1, 2, etc:
	while (Dibujo < _level0.MaxCuadro+1) {
		// Este if es porque el dibujo a copiar no necesita...
		// ser modificado, eso sería como sustituirse por él mismo:
		if (Dibujo != _parent.ID) {
			Cuadradito = 0;
			// Repetir hasta que todo cuadradito se haya copiado:
			do {
				Cuadradito++;
				ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
				ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
				ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
			} while (Cuadradito<_level0.MaxCuadradito);
			// Los dibujos mutarán:
			// De cada dibujo copia, variar cuadraditos al azar,
			// de 1 hasta CuadraditosPorFila,
			// aumentando por dibujo hacia derecha y abajo:
			// Repetir hasta que se haya variado esa cantidad...
			// de cuadraditos:
			CuadraditosModificados = 0;
			do {
				// Para evitar que se modifique uno ya modificado,
				// los modificados se guardan en una lista,
				// y cuando se va a modificar uno se mira...
				// que no esté en la lista, sino se elige otro:
				do {
					trace("Se modificará un cuadradito del dibujo "+Dibujo);
					Repetido = "No";
					NroDeCuadraditoaCambiar = random(_level0.MaxCuadradito)+1;
					trace("El nro: "+NroDeCuadraditoaCambiar);
					trace("Se verá si ya fue modificado.");
					PunteroParaLista = 1;
					// Ver si NroDeCuadraditoaCambiar está en la lista de modificados:
					while (PunteroParaLista <= CuadraditosModificados) {
						trace("Comparando con el nro "+PunteroParaLista+" de la lista de modificados.");
						if (NroDeCuadraditoaCambiar == eval("CuadraditoModificado"+PunteroParaLista)) {
							Repetido = "Sí";
							PunteroParaLista = CuadraditosModificados+1;
							trace("Ya fue modificado, se elegirá otro.");
						}
						PunteroParaLista++;
					}
				} while (Repetido == "Sí");
				CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+NroDeCuadraditoaCambiar;
				trace("Ya se eligió uno no modificado, es: "+CuadraditoaCambiar);
				ColoraSustituirse = new Color(CuadraditoaCambiar);
				// A esto lo convierto a String porque...
				// lo debo comparar con un string y es más fácil así.
				SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
				// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
				// Repetir mientras el color no cambie:
				do {
					NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
				} while (NuevoColor == SavedeColoraSustituirse);
				ColoraSustituirse.setRGB(NuevoColor);
				// trace ("NuevoColor: "+NuevoColor);
				CuadraditosModificados++;
				// Agregar el cuadradito a la lista de modificados:
				set("CuadraditoModificado"+CuadraditosModificados, NroDeCuadraditoaCambiar);
			} while (CuadraditosModificados<ModificacionesRequeridas);
		}
		Dibujo++;
		if (ModificacionesRequeridas <= _level0.Resto) {
			ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
		} else {
		    ModificacionesRequeridas = Math.floor((Dibujo-1-_level0.Resto*(_level0.DistintasMutaciones+1))/(_level0.DistintasMutaciones))+1+_level0.Resto
		}
	}
}

Quiero agregar que cada dibujo resultante deba tener cierta cantidad de colores (3 en este caso), ni más ni menos. Eso implica que si los cuadraditos elegidos a modificarse son los únicos que tienen cierto color, deben elegirse otros (porque si cambian de color, habría menos colores, por ser los únicos que tenían ese color). Y eso, creo, implica que ya no conviene modificarlos a penas se seleccionan, porque si no son una elección válida entonces habría que volverlos al color anterior y eso parece más complicado y menos eficiente que irlos guardando en una lista y modificarlos recién cuando esté completa.
Tengo más o menos la idea de cómo hacerlo pero son tantos while (o no sé evitarlos) que me lié. El pseudocódigo yo diría que es:
Bueno, creo que está bien, hacer pseudocódigos puede simplificar la tarea veo, yo me había quedado así:

on (release) {
	// Los dibujos serán como el de encima de este botón:
	Dibujo = 1;
	ModificacionesRequeridas = 1;
	// Repetir para el dibujo 1, 2, etc:
	while (Dibujo < _level0.MaxCuadro+1) {
		// Este if es porque el dibujo a copiar no necesita...
		// ser modificado, eso sería como sustituirse por él mismo:
		if (Dibujo != _parent.ID) {
			Cuadradito = 0;
			// Repetir hasta que todo cuadradito se haya copiado:
			do {
				Cuadradito++;
				ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
				ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
				ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
			} while (Cuadradito<_level0.MaxCuadradito);
			// Los dibujos mutarán:
			// De cada dibujo copia, variarán cuadraditos al azar,
			// de 1 hasta CuadraditosPorFila,
			// aumentando por dibujo hacia derecha y abajo,
			// pero 1ero elegir cuales,
			// porque puede que la elección no sea válida,
			// en cuyo caso habría que resetearlos.
			// La elección no es válida si los elegidos tienen el mismo color y son los únicos con ese.
			// A continuación se eligen para 1 dibujo, pero esto se está repitiendo en un loop mayor:
			CuadraditosElegidos = 0;
			do {
				Repetir = "No";
				// Para evitar que se elija uno ya elegido,
				// los elegidos se guardan en una lista,
				// y cuando se va a elegir uno se mira...
				// que no esté en la lista, sino se elige otro:
				do {
					trace("Se elegirá un cuadradito del dibujo "+Dibujo);
					Repetido = "No";
					CuadraditoElegido = random(_level0.MaxCuadradito)+1;
					trace("El nro: "+CuadraditoElegido);
					trace("Se verá si ya fue elegido:");
					PunteroParaLista = 1;
					// Ver si CuadraditoElegido está en la lista de elegidos:
					while (PunteroParaLista <= CuadraditosElegidos) {
						trace("Comparando con el nro "+PunteroParaLista+" de la lista de elegidos.");
						if (CuadraditoElegido == eval("CuadraditoElegido"+PunteroParaLista)) {
							Repetido = "Sí";
							// Esto es para que ya no mire la lista:
							PunteroParaLista = CuadraditosElegidos;
							trace("Ya fue elegido antes, se elegirá otro.");
						}
						PunteroParaLista++;
					}
				} while (Repetido == "Sí");
				CuadraditosElegidos++;
 
 
 
			// Repetir hasta que se haya variado esa cantidad...
			// de cuadraditos:
			CuadraditosaModificarse = 0;
			do {
				// Para evitar que se modifique uno ya modificado,
				// los modificados se guardan en una lista,
				// y cuando se va a modificar uno se mira...
				// que no esté en la lista, sino se elige otro:
				do {
					trace("Se modificará un cuadradito del dibujo "+Dibujo);
					Repetido = "No";
					NroDeCuadraditoaCambiar = random(_level0.MaxCuadradito)+1;
					trace("El nro: "+NroDeCuadraditoaCambiar);
					trace("Se verá si ya fue modificado.");
					PunteroParaLista = 1;
					// Ver si NroDeCuadraditoaCambiar está en la lista de modificados:
					while (PunteroParaLista <= CuadraditosaModificarse) {
						trace("Comparando con el nro "+PunteroParaLista+" de la lista de modificados.");
						if (NroDeCuadraditoaCambiar == eval("CuadraditoModificado"+PunteroParaLista)) {
							Repetido = "Sí";
							PunteroParaLista = CuadraditosaModificarse+1;
							trace("Ya fue modificado, se elegirá otro.");
						}
						PunteroParaLista++;
					}
				} while (Repetido == "Sí");

Un lío. Nótese que estoy cambiando algunos nombres por lo de que debe eligirse un grupo y chequearse que sirvan en vez de modificar colores enseguida.

Intentaré transformar el pseudocódigo en código, pero ¿se puede simplificar? ¿consejos?

Te paso el fla:
https://drive.google.com/file/d/1Ewju2bGGeupjS_AmrH0G7IdSt-765TrG/view?usp=sharing

La idea es hacer un juego de peleas tipo Megaman en principio. Por ahora se controla (con flechas) a Jumpman (Mario antes de serlo) y la IA controla a Loder Runner, pero está muy simplón, lo voy haciendo de a poco.

Voy a probar esto
FaceLeft(Player)
así sin comillas a ver si funciona. Sí ¿pero con comillas no es más eficiente? Ya que en tal caso, quizá, deduce más rápido que es un objeto.

Te doy el fla para que veas si conviene eso o no, me parece que es mejor que las funciones esté definidas fuera sólo 1 vez cada una, sino habría que poner copias en cada personaje (objeto) ¿no?

Yo la vi como en 2006 y a veces he pensado en preguntar aquí esto. Si mal no recuerdo es una chica callada que adquiere una computadora y resulta una genia, aparentemente. 2 tipos en una camioneta negra la comienzan a espiar. Parece que estuviera hackeando cosas pero se pone muy raro todo, como si hackeara la realidad misma, o se autotriplicara según leí.

Vi esta noticia así que me decidí a preguntar.
https://somoskudasai.com/noticias/cultura-otaku/una-linda-lain-vuelve-para-ensenarte-a-programar/
Pero no, no tengo interés en ver sus videos.

Además me quedé con la duda de cómo sería ahí. Creo que poniendo un loop en el vbs y quit 0 (no el 1) funcionaría: No es 0 hasta que se detecte la carpeta.

El bat, por otro lado, también estaría loopeado hasta que lo otro diga 0.

Pero no sé cómo se interpreta ahí una variable (el mensaje, número, del quit) que aún no ha sido definida. Por ahora no averigué más, de cómo sería eso o cómo crear una variable en vbs y que se pase al bat, si es posible.

Bien, funciona, en bat había visto que se podía generar una espera pero como la velocidad de mi PC es tan variable no me pareció buena idea.

Tengo estas funciones:

function FaceRight () {
	if (Player.Facing == -1) {
		Player.Facing = 1;
		Player._xscale = 100;
	}
}
function FaceLeft () {
	if (Player.Facing == 1) {
		Player.Facing = -1;
		Player._xscale = -100;
	}
}

Sirven para que el personaje manejado por el jugador quede mirando hacia un lado u otro.

Quisiera que esa función se pueda usar también para los enemigos.

Ahora me doy cuenta de que no tendría problema, creo, en hacerlo como se me ocurrió, pero no parece la mejor forma. Sería algo así:

function FaceRight () {
	if (eval(Character+".Facing") == 1) {
		set(Character+".Facing", 1);
		set(Character+"._xscale", 100);
	}
}
// Cambios similares a FaceLeft.
// Antes de llamar a la función, definir Character para indicar a qué personaje se aplicará.

Lo que pasa que pensé que los códigos se podrían ejecutar en un mismo momento y entonces la variable Character podría cambiar en medio del proceso y generar lío, por eso pensé que sería mejor que cada función tenga una variable independiente, un parámetro. Aunque tal vez no lo necesito, quiero saber cómo sería, no lo sé. Sé que el parámetro va entre el paréntesis, por ejemplo:
FaceRight ("Player")
La idea es que la función se aplique a lo que indique el parámetro ¿pero cómo hago referencia al parámetro luego? No puedo decir:
if (eval(Parametro+".Facing") == 1) {
no sé cómo se dice.

EDIT: Ya vi, era fácil, el nombre se pone en el paréntesis al definir la función:

function FaceRight (Character)

Para hacer referencia al parámetro se pone eso que se haya escrito.

Sorry por preguntar algo tan fácil, nunca había usado parámetros.

EDIT2: Igual el scale no funciona así xP

function FaceRight (Character) {
	if (eval(Character+".Facing") == -1) {
		set(Character+".Facing", 1);
		set(Character+"._xscale", 100);
	}
}

Ya me había pasado algo similar pero quise arriesgarme. No sé cómo se resuelve, intento decir que la propiedad xscale del objeto Player sea 100, pero Flash crea una variable llamada Player._xscale, es como que lo anterior a _ no puede ser variable o sino se enreda... ¿alguna solución, para que no tenga que usar ifs ni similares?
GPT me dijo:
eval(Character)._xscale = 100;
Yo había probado eval pero de otras maneras 

GPT me dijo esto:

¿Está bien? El código me suena un poco a chino. Me había dicho uno en powershell pero no sé ni qué es. Le pedí explicaciones de todo, es un poco largo así que no lo pego. Lo pruebo.

Lo de modificar el registro, que me dijo antes, por ahora no lo probaré.

...

No sirve, el archivo se abre antes que la carpeta. Le dije y me respondió:

Ahora veo el 1er código y estoy confundido.

For Each wnd In objShell.Windows
    If InStr(wnd.LocationURL, "file:///CARPETA") > 0 Then
        WScript.Quit(0)
    End If
Next
 
WScript.Quit(1)

Si se encuentra la carpeta abierta, el mensaje es 0, sino 1 ¿no?
En el bat dice:
Se ejecuta el code anterior. Si el mensaje o error es 0... m, supongo que debería cambiarlo a 1, pruebo. Es que poner un else como me dijo ahora me pareció innecesario.

Ahora ni abre el archivo. Vamos desde el código anterior. Si el mensaje es 0, es decir si la carpeta se abrió, el código se ejecutará de nuevo ¿cómo es que llegó a terminar entonces? ¿se ejecutan mezclados?
Supongamos que la carpeta no se abrió, el mensaje es 1. El loop no se hace, fin. Está mal. Supongo que pasa esto.
Pero supongamos que sí se abre, el mensaje es 0. El loop se hace, y es interminable ¿no?

Ahora vamos a ver el código cambiando ese 0 por 1, en el bat:
Supongamos que la carpeta no se abrió, el mensaje es 1. El loop se hace, así que en algún punto la carpeta debería abrirse y el mensaje ser 0.
Si es 0, el programa sigue de largo sin hacer más.
¿Por qué el loop no termina si la carpeta está abierta?