Lo tengo así:

ApuntandoX = Math.max(Math.random()*350, Dificultad*10);
ParaSigno = random(2);
if (ParaSigno == 0) {
	ApuntandoX = -ApuntandoX;
}
ApuntandoY = Math.max(Math.random()*400, Dificultad*10+20.5);
Rotando = Math.max(Math.random()*100, Dificultad*10);
ParaSigno = random(2);
if (ParaSigno == 0) {
	Rotando = -Rotando;
}

Me falta confirmar que funcione como espero y crear la variable D¡ficultadx10 para no tener que estar multiplicando Dificultad a cada rato (o si siempre va a usarse como *10 la voy a ajustar, tengo que fijarme si se puede así).

Sugiero que el bot no se active cuando intento responder algo. No sé si lo habían corregido o no, pero pasa eso, te manda para el fondo de la pantalla y tienes que subir. Cuando quiero leerlo lo leo antes, así que cuando intento responder es molesto.

Me gustó esto:

// Usada al cambiar ciertas configuraciones y en el objeto Fondo si el modo cambiando está configurado:
function RepintarCuadrosMuchoAzar () {
	NroDelCuadroaRepintar = 0;
	do {
		NroDelCuadraditoaRepintar = 0;
		// p representa un ".", "punto".
		Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
		do {
			Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
			ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
			ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
			NroDelCuadraditoaRepintar++;
		} while (NroDelCuadraditoaRepintar<Cuadraditos);
		NroDelCuadroaRepintar++;
	} while (NroDelCuadroaRepintar<Cuadros);
}
function RepintarCuadrosCuadrados () {
	NroDelCuadroaRepintar = 0;
	do {
		NroDelCuadraditoaRepintar = 0;
		// p representa un ".", "punto".
		Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
		// Inicialmente los cuadraditos del cuadro tendrán el mismo color:
		ColorDelCuadro = PosiblesColores[random(PosiblesColores.length)];
		do {
			Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
			ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
			ParaColorDeCuadradito.setRGB(ColorDelCuadro);
			NroDelCuadraditoaRepintar++;
		} while (NroDelCuadraditoaRepintar<Cuadraditos);
		NroDelCuadroaRepintar++;
		GenerarCuadrados();
	} while (NroDelCuadroaRepintar<Cuadros);
}

Me falta agregar modos pero cada uno tiene su propia función, de esa manera no hay tantos ifs dentro de un while. Para determinar a qué función llamar se hace:
eval("RepintarCuadros"+Modo)();

Capaz que no es el subforo adecuado.

Explico esta imagen


En la columna base se tiene una fuerza bruta que resuelve una duda o problema extremadamente sencill@.
En las siguientes columnas, se le agrega algo a la duda o problema, haciéndol@ más complej@.

En una siguiente hoja, los nuevos códigos se pondrían de Base, uno por fila, y el proceso se repetiría.

Algunas cosas no se pueden automatizar supongo porque no expliqué todo, pero otras sí quizá ¿pero cómo? No digo que la IA ponga los códigos en el archivo Excel, pero algo como que le doy el código base y me da algunos de los nuevos códigos.

Edit: Parte de la respuesta del bot del foro, se parece a lo que preciso:

Logré 0, -1, 1, etc, o sea, los negativos 1ero:

Action = 0;
// Usada repetidamente por un objeto en el frame 1:
function FuerzaBruta () {
	Mensaje = "Probando "+Action;
	if (Action>9) {
		// Solución; mostrar en pantalla y fin.
		Mensaje = "Se recomienda la acción "+Action;
		gotoAndStop (2);
	} else if (Action < 0) {
		Action = Action*-1;
	} else {
		Action = (Action+1)*-1;
	}
}
stop ();

Le pregunté a GPT cómo hacerlo más eficiente y decidí pasar de lo que dijo  
https://poe.com/s/bxpuPhjPjWSh0v7ZtnfB

Lo que me choca es el paréntesis, creo que debe haber algo mejor.

Por otro lado, como dice el título quisiera que empezara por los positivos ¿cómo sería eso?


Edit: Ya veo, así:

	} else if (Action > 0) {
		Action = Action*-1;
	} else {
		Action = Action*-1+1;
	}
 

Resuelto entonces, pero por curiosidad ¿empezando por negativos cómo sería?
Nota: Sin <=, ni >= ni paréntesis. Y eficiente y legible, no como la respuesta de GPT.

edit2: Así

} else if (Action < 0) {
	Action = Action*-1;
} else {
	Action = Action*-1-1;
}

Sólo aviso, por las dudas, que en mi tema donde pregunté qué están haciendo, la IA de acá me dijo que estaba haciendo algo, no viene al caso qué, entonces ojo con lo que se pregunte sobre el foro o la IA, porque la IA podría dar info que no se quiere. No sé, por las dudas, hace mucho vi un meme de algo parecido.

Ninguno está completo.

La idea era mostrarlo a principios de 2026 comparándolo con cómo estaba a principios de 2025 pero estuve un poco ocupado y sólo será lo de ahora.

Cada cosa incluye:
- El editable (fla).
- El ejecutable si se tiene Flash Player (swf).
- El ejecutable si no se tiene (exe).
Exceptp 009 adding DK Jr 02 que sólo incluye el editable y un gif.
Y se incluye el archivo IA fallada.txt, ver a continuación.

Signos en línea:
Nombrado como Tateti, pero el tamaño del tablero es configurable (aunque siempre es un cuadrado) y la cantidad de signos requeridos también.
No tiene IA, la máquina juega al azar. Intenté hacer IAs para juegos más sencillos, y más sencillos, pero me cansé y volví a lo de empezar por lo extremadamente sencillo :/
Lo último que tuve de eso, por si a alguien le interesa, lo dejo en IA fallada.txt

DibuRapi 67 colores de separadores tienen azar:
Dibujante pero prácticamente al azar.
Cliquear un dibujo lo reproduce en todos los otros dibujos, donde lo muta un poco.

Dibujante:
Intenta ser una mejor versión, pero está muy a medio hacer.

Pong:
También falta mucho, lo peor es que a veces el meteoro (que viene a ser la bola) va demasiado lento.
Controlas la nave naranja. Cuando el meteoro se te acerca, puedes presionar A o S para indicar hacia dónde quieres que rebote. Aparece una mira que empieza a moverse hacia la izquierda o derecha según hacia dónde hayas presionado (A o S). Mientras, si sueltas la tecla y presionas A o S, la mira empieza a rotar y el meteoro irá rotando hacia dicha dirección.
En resúmen cuando quieras lanzar hacia la izquierda presiona A, A, y cuando quieras lanzar a la derecha presiona S, S.
Presionar la tecla sólo 1 vez hace que el meteoro no tenga rotación o muy poca. Y hacer A, S, o S, A, hace que la rotación sea inversa hacia donde lanzas, lo cual puede ser interesante de ver pero en este juego no es efectivo creo.

Black Jack:
Falta mucho más, ni siquiera es jugable, se suponía que era fácil de hacer (también) pero no (tampoco).
Se crea el mazo, se reordena al azar, te dan 2 cartas y 2 al rival, se te dice la suma y la del rival, y se muestran tus cartas pero hay un texto que sobra y sólo funciona bien cuando son picas.
Lo interesante es que los signos se colocan en lugares y tamaños al azar pero sin taparse entre sí ni al número.

Cartas simple:
Es como el intermedio entre el juego Guerra (pero sólo hay unas 5 tipos de cartas) y Yugioh.
Logré que una carta dé opciones y funcione según se elija, duh.

DK:
El juego Donkey Kong pero diferente, a grandes rásgos más simple.
Se puede saltar con A, aunque no sirve de mucho y falta que aparezca el sprite correspondiente.

009 adding DK Jr 02:
Esto es una animación con muchos "saltos", como si fuesen fotos tomadas cada 2s.

https://drive.google.com/file/d/1TV_Zax-EJ3zalrETQH42zFc_J31YjDoN/view?usp=sharing

¿Y uds qué han hecho en 2025 y qué están haciendo?

Resolví esto pero creo que podría mejorarse. Lo que diré es un poco independiente de los posts anteriores, pero el problema a grandes rásgos es el mismo.

HumanoObtieneCarta agrega un objeto (invisible) u otro según si la carta da opciones o no:

function HumanoObtieneCarta () {
(...)
	// Si la carta no da opciones:
	if (eval(Cartas[NroDeCartaDeHumano]+"Op") == 1) {
		// Se agrega un objeto que la ejecuta al presionar A:
		attachMovie("sParaCartaSimple", "Ventana", 4);
	} else {
		// Se agrega un objeto que la ejecuta de un modo u otro según qué tecla se presione:
		attachMovie("sParaCartaOpcional", "Ventana", 4);
	}
}

Esto es el código en sParaCartaSimple:

onClipEvent (enterFrame) {
	// Si se presiona A:
	if (Key.isDown(65)) {
		_level0.UsarCartaSimple();
		removeMovieClip (_parent);
	}
}

Este es en sParaCartaOpcional:

onClipEvent (enterFrame) {
	// Si se presiona izquierda:
	if (Key.isDown(37)) {
		// Humano eligió opción 1:
		_level0.CartaUsada = _level0.Cartas[_level0.NroDeCartaDeHumano]+"1";
		_level0.UsarCartaOpcional();
		removeMovieClip (_parent);
	} else if (Key.isDown(39)) {
		// Humano eligió opción 2:
		_level0.CartaUsada = _level0.Cartas[_level0.NroDeCartaDeHumano]+"2";
		_level0.UsarCartaOpcional();
		removeMovieClip (_parent);
	}
}

function UsarCartaSimple () {
	// CartaUsada es para resumir:
	CartaUsada = Cartas[NroDeCartaDeHumano];
	User = "Humano";
	Ataque = eval(CartaUsada+"At");
	eval(CartaUsada)();
}

function UsarCartaOpcional () {
	// CartaUsada es para resumir, definida en el objeto sParaCartaOpcional:
	User = "Humano";
	eval(CartaUsada)();
}

Ejemplo de carta con opciones (el único que tengo por ahora):

function MarioDK1 () {
	Ataque = MarioDKAt;
	Mensaje = "¡Mario de Donkey Kong dañó al rival!";
	MarioDK();
}
function MarioDK2 () {
	HumanoHP--;
	if (HumanoHP > 0) {
		Ataque = MarioDKAt+1;
		Mensaje = "¡Perdiste 1HP pero Mario de Donkey Kong consiguió un martillo y dañó al rival!";
		MarioDK();
	} else {
		Mensaje = "¡Mario de Donkey Kong consiguió un martillo pero ya no tienes HP!";
		HumanoPierde();
	}
}
function MarioDK () {
	if (User == "Humano") {
		IAHP = IAHP-Ataque;
		if (IAHP > 0) {
			TerminandoTurnoHumano();
		} else {
			HumanoGana();
		}
	} else {
		// Aquí la IA debería poder elegir otra opción, pero es otro tema.
		HumanoHP = HumanoHP-Ataque;
		Mensaje = Mensaje+"\n¡Donkey Kong rival te dañó!";
		if (HumanoHP > 0) {
			TerminandoTurnoDeIA();
		} else {
			HumanoPierde();
		}
	}
}

1era cuestión:
¿Es buena idea agregar un objeto invisible para que se capten unas teclas u otras según si la carta da opciones o no?
Creo que sí, una alternativa sería que fuese un único objeto y que esté haciendo un if constantemente de "si no tiene opciones, ver si se presiona A, sino ver si se presiona <- o ->", lo cual para mí es peor.
Lo malo en mi método es que el objeto se autoremueve luego de haber ejecutado funciones que llaman a otras así que no sé realmente cuando se remueve xP Aunque por ahora no noté errores. Además, un objeto con igual nombre es agregado cuando se recibe una carta, así que se sustituye al que hubiera si no se removió.
Otra opción es poner el código en frames y que haya goto al anterior, pero eso parece peor, es el mismo código en 2 frames (excepto por el goto) o se ejecuta cada 2 frames.
¿Se les ocurre algo mejor?

2nda cuestión:
Los objetos sParaCartaSimple y sParaCartaOpcional usan a funciones de la zona raíz, pero sólo los usan ellos, diferente cada uno, es decir las funciones podrían ser código en ellos ¿no sería mejor así?
El problema es que esos códigos deben hacer cambios en la raíz, entonces si estuvieran directamente en los objetos habría que poner _root. delante de varias variables, por eso a pesar del lío me parece mejor así como está (al llamar a la función de root, sólo habría que poner un solo _root delante) ¿pero no hay alguna forma mejor?
¿A mi Flash (Macromedia 5) le enlentece referencias como
_root.CartaUsada = _root.Cartas[_root.NroDeCartaDeHumano];
comparado con sin _root, o al compilarse el código da igual?

Pregunté a GPT sobre esto e interpretó que puede haber 2 movieclips a la vez chequeando teclas. No, es uno u otro. Sobre otras cosas quedé algo saturado, lo pensaré otro día.
https://poe.com/s/82EsYOmKzQuiyy9noUYz

A ver, creo que hace mucho un helado de McDonalds costaba $10, quizá $30.
El Famicom que me compraron que incluía como 40 juegos costó unos $400 o menos.

Hoy día, un helado cuesta como $50.
Significa que el precio de los helados se duplicó o quintuplicó, a lo mucho.

Un NES, que era peor que un Famicom en cuanto al precio y variedad obtenible de juegos (al menos aquí), a lo mejor costaba $1000.
Entonces, partiendo de ahí, y no del Famicom, o sea estoy siendo generoso, el precio se veinteplicó o como se diga.

Eso es lo que vale una PC último modelo más o menos... Con un PC puedes hacer mucho ¿debería una consola valer lo mismo?

Estas fórmulas determinan hacia dónde irán los saques en mi juego Pong y la rotación de lo que sería la bola:
ApuntandoX = Math.random()*700-350;
ApuntandoY = Math.random()*375.5+20.5;
Rotando = Math.random()*200-100;

Si las entiendo bien,
el rango de ApuntandoX es -350~350,
de ApuntandoY es 20.5~400,
y de Rotando es -100~100.

El juego se pone más difícil entre con mayor diferencia vayas ganando, es decir hay una variable Dificultad, que inicia como 0 y va subiendo.

Quisiera modificar las fórmulas de modo que Dificultad influya.

En el caso de ApuntandoX, el resultado puede ser 0, pero si Dificultad es 10 por ejemplo, quiero que el rango sea -350~-10 y 10~350, es decir así con una zona de "valores prohibidos", básicamente es que entre mayor sea la dificultad, menos al centro irán los saques.

Rotando es parecido, entre mayor sea la dificultad, mayor será la mínima rotación inicial posible, es decir todos los tiros tendrán algo de rotación.

ApuntandoY sólo tiene valores positivos así que parece más fácil de resolver, algo como
ApuntandoY = Math.max(Math.random()*400, Dificultad+20.5);
...no estoy seguro.