https://www.youtube.com/watch?v=FysJWe3oVZw

 

Si han visto algo parecido, muestren.

¿Las imágenes y las voces también? Otro día me fijo lo de las voces, pero es que lo dicen de forma confusa y en inglés, que es IA pero que están en contra ¿?

Action1 = "";
Action2 = "";
// Usada repetidamente por un objeto en el frame 1:
function FuerzaBruta () {
    Mensaje = "Probando "+Action1+" y "+Action2;
    if (Action1<Action2) {
		trace("Action1<Action2");
        // Solución; mostrar en pantalla y fin.
        Mensaje = "Se recomiendan las acciones "+Action1+" y "+Action2;
        gotoAndStop (2);
    } else if (Action1<"111") {
        Action1 = Action1+"1";
		trace("Action1");
    } else if (Action2<"111") {
        Action1 = "";
        Action2 = Action2+"1";
		trace("Action2");
    } else {
        Mensaje = "No se pudo hallar una solución";
        gotoAndStop (2);
    }
}
stop ();
 

Ni siquiera me muestra los traces, o sea nunca se cumplen estas condiciones:
    if (Action1<Action2) {
    } else if (Action1<"111") {
    } else if (Action2<"111") {

Pero según GPT cuando una cadena se compara con otra se mira el valor ASCII o algo así de cada caracter, algo parecido a que se chequea qué cadena va 1ero en orden alfabético.

    if (Action1<Action2) {
deberia cumplirse en el par "" y "1", o en el par "1" y "11", etc. Salvo que cuando no haya caracteres diga "no hay con qué comparar, false".

    } else if (Action1<"111") {
Action1 empieza como "", y "" < "111", así que esta condición debería cumplirse.

En fin, intentaba hacer un código simple, sin usar lenght ¿es realmente necesario?


Hmp. Tampoco es como dijo GPT del código ASCII, es por la longitud de la cadena, no es necesario poner length ¿pero entonces qué pasa?
Se debería cumplir esto
 } else if (Action1<"111") {
"" < "111"
¿por qué no se cumple?

Edit: El bot de acá tampoco acertó, dijo:
Pero acabo de poner que las variables Action inicien como "1" y al resetearse también, y el resultado es el mismo.
"1" no es < "11"

Edit2: Más simple:

Action1 = "1";
Action2 = "1111";
    if (Action1<Action2) {
	trace("jdbhbdhbdf");
}

No se cumple.

Action1 = "1";
Action2 = "a";
    if (Action1<Action2) {
	trace("jdbhbdhbdf");
}

Se cumple.

Action1 = "1";
Action2 = "aaa";
    if (Action1<Action2) {
	trace("jdbhbdhbdf");
}

Se cumple.

O sea, lo que copié del manual parece que está equivocado ¿?
"Las expresiones de cadena se evalúan y comparan basándose en el número de caracteres de la cadena."
¿Quizá lo tradujeron mal del inglés?

Edit3: Creo que ya entendí al bot.
"1" < "11" no se cumple porque
"1" == "1"
"" nada "1" o sea se considera false según dijo.

En el siguiente video notarán varios errores pero céntrense en la posición de las cartas, estoy diciendo al juego que me de otra y otra, etc, y debería mostrarlas mejor posicionadas (las cartas, los símbolos en ellas son otro tema) ¿cómo lo logro?
https://youtu.be/o0IiQwvmSOY

// para tomar otra carta: Crear función para distribuir cartas y agregar 1, en vez de agregar y redistribuir todas cuando ya están.
 
// Generar array de cartas:
Cartas = [];
Nro = 0;
do {
	Nro++;
	Cartas[Cartas.length] = "P"+Nro;
	Cartas[Cartas.length] = "T"+Nro;
	Cartas[Cartas.length] = "C"+Nro;
	Cartas[Cartas.length] = "D"+Nro;
} while (Nro < 13);
 
// Ordenarlas al azar:
// Eso creo que no tiene que ver así que no lo pongo acá.
 
// Dar 2 a jugadores:
SiguienteNroDeCarta = 0;
CartasDeHumano = [];
// Para facilitar las sumas:
NumerosDeHumano = [];
CartasDeIA = [];
do {
	CartasDeHumano[CartasDeHumano.length] = Cartas[SiguienteNroDeCarta];
	NumerosDeHumano[NumerosDeHumano.length] = Number(Cartas[SiguienteNroDeCarta].substring(1, Cartas[SiguienteNroDeCarta].length));
	CartasDeIA[CartasDeIA.length] = Cartas[SiguienteNroDeCarta+1];
	SiguienteNroDeCarta = SiguienteNroDeCarta+2;
} while (SiguienteNroDeCarta < 4);
 
// Mostrarlas en pantalla:
function MostrarCartasDeHumano () {
	NroDeCartaaMostrar = 0;
	if (CartasDeHumano.length % 2 == 0) {
		PosicionDe0 = 256 - CartasDeHumano.length-1 * 50 - 25;
	} else {
		PosicionDe0 = 256 - CartasDeHumano.length * 50;
	}
	// trace(PosicionDe0);
	do {
		NombreDeCarta = "CartaDeHumano"+CartasDeHumano[NroDeCartaaMostrar];
		attachMovie ("sCarta", NombreDeCarta, NroDeCartaaMostrar);
		setProperty (NombreDeCarta, _x, PosicionDe0+(NroDeCartaaMostrar)*150);
		setProperty (NombreDeCarta, _y, 192);
		// Para el interior de la carta:
// Eso creo que no tiene que ver así que no lo pongo acá.
		NroDeCartaaMostrar++;
	} while (NroDeCartaaMostrar < CartasDeHumano.length);
}
MostrarCartasDeHumano();
 
// Calcular suma de humano:
// Eso creo que no tiene que ver así que no lo pongo acá.
 
// Calcular suma de IA:
// Eso creo que no tiene que ver así que no lo pongo acá.
 
// Tomar carta sí o no. Un objeto en F2 repite esto:
function TomarCartaSoN () {
	// Si se presiona izquierda:
	if (Key.isDown(37)) {
// Eso creo que no tiene que ver así que no lo pongo acá.
	} else if (Key.isDown(39)) {
		SiguienteNroDeCarta++;
		CartasDeHumano[CartasDeHumano.length] = Cartas[SiguienteNroDeCarta];
		NumerosDeHumano[NumerosDeHumano.length] = Number(Cartas[SiguienteNroDeCarta].substring(1, Cartas[SiguienteNroDeCarta].length));
		Mensaje = "Has recibido "+CartasDeHumano[CartasDeHumano.length];
		MostrarCartasDeHumano();
	}
}

Me refiero a qué debería agregar o mejorar.

Foto:


Por ejemplo:
1- Debería haber un martillo en el centro de la pantalla y Mario debería poder agarrarlo.
2- Los barriles al tocar el suelo deberían empezar a rodar por él en vez de seguir de largo.
3- El objetivo del juego debería ser subir, así que debería haber...

El orden debe ser teniendo en cuenta qué es más fácil de hacer (eso se prefiere que esté 1ero) y qué es más importante (idem). Puede que sea imposible cumplir ambos criterios a la vez, pero más o menos.

Me interesa lo de que Mario pueda subir ¿pero cual sería la forma más fácil? No que una plataforma lo suba, claro, Mario debe poder moverse hacia los lados para esquivar los barriles.
Ya puse que Mario pueda saltar, y lo que se me ocurre es poner pisos con subida como en el juego original pero mucho más juntos, de modo que si Mario salta en el extremo de uno, puede que llegue al otro:
/
\
No tan así extremo pero si está en el de abajo a la izquierda, está tan cerca del de arriba que al saltar quedaría arriba.
Entonces por ahora no tendría que poner escaleras y que las pueda subir, que parece más difícil.
Otra posibilidad es que haya muchas plataformas, no, mejor pisos sin inclinación, muy juntos, y al saltar debe quedar en un piso de arriba y la pantalla debe bajar, como si la cámara siguiera a Mario y siempre mostrara lo que hay arriba, sino... Bueno, pueden ser 2 versiones distintas del juego, uno en que subes infinitamente y la cámara siempre te muestra abajo (algo como Ice Climber pero infinito, la dificultad aumenta al subir), y otro en que pasas de pantalla cuando llegas arriba del todo. Como es una imitación, haré eso último.

La pregunta así sería ¿cual sería la forma "correcta" de hacer que si el personaje saltó y cayó en una plataforma quede encima de ella?
En mi juego por ahora Mario no podría bajar, o sea, no sería como en el original en que muere si cae o si salta hacia un sitio muy bajo, ese no es el problema, lo que digo es que se podría poner que si salta queda más arriba al caer, porque no importa hacia dónde lo haga, hay piso, pero eso sería trampa, debe estar programado para chequear que haya piso y si hay que quede encima. A eso me refiero con "correcta".
La función que se ejecuta al saltar es:

function Jump () {
	Player._x = Player._x+DKMarioSpeedX;
	Player._y = Player._y+DKMarioSpeedY;
	DKMarioSpeedY = DKMarioSpeedY+0.015;
	if (Player._y >= 568) {
		Player._y = 568;
		Player.gotoAndStop(1);
		Quiet();
	}
}

En vez de ese if debo poner que si DKMarioSpeedY es negativa... ¿entonces empezar a chequear piso por piso a ver si toca alguno? Sólo los que estén en la pantalla, pero en este caso son todos. No es que sean muchos, pero me parecía poco eficiente.
Pero no es "si lo toca", es "si está por encima, pero no tan por encima", m... ¿Entonces algo así:
Si Mario está cayendo
   PisoaChequar = 9
   do
      Si Mario está tocando el piso PisoaChequar
         Si Mario está por encima de (posición del piso PisoaChequar)
...más o menos entiendo la idea, pero me entrevera eso de que si está encima pero no tan encima. La posición de Mario está en los pies, eso ya lo tengo, así que si está tocando y está encima ¿alcanza con eso, debe quedar encima? La posición de la plataforma está en su centro.
Si la plataforma fuese muy alta:
M6
____M5_
M4
 P M3
M2
----M1--

M1 (Mario en la posición 1) la está tocando pero no está encima, así que seguirá subiendo por el salto.
M2 lo mismo.
M3 está justo en el centro vertical de la plataforma, pero no está bajando, así que seguirá. ¿Y si estuviera bajando? Debe seguir bajando, supongo.
M4 está por encima del centro, pero no encima de la parte de arriba. Si está subiendo seguirá ¿y si está bajando? Ponerlo encima de la plataforma suena mal, debe ocurrir sólo si estuvo encima.
M5 está justo en el suelo de la plataforma. ¿Acaso ese es el punto vertical que importa, no el centro? Obviamente si M está cayendo debe quedar encima, pero este caso es poco probable (posiciones exactamente iguales mientras M cae).
M6 no está tocando así que sigue su curso.

Haré las plataformas y "la trampa", el modo fácil, pero quisiera hacerlo bien y como ven no tengo del todo claro cómo sería.

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;
}

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?

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.

El programa es un generador de 3 tipos de imágenes por ahora:

MuchoAzar: Lo que sería cada píxel lo pinta de un color al azar de una lista:


Cuadrados:


Y el que intento agregar: AzarrazA, que es como el azar pero simétrico así horizontalmente como se muestran las letras, no verticalmente.

Cuando se presiona un botón para cambiar el modo (en este caso a MuchoAzar), sucede esto:

on (release) {
	Modo = "MuchoAzar";
	RepintarCuadraditos();
}

Es decir se usa esto:

function RepintarCuadraditos () {
	NroDelCuadroaRepintar = 0;
	do {
		NroDelCuadraditoaRepintar = 0;
		// p representa un ".", "punto".
		Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
		if (Modo == "Cuadrados") {
			// Inicialmente los cuadraditos del cuadro tendrán...
			// el mismo color:
			ColorDelCuadro = PosiblesColores[random(PosiblesColores.length)];
			trace("ColorDelCuadro: "+ColorDelCuadro);
		}
		do {
			Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
			ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
			if (Modo == "MuchoAzar") {
				ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
			} else if (Modo == "Cuadrados") {
				ParaColorDeCuadradito.setRGB(ColorDelCuadro);
			}
			NroDelCuadraditoaRepintar++;
		} while (NroDelCuadraditoaRepintar<Cuadraditos);
		NroDelCuadroaRepintar++;
		if (Modo == "Cuadrados") {
			GenerarCuadrados();
		}
	} while (NroDelCuadroaRepintar<Cuadros);
}

En ese código debo poner el caso para el modo AzarrazA ¿cómo me conviene ponerlo?
Es que en ese código todos los cuadraditos se pintan de una u otra forma, pero en este caso si están a la derecha del medio (de un cuadro, no de la pantalla) van a tener que imitar el color que se haya seleccionado para su pixel (o cuadradito) opuesto, lo que se me acaba de ocurrir es poner:

if (Modo == "MuchoAzar") {
	ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
} else if (Modo == "AzarrazA") {
	Si el cuadradito a pintar no está a la derecha del centro del cuadro:
		ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
	sino
		pintarlo igual que su opuesto
	fin del si
} else if (Modo == "Cuadrados") {
	ParaColorDeCuadradito.setRGB(ColorDelCuadro);
}

Creo que con eso estaría bien, pensé que no porque tengo la manía de querer evitar ifs, ah, cierto ¿no sería mejor crear un código aparte para los que deba pintar al azar y luego otro para los que deban ser imitaciones? El problema es que parece más complicado hacerlo.

Problema tontuelo se supone.

Normalmente ocurre algo como esto:
lo normal es algo como
-----------------------------------------------------------------
¡(tu carta causó un efecto)!

Es el turno del rival
¡(su carta causó un efecto)!

Es tu turno
Has obtenido a (carta)
-----------------------------------------------------------------
Al usar una carta, todo eso se borra. Pero hay una carta que deja una línea en blanco antes de borrar. Cuando se obtiene, da 2 opciones, se ejecuta la elegida y luego (si se sobrevive) se ejecuta otro código.

function MarioDK1 () {
	Ataque = MarioDKAt;
	Mensaje = "";
	MarioDK();
}
function MarioDK2 () {
	HumanoHP--;
	if (HumanoHP > 0) {
		Ataque = MarioDKAt+1;
		Mensaje = "¡Perdiste 1HP pero Mario de Donkey Kong consiguió un martillo!";
		MarioDK();
	} else {
		Mensaje = "¡Mario de Donkey Kong consiguió un martillo pero ya no tienes HP!";
		HumanoPierde();
	}
}
function MarioDK () {
	if (User == "Humano") {
		IAHP = IAHP-Ataque;
		Mensaje = Mensaje+"\n¡Mario de Donkey Kong dañó al rival!";
		if (IAHP > 0) {
			TerminandoTurnoHumano();
		} else {
			HumanoGana();
		}
	} else {
		// No viene al caso.
	}
}

El efecto de otras cartas cuando el usuario es humano sustituye el mensaje por otro.
Pero en el caso de Mario, la función MarioDK, no puede hacer eso porque hay una de las opciones que da un mensaje que no debe borrarse. Creo que no me explico, a ver, se obtiene la carta:

Si se presiona izquierda:
Debe ocurrir MarioDK1, luego MarioDK y el mensaje debe ser:
¡Mario de Donkey Kong dañó al rival!

Sino si se presiona derecha:
Debe ocurrir MarioDK2.
Si se sobrevive, debe ocurrir MarioDK y el mensaje en pantalla debe quedar así:
---------------------------------------------------------------------------------------------------------
¡Perdiste 1HP pero Mario de Donkey Kong consiguió un martillo!
¡Mario de Donkey Kong dañó al rival!
---------------------------------------------------------------------------------------------------------
si no se sobrevive, no debe ocurrir MarioDK y el mensaje debe ser:
¡Mario de Donkey Kong consiguió un martillo pero ya no tienes HP!


En otras palabras, al ejecutarse MarioDK...

Si se ejecutó MarioDK1, el mensaje debe borrar todo lo anterior y ser:
¡Mario de Donkey Kong dañó al rival!
sino si se ejecutó MarioDK2, el mensaje debe conservar el que se dió en esa función, quedando:
¡Perdiste 1HP pero Mario de Donkey Kong consiguió un martillo!
¡Mario de Donkey Kong dañó al rival!

No quiero usar un if, creo que hay otra solución, quizá poniendo /n al final en un caso en vez de al inicio ¿cómo sería?

Otra cosa que se me acaba de ocurrir es poner los mensajes necesarios en MarioDK1 y MarioDK2, ninguno en MarioDK, voy a probarlo, pero me interesa cómo sería de otra forma.

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!\n¡Mario de Donkey Kong 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 {
		// No viene al caso.
	}
}