Al irse, el foro perdió actividad, y los que quedaban perdieron parte de la motivación para quedarse, es como una fila de fichas de dominó, no sé si me explico, la caída o el retiro de uno provoca lo mismo en otro, o contribuye a provocarlo.

O hay algo más, no sé bien qué.

Preguntas hay, e incluso aportes.

En el caso de los aportes, yo no puedo opinar porque no sé de qué hablan, parece chino. Pero por qué otros no postean para decir que harían X mejora o Y, no sé ¿se considera mala educación decir eso, como si se estuviera criticando el trabajo de otro? Buh.

Preguntas en general tampoco puedo responder, además en varios casos soy quien las hago. Por qué no las responden, no sé, puede ser que no les interesa el tema porque poco tiene que ver con seguridad informática, o porque uso un lenguaje muy antiguo, o porque escribo mucho, o mal, o porque son preguntas complicadas, etc.

Luego está la teoría, que la dijo un usuario que se fue, de que muchos aquí no quieren compartir lo que saben.

Muchos imagino que no tienen tiempo, ni muchos recursos, como para usar una PC seguido.

En fin, es cierto que si la gente se va esto decae, pero los que están podrían hacer más que sólo aparecer para moderar y/o saludar en fin de año:
https://foro.elhacker.net/foro_libre/feliz_navidad-t522878.0.html
El tema que más recibe respuestas es el más vanal o el de guerras donde es su creador (del tema) quien más postea, y muchas veces ni son escritos suyos. Pero para algunos está prohibido casi hablar de política, así que aunque esos temas tuvieran mucho valor, es como que baja por eso.

Sin ánimo de ofender o decir que el foro está horrible, sólo trato de entender qué pasa, no creo que sea sólo "se fue mucha gente" ¿qué pasa con la que queda?

La otra teoría que se me olvidó es que, como la información está por ahí, no vale la pena decirla, es como un tema de humildad también, la gente no se cree super hacker y por lo tanto no vienen a dar clases. Yo no tengo mucho interés en el hacking, pero algunos consejos de programación podrían servir, un tema con un curso. En vez de hacer temas de que Musk o Trump se tiraron un pedo o lo que sea.

Lo acabo de hablar con Deepseek.

En teoría los peones tendrían que haberse movido de a 1 casillero, hasta coronar, probablemente a caballo.

Pero para que los peones no se bloqueen entre sí, algunas piezas deberían perderse, lo cual pone en duda la teoría.

Los reyes tendrían que moverse hacia las esquinas opuestas, sin enrocar, pero la posibilidad de que les hagan jaque y los obliguen a retroceder u otras cosas, hace que no pueda descartarlo.

Dije que los peones probablemente deban coronar a caballo porque esa es la pieza que más tardaría en llegar a cierto sitio.

Demasiada teoría, muy en el aire.

¿Qué opinan?

Dicen que en este juego hay más posibilidades que átomos en el universo, y yo aún no termino mi IA para Signos en línea, pero he pensado que se debe iniciar a resolver desde las situaciones más alejadas, en que sólo queda 1 casillero libre, y entonces me preguntaba qué sería lo análogo en el Ajedrez... Pero no digo las situaciones en que un jugador sólo tiene 1 opción, sino las que requieren más movimientos para ocurrir, aunque... como en este juego se puede volver a situaciones anteriores, no como en el Signos en línea, supongo que mi plan no funcionaría. Sólo puedo evaluar situaciones que sólo tienen 1 opción que termine la partida o que lleven a situaciones ya evaluadas. Si hay situaciones no resueltas que lleven a otras no resueltas, no sé. En fin, ese es el motivo, es otra cuestión que estoy pensando, pero la pregunta me pareció interesante.

Tengo 2 animaciones de Mario martillando.

En una está quieto, en la otra caminando.

Ambas tienen 6 frames.

En los 1eros 3 el martillo está arriba, en las demás abajo.

Cuando el personaje pase de quieto a caminando, o viceversa, debo cambiar la animación y quiero que el martillo quede como estaba, o sea, si estaba en el 2ndo frame en que está arriba, la otra animación debe empezar ahí.

Para eso puse una variable EtapaDeMartillo, que marca a qué frame debe irse.

Cada animación, en el frame 1, establece que es 1, y en los demás le suma 1.

Cuando debe ocurrir el cambio de animación, uso esto:

	Player.SaveDeEtapaDeMartillo = Player.EtapaDeMartillo;
	Player.gotoAndStop(3);
	Player.Movie.gotoAndStop(Player.SaveDeEtapaDeMartillo);
	Player.EtapaDeMartillo = Player.SaveDeEtapaDeMartillo;
 

Donde dice 3, en el otro caso es 2. No hay problema con eso. Lo demás son intentos de hacer que funcione pero no hay caso. No entiendo bien qué pasa, tengo estos prints:
f1, 1
f2, 2
f3, 3
f4, 4
quiet
f1, 4
f4, 2
walking
f1, 2
f2, 2
significa que, durante 4 frames estuvo bien, en el frame 1 la variable es 1, en el 2 es 2, etc, hasta 4, se estaba ejecutando la animación de que estaba quieto. En el 4to es cuando baja el martillo. Ahí empecé a caminar. Se activa el frame 1 de la otra animación, aunque ese frame no se muestre, aparentemente es inevitable, cuando carga la película se activa eso. Eso hace que EtapaDeMartillo sea 1, pero va al frame 4 donde debe ser 4, se le suma 1 ahí y queda 2, pero debe ser 4. Luego cuando dejo de caminar el martillo aparece encima, supongo que porque está en el frame 2.

Con SaveDeEtapaDeMartillo intenté que luego de que se cargue la película y se modifique EtapaDeMartillo, esta variable lo vuelva a su valor original, pero no funciona, como expliqué, es como si 1ero se ejecutara este código y luego el que está en la película.

Puedo poner un if en el 1er frame de las animaciones, que no resetee EtapaDeMartillo si acaba de ocurrir un cambio, pero parece una forma muy tosca de hacerlo ¿qué alternativas son mejores?


Explícame la solución 2: Mover la lógica de EtapaDeMartillo fuera de los frames.


Intentaré eso.

Aparentemente sí era eso, lo hablé con Deepseek y lo solucioné:

function ConvertiraBinario (numero) {
	// Averiguar cómo es en binario:
	DibujoEnBinario = "";
	while (numero>0) {
		DibujoEnBinario = numero%2+DibujoEnBinario;
		numero = Math.floor(numero/2);
	}
	// Agregar 0s a DibujoEnBinario si hacen falta:
	while (DibujoEnBinario.length<Cuadraditos) {
		DibujoEnBinario = 0+DibujoEnBinario;
	}
}

Dice que hay mejores formas de hacerlo, pero yo de esto no entiendo mucho ni me llama mucho, estas cosas matemáticas.

Sé de algo que quizá funcione ¿pero es ético? ô.ó

Flash pone carteles si un proceso es muy largo así que lo dividí en frames. En ese sentido no es que digo de mejorarlo, eso es complicado.

Escena 1
   actions for fotograma 1
      // De las permutaciones a crear:
      Largo = 1;
      // Primeras opciones y costos:
      // Largo de la permutación, id:
      L1P1 = "A";
      L1P1Costo = 4;
      L1P1Opciones = ["B", "C", "D", "E", "F", "G", "H"];
      L1P2 = "B";
      L1P2Costo = 4;
      L1P2Opciones = ["A", "C", "D", "E", "F", "G", "H"];
      L1P3 = "C";
      L1P3Costo = 4;
      L1P3Opciones = ["A", "B", "D", "E", "F", "G", "H"];
      L1P4 = "D";
      L1P4Costo = 4;
      L1P4Opciones = ["A", "B", "C", "E", "F", "G", "H"];
      L1P5 = "E";
      L1P5Costo = 2;
      L1P5Opciones = ["A", "B", "C", "D", "F", "G", "H"];
      L1P6 = "F";
      L1P6Costo = 2;
      L1P6Opciones = ["A", "B", "C", "D", "E", "G", "H"];
      L1P7 = "G";
      L1P7Costo = 2;
      L1P7Opciones = ["A", "B", "C", "D", "E", "F", "H"];
      L1P8 = "H";
      L1P8Costo = 2;
      L1P8Opciones = ["A", "B", "C", "D", "E", "F", "G"];
      // Costes:
      CostoAB = 2;
      CostoBA = 2;
      CostoAC = 1;
      CostoCA = 1;
      CostoAD = 2;
      CostoDA = 2;
      CostoAE = 2;
      CostoEA = 2;
      CostoAF = 2;
      CostoFA = 2;
      CostoAG = 3;
      CostoGA = 3;
      CostoAH = 3;
      CostoHA = 3;
      // 
      CostoBC = 2;
      CostoCB = 2;
      CostoBD = 1;
      CostoDB = 1;
      CostoBE = 2;
      CostoEB = 2;
      CostoBF = 2;
      CostoFB = 2;
      CostoBG = 3;
      CostoGB = 3;
      CostoBH = 3;
      CostoHB = 3;
      // 
      CostoCD = 2;
      CostoDC = 2;
      CostoCE = 2;
      CostoEC = 2;
      CostoCF = 2;
      CostoFC = 2;
      CostoCG = 3;
      CostoGC = 3;
      CostoCH = 3;
      CostoHC = 3;
      // 
      CostoDE = 3;
      CostoED = 3;
      CostoDF = 2;
      CostoFD = 2;
      CostoDG = 3;
      CostoGD = 3;
      CostoDH = 3;
      CostoHD = 3;
      // 
      CostoEF = 1;
      CostoFE = 1;
      CostoEG = 1;
      CostoGE = 1;
      CostoEH = 2;
      CostoHE = 2;
      // 
      CostoFG = 2;
      CostoGF = 2;
      CostoFH = 1;
      CostoHF = 1;
      // 
      CostoGH = 1;
      CostoHG = 1;
      // Para saber cuántas permutaciones con el largo anterior hay...
      // que extender:
      PermutacionesDeOldL = 8;
      Mensaje = "";
   actions for fotograma 2
      // Se extenderá L?P1, L?P2, etc, esto evita repetir concatenaciones:
      L_OldLargo_P = "L"+Largo+"P";
      // Incrementar largo de las permutaciones a crearse:
      Largo++;
      Mensaje = "Nuevo largo de permutaciones: "+Largo;
      // Parte de nombres de nuevas permutaciones, usado para evitar...
      // repetir concatenaciones:
      L_NewLargo_P = "L"+Largo+"P";
      NroDePermutacionaExtender = 0;
      // Cuando se empiece a extender permutaciones más largas,
      // esto determina cuántas hay que extender (PermutacionesDeOldL):
      PermutacionesNuevas = 0;
   actions for fotograma 3
      // Cambiar permutación a extender:
      NroDePermutacionaExtender++;
      NombreDePaExtender = L_OldLargo_P+NroDePermutacionaExtender;
      // Para evitar evals:
      EvaluedNombreDePaExtender = eval(NombreDePaExtender);
      // trace ("Se extenderá la permutación "+NombreDePaExtender+", que es "+EvaluedNombreDePaExtender);
      // Copia de variable, para evitar referencias:
      CaracteresDisponibles = eval(NombreDePaExtender+"Opciones");
      // Para evitar restas:
      LastNroDeCaracter = CaracteresDisponibles.length-1;
      NroDeCaracteraAgregar = -1;
      // Copia para evitar referencias:
      Costo = eval(NombreDePaExtender+"Costo");
      Mensaje = "Se extenderá la permutación "+NombreDePaExtender+", que es "+EvaluedNombreDePaExtender+" y cuesta "+Costo;
      // Último punto alcanzado:
      LastPunto = EvaluedNombreDePaExtender.charat(EvaluedNombreDePaExtender.length-1);
      // ¿NO SE PODRÍA USAR LastNroDeCaracter?
      // Para evitar repetir concatenaciones al averiguar costo a sumar:
      Costo_LastPunto = "Costo"+LastPunto;
      // ResumenParaCosto = "Costo"+(eval(NombreDePaExtender).charat(LastNroDeCaracter));
   actions for fotograma 4
      // Cambiar el caracter que se agrega:
      NroDeCaracteraAgregar++;
      // Crear permutación usando la a extender,
      // agregándole el caracter señalado:
      PermutacionesNuevas++;
      NombreDeNuevaP = L_NewLargo_P+PermutacionesNuevas;
      set (NombreDeNuevaP, eval(NombreDePaExtender)+CaracteresDisponibles[NroDeCaracteraAgregar]);
      // trace ("Nueva permutación: "+NombreDeNuevaP+": "+eval(NombreDeNuevaP));
      // Crear su variable de Opciones
      // (slice para copiar el array,
      // splice para quitarle un elemento):
      // Copia el array:
      CopiaDelArray = CaracteresDisponibles.slice();
      // A esa copia se le quita el caracter agregado en la permutación:
      CopiaDelArray.splice(NroDeCaracteraAgregar, 1);
      set (NombreDeNuevaP+"Opciones", CopiaDelArray);
      // trace ("Sus opciones son: "+NombreDeNuevaP+"Opciones: "+eval(NombreDeNuevaP+"Opciones"));
      set (NombreDeNuevaP+"Costo", Costo+(eval(Costo_LastPunto+(eval(NombreDeNuevaP).charat(eval(NombreDeNuevaP).length-1)))));
   actions for fotograma 5
      if (NroDeCaracteraAgregar<LastNroDeCaracter) {
         // Se volverá a extender la permutación, cambiando el caracter:
         gotoAndPlay (4);
      } else if (NroDePermutacionaExtender<PermutacionesDeOldL) {
         // Se volverá a cambiar la permutación a extender:
         delete eval(NombreDePaExtender);
         delete eval(NombreDePaExtender+"Opciones");
         delete eval(NombreDePaExtender+"Costo");
         gotoAndPlay (3);
      } else if (Largo<4) {
         // Se volverá a incrementar el largo...
         // de las permutaciones a extender:
         delete eval(NombreDePaExtender);
         delete eval(NombreDePaExtender+"Opciones");
         delete eval(NombreDePaExtender+"Costo");
         PermutacionesDeOldL = PermutacionesNuevas;
         gotoAndPlay (2);
      }
   actions for fotograma 6
      Mensaje = "Borrando variables innecesarias.";
      NroDePermutacionaBorrar = 0;
      do {
         NroDePermutacionaBorrar++;
         delete eval(L_NewLargo_P+NroDePermutacionaBorrar+"Opciones");
         delete eval(L_NewLargo_P+NroDePermutacionaBorrar);
      } while (NroDePermutacionaBorrar<PermutacionesNuevas);
   actions for fotograma 7
      delete eval(NombreDePaExtender);
      delete eval(NombreDePaExtender+"Opciones");
      delete PermutacionesDeOldL;
      delete Largo;
      delete L_OldLargo_P;
      delete L_NewLargo_P;
      delete NroDePermutacionaExtender;
      delete PermutacionesNuevas;
      delete NombreDePaExtender;
      delete CaracteresDisponibles;
      delete LastNroDeCaracter;
      delete NroDeCaracteraAgregar;
      delete NombreDeNuevaP;
      delete CopiaDelArray;
      delete NroDePermutacionaBorrar;
      Mensaje = "Listo.";
      stop ();
 

Tanto borrado de variables al final es porque falta que muestre cual es el camino, tendría que comparar cada costo obtenido y quedarse con el menor ¿me conviene hacer eso al final?

El caso que estoy analizando es probablemente simplón: Pasar por los 8 tornillos (o lo que sean) tocando la menor cantidad de escaleras posible:
https://www.youtube.com/watch?v=ovi2Vr1Wza0
El video ese no es mío y no se está intentando eso, es simplemente para que vean.

Pero bueno ¿estoy borrando variables inexistentes?

Y me faltaría que se borren estas:
  Variable _level0.CostoAB = 2
  Variable _level0.CostoBA = 2
  Variable _level0.CostoAC = 1
  Variable _level0.CostoCA = 1
  Variable _level0.CostoAD = 2
  Variable _level0.CostoDA = 2
  Variable _level0.CostoAE = 2
  Variable _level0.CostoEA = 2
  Variable _level0.CostoAF = 2
  Variable _level0.CostoFA = 2
  Variable _level0.CostoAG = 3
  Variable _level0.CostoGA = 3
  Variable _level0.CostoAH = 3
  Variable _level0.CostoHA = 3
  Variable _level0.CostoBC = 2
  Variable _level0.CostoCB = 2
  Variable _level0.CostoBD = 1
  Variable _level0.CostoDB = 1
  Variable _level0.CostoBE = 2
  Variable _level0.CostoEB = 2
  Variable _level0.CostoBF = 2
  Variable _level0.CostoFB = 2
  Variable _level0.CostoBG = 3
  Variable _level0.CostoGB = 3
  Variable _level0.CostoBH = 3
  Variable _level0.CostoHB = 3
  Variable _level0.CostoCD = 2
  Variable _level0.CostoDC = 2
  Variable _level0.CostoCE = 2
  Variable _level0.CostoEC = 2
  Variable _level0.CostoCF = 2
  Variable _level0.CostoFC = 2
  Variable _level0.CostoCG = 3
  Variable _level0.CostoGC = 3
  Variable _level0.CostoCH = 3
  Variable _level0.CostoHC = 3
  Variable _level0.CostoDE = 3
  Variable _level0.CostoED = 3
  Variable _level0.CostoDF = 2
  Variable _level0.CostoFD = 2
  Variable _level0.CostoDG = 3
  Variable _level0.CostoGD = 3
  Variable _level0.CostoDH = 3
  Variable _level0.CostoHD = 3
  Variable _level0.CostoEF = 1
  Variable _level0.CostoFE = 1
  Variable _level0.CostoEG = 1
  Variable _level0.CostoGE = 1
  Variable _level0.CostoEH = 2
  Variable _level0.CostoHE = 2
  Variable _level0.CostoFG = 2
  Variable _level0.CostoGF = 2
  Variable _level0.CostoFH = 1
  Variable _level0.CostoHF = 1
  Variable _level0.CostoGH = 1
  Variable _level0.CostoHG = 1
  Variable _level0.EvaluedNombreDePaExtender = "HGF"
  Variable _level0.Costo = 5
  Variable _level0.LastPunto = "F"
  Variable _level0.Costo_LastPunto = "CostoF"
  Variable _level0.L3P336Costo = 5

O sea, si el programa tuviese más posibles caminos, serían más cantidad de "CostoLetra1Letra2". Además esta L3P336Costo, que supongo es la última de largo 3, si el programa llegara a formar caminos más largos (lo configuré hasta 4 por ahora para pruebas, pero se precisan 8), sería otra. No sé por qué no se borra.
Otras supongo que son fáciles de borrar.

¿Qué más me recomiendan?

No he olvidado esto:
https://foro.elhacker.net/buscador-t522268.0.html
pasa que en aquél entonces no me atraía tanto el tema. Leeré eso pronto.

No entiendo por qué me resulta tan complicado.

Los dibujos empiezan teniendo 3*3 cuadraditos, siempre los números serán iguales entre sí.

Como regla he puesto que, si son X*X, se muestren (X-1)*(X-1) dibujos en la pantalla, o sea que al inicio serían 2*2.

Una muestra:

Lo gris son separadores. Hay 2*2 dibujos o cuadros, de 3*3 cuadraditos cada uno. Son blancos o negros.

Hay 2^(3*3) dibujos posibles, creo, no importa si está mal el cálculo. Esa cantidad se quiere que se divida en 4, para que cada cuadro muestre la misma cantidad de dibujos.

Los dibujos se pueden representar mediante un número, especialmente uno binario. Como en Flash el negro es 000000, decido que el 0 represente negro y 1 blanco.

Quiero que se vayan mostrando dibujos en orden desde todo blanco, o sea, si los dibujos fuesen de 2*2 sería:
1er dibujo del 1er cuadro: 1111
2ndo dibujo de ese cuadro: 1110
3ero: 1101
el número va bajando, sin sobresaltos.

También quiero que inicialmente los dibujos varíen desde arriba e izquierda, por lo que, supongo, me conviene numerar a los cuadraditos así:
8 7 6
5 4 3
2 1 0
Así que el dibujo correspondiente a 111111110 sería:
0 1 1
1 1 1
1 1 1
O sea ¡al revés!

El número debe variar normal, pero debe aplicarse al revés, creo.

Creo que ya había logrado eso. Entonces quise que en vez de mostrarse todos los dibujos, se empiece por este:
1 1 0
1 1 0
0 0 0
No viene al caso por qué. La cosa es que se mostrarán menos dibujos, la cantidad a dividir en cuadros es distinta. Hay que averiguar qué cantidad es.

Hago esto:

	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+DibujoEnBinario);

Me da: DibujoEnBinario (_|): 110110000
Está bien.

Lo convierto a decimal, porque ese es el número de dibujo más grande que se mostrará, esa esa la cantidad que quiero repartir en los cuadros.

	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while	(NroDelCaracter < Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Me da 432.

Disminucion = Math.floor(DibujoaMostrar/Cuadros);
// Se llama disminución porque se comenzará mostrando...
// el dibujo que según el modo conque los numero,
// es el último, y se irá disminuyendo.

No creo que el error esté ahí, tampoco.

Pero como vieron en la imagen, el 1er cuadro (arriba izquierda, los cuadros están numerados normal) no muestra una _| sino una
 _
|

¿Qué estoy haciendo mal?

// Generador de dibujos.
// 
// Se insertarán cuadros numerados así:
// 0 1
// 2 3
// En cada uno se insertarán cuadraditos numerados al revés (ver...
// Por qué cuadraditos numerados inversamente.txt por detalles).
// 
// Usada en InsertarCuadros sólo 1 vez
// (ergo podría no ser una función, pero por ahora simplifica):
function AjustarVariables () {
	Cuadros = CuadrosPorFila*CuadrosPorFila;
	MaxCuadro = Cuadros-1;
	Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
	MaxCuadradito = Cuadraditos-1;
	LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
	LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
	// Esto es para que el 1er dibujo sea una |_ porque es el...
	// 1ero que tiene algún cuadradito pintado en cada fila y...
	// columna (en realidad el 1ero es el que tiene despintado el punto de unión, pero hay poca diferencia)
	// esto es para evitar que se salteén montones de dibujos.
	// Se averigua su número representante:
	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+DibujoEnBinario);
	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while (NroDelCaracter < Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);
	// Esa cantidad se dividirá según la cantidad de cuadros,
	// de modo que cada cuadro mostrará la misma cantidad de...
	// dibujos, pero distintos a los de otros cuadros:
	Disminucion = Math.floor(DibujoaMostrar/Cuadros);
	// Se llama disminución porque se comenzará mostrando...
	// el dibujo que según el modo conque los numero,
	// es el último, y se irá disminuyendo:
	// DibujoaMostrar = DibujoaMostrar-1;
	trace("DibujoaMostrar: "+DibujoaMostrar);
}
// Usada en InsertarCuadros una vez (totalmente innecesaria):
function ConvertiraBinarioInverso (numero) {
	trace(numero);
	// Averiguar cómo es en binario:
	DibujoEnBinario = "";
	while (numero>0) {
		DibujoEnBinario = DibujoEnBinario+numero%2;
		numero = Math.floor(numero/2);
	}
	// Agregar 0s a DibujoEnBinario si hacen falta:
	while (DibujoEnBinario.length<Cuadraditos) {
		DibujoEnBinario = DibujoEnBinario+0;
	}
	trace("DibujoEnBinario: "+DibujoEnBinario);
}
// Usada al inicio y cuando aumenta la cantidad de cuadraditos por fila:
function InsertarCuadros () {
	AjustarVariables();
	NroDelCuadroaColocar = 0;
	// Sus columnas y filas se cuentan desde 0 también:
	ColumnaDeCuadro = 0;
	FilaDeCuadro = 0;
	do {
		NombreDelCuadro = "Cuadro"+NroDelCuadroaColocar;
		attachMovie("sCuadro", NombreDelCuadro, NroDelCuadroaColocar);
		setProperty (NombreDelCuadro, _x, LargoDeCuadros*ColumnaDeCuadro+ColumnaDeCuadro*LargoDeCuadraditos);
		setProperty (NombreDelCuadro, _y, LargoDeCuadros*FilaDeCuadro+FilaDeCuadro*LargoDeCuadraditos);
		ColumnaDeCuadro++;
		if (ColumnaDeCuadro == CuadrosPorFila) {
			ColumnaDeCuadro = 0;
			FilaDeCuadro++;
		}
		// Se agregarán y distribuirán cuadraditos en el cuadro...
		// recién agregado, numerándolos del modo opuesto:
		NroDelCuadraditoaColocar = MaxCuadradito;
		// Sus columnas y filas se cuentan desde 0:
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		// Se pintarán de modo que muestren el dibujo...
		// acorde a la división de dibujos; averiguarlo:
		ConvertiraBinarioInverso(DibujoaMostrar);
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		do {
			eval(NombreDelCuadro).attachMovie("sCuadradito", "Cuadradito"+NroDelCuadraditoaColocar, NroDelCuadraditoaColocar);
			NombreDelCuadraditoSinNum = NombreDelCuadro+".Cuadradito";
			NombreDelCuadradito = NombreDelCuadraditoSinNum+NroDelCuadraditoaColocar;
			setProperty (NombreDelCuadradito, _x, ColumnaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _y, FilaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _width, LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _height, LargoDeCuadraditos);
			ColorDelCuadradito = new Color(NombreDelCuadradito);
			// Los números tomados del binario son los opuestos al cuadradito,
			// ya que los cuadraditos están numerados al revés.
			// Tomando el 1er caracter del binario y borrándolo para que...
			// en la próxima repetición se use el siguiente, se logra eso:
			NroDeColor = Number(DibujoEnBinario.charat(0));
			DibujoEnBinario = DibujoEnBinario.substring(1, DibujoEnBinario.length);
			if (NroDeColor == 0) {
				ColorDelCuadradito.setRGB(0);
			} else {
				ColorDelCuadradito.setRGB(0xFFFFFF);
			}
			// Esto es para modificar con más practicidad el color:
			set (NombreDelCuadro+".ColordeCuadradito"+NroDelCuadraditoaColocar, NroDeColor);
			ColumnaDeCuadradito++;
			if (ColumnaDeCuadradito == CuadraditosPorFila) {
				ColumnaDeCuadradito = 0;
				FilaDeCuadradito++;
			}
			NroDelCuadraditoaColocar--;
		} while (NroDelCuadraditoaColocar > -1);
		NroDelCuadroaColocar++;
		DibujoaMostrar = DibujoaMostrar-Disminucion;
		// trace("DibujoaMostrar: "+DibujoaMostrar);
	} while (NroDelCuadroaColocar < Cuadros);
}
// PorFila es también por columna:
CuadrosPorFila = 2;
// Debido a que en cierto chequeo se asume que...
// si el cuadradito no está en la parte inferior ni...
// superior entonces está en una fila intermedia,
// conviene que CuadraditosPorFila comience siendo >2:
CuadraditosPorFila = 3;

Probablemente obtengo el binario al revés y luego lo aplica al revés de eso, no sé, algunos cálculos me los dijo GPT ¿qué me conviene hacer?

Es Macromedia, no Adobe, Adobe aún no lo había comprado.

No tengo móvil.

Lo veo complicado, este asunto es porque había pensado en ofrecer juegos para empresas (aunque probablemente aún no puedo hacer algo de calidad aceptable), pero tendría que ser para móvil porque hoy día PC no usa mucha gente creo. Pero tendría que probar lo que dijiste, aunque no sé qué le puedan meter al convertirlo en otro formato :/

Mejor podría ser aprender a usar un programa conque los pueda hacer.

No tengo idea sobre celulares. Si pueden abrir archivos exe o no. swf supongo que no. O tal vez con un programa... o muy popular.


GPT:

En la imagen pueden verse 10 textos que son valores de colores: 000000, FF0000, 00FF00, y el resto son todos 999999.

Al lado de cada valor hay una columna de cuadraditos grises.

La idea básicamente es que tengan un color y al cliquearlos su color se transfiera al valor que muestra su texto asociado.

Cada columna de esas es una película con algo como esto:

onClipEvent (load) {
	ColorAsociado = 0;
	ColorDelCentro0 = 0xCCCCCC;
	ColorDelCentro1 = 0x999999;
	ColorDelCentro2 = 0x666666;
	ColorDelCentro3 = 0x333333;
}

en cada una los valores son distintos.
ColorAsociado se refiere a qué valor cambiará.
Lo demás se refiere a qué colores tendrán los centros de los cuadraditos.

Cada cuadradito tiene:

onClipEvent (load) {
	ColorDelCentro = _parent.ColorDelCentroX;
}

donde X es 0, 1, etc, según el cuadradito que sea.
Lo que hace es tomar de su película padre, el color que se le puso.
Si los cuadraditos tuvieran nombre, quizá se podría haber puesto al inicio algo como:
Cuadradito0.ColorDelCentro = 0xCCCCCC;
Cuadradito1.ColorDelCentro = 0x999999;
etc, tendría que probar.

Todos los cuadraditos tienen esto:


En frame 1:
ColorDelObjetoCentro = new Color(Centro);
stop ();

La parte del extremo (el borde, pero no le digo así porque tienen un borde con línea, que obvié) tiene transparencia.

El centro, llamado Centro, se extiende hasta el frame 2 y tiene:

onClipEvent (load) {
	_parent.ColorDelObjetoCentro.setRGB(_parent.ColorDelCentro);
}

Con esto, cada vez que la película va al frame 1 o al 2, el centro del cuadradito se pone del color que se le estableció.

El botón es un objeto invisible que ocupa todo el cuadradito y en el frame 1 tiene:

on (rollOver) {
	gotoAndStop (2);
}

Hace que, al señalarlo, la película vaya al frame 2.

Frame 2:

La parte extrema del cuadradito, ahora llamada Extremo, pero no sé si es necesario ponerle nombre, tiene:

onClipEvent (load) {
	ColorDelExtremo = new Color(this);
}
onClipEvent (enterFrame) {
	Rojo = random(256);
	Verde = random(256);
	Azul = random(256);
	ColorDelExtremo.setRGB(Rojo*65536+Verde*256+Azul);
}

Eso hace que cambie de color constantemente. Es un efecto visible para indicar que el botón está siendo señalado.

El centro ya dije que se extendía desde el frame 1, así que sigue igual.

El botón, que se extiende hasta el frame 3, tiene:

on (rollOut) {
	gotoAndStop (1);
}
on (press) {
	// El extremo de este botón tendrá el color del centro,
	// y él cambiará a colores random:
	ExColorDelCentro = ColorDelObjetoCentro.getRGB();
	gotoAndStop (3);
}
on (release, releaseOutside) {
	// El centro tendrá el color asociado (de unos cuadraditos):
	ColorDelCentro = _level0.PosiblesColores[_parent.ColorAsociado];
	ColorDelObjetoCentro.setRGB(ColorDelCentro);
	// Si se saltearon colores (es cuando se asigna el 5to...
	// sin haber asignado el 4to, por ej), asignar los intermedios al azar:
	NroDePosibleColoraAsignar = _level0.PosiblesColores.length;
	while (_level0.PosiblesColores.length < _parent.ColorAsociado) {
		ColorElegido = random(16711681);
		_level0.PosiblesColores[NroDePosibleColoraAsignar] = ColorElegido;
		// A continuación se modificará la variable que muestra...
		// el color, que existe porque el contenido de un array...
		// no se puede mostrar directamente. Se le agregarán "0s"...
		// si tiene menos de lo debido:
		ColoraAsignar = ColorElegido.toString(16).toUpperCase();
		while (ColoraAsignar.length < 6) {
			ColoraAsignar = "0"+ColoraAsignar;
		}
		set("_level0.ShowerDePosibleColor"+NroDePosibleColoraAsignar, ColoraAsignar);
		NroDePosibleColoraAsignar++;
	}
	// El color asociado de los posibles colores de los cuadraditos...
	// tendrá el color del extremo:
	_level0.PosiblesColores[_parent.ColorAsociado] = ColorDelExtremo.getRGB();
	// A continuación se modificará la variable que muestra...
	// el color, que existe porque el contenido de un array...
	// no se puede mostrar directamente. Se le agregarán "0s"...
	// si tiene menos de lo debido:
	ColoraAsignar = ColorDelExtremo.getRGB().toString(16).toUpperCase();
	while (ColoraAsignar.length < 6) {
		ColoraAsignar = "0"+ColoraAsignar;
	}
	set("_level0.ShowerDePosibleColor"+_parent.ColorAsociado, ColoraAsignar);
	_level0.InsertarCuadros();
	gotoAndStop (1);
}

Si el botón se deja de señalar, la película va al frame 1, donde la parte extrema del cuadradito ya no cambia de colores, queda como al inicio, un botón normal.

Dije lo que hace cuando se cliquea, pero no entiendo cómo lo hice o cómo lo hago mejor, diré más en el frame 3. Es un efecto visible de que el botón está siendo presionado, en vez de hundirse.

Lo que el botón hace cuando se suelta, lo hace luego de llegar al frame 3 porque fue ahí al cliquearse, así que lo vemos luego.

Frame 3:
ColorDelExtremo = new Color(Extremo);
ColorDelExtremo.setRGB(ExColorDelCentro);
Con esto el color del extremo del cuadradito queda como estaba su centro. Pensé que podría ponerlo en el botón en el código de cuando se cliquea, pero algo falla, no sé.

La parte extrema del cuadradito, Extremo, ya no tiene su código de cambiar colores.

El centro tiene:

onClipEvent (load) {
	ColorDeEsto = new Color(this);
}
onClipEvent (enterFrame) {
	Rojo = random(256);
	Verde = random(256);
	Azul = random(256);
	ColorDeEsto.setRGB(Rojo*65536+Verde*256+Azul);
}

Para que cambie de colores al azar, el efecto visible en vez de hundirse, que ya comenté.

Y ahora se aplicaría lo del botón.

// El centro tendrá el color asociado (de unos cuadraditos):
ColorDelCentro = _level0.PosiblesColores[_parent.ColorAsociado];
ColorDelObjetoCentro.setRGB(ColorDelCentro);

En cuanto a cuadraditos es lo mismo que tomar el valor que tiene su texto asociado. Es como que los colores se intercambian, el color central es ahora como indica el texto pero el texto queda como era el color central. Es como si hubiera 5 opciones: 4 en los cuadraditos y la elegida en el texto, entonces al elegir otra se pasa al texto y la que estaba elegida pasa a las elegibles.

// Si se saltearon colores (es cuando se asigna el 5to...
// sin haber asignado el 4to, por ej), asignar los intermedios al azar:
NroDePosibleColoraAsignar = _level0.PosiblesColores.length;
while (_level0.PosiblesColores.length < _parent.ColorAsociado) {
	ColorElegido = random(16711681);
	_level0.PosiblesColores[NroDePosibleColoraAsignar] = ColorElegido;
	// A continuación se modificará la variable que muestra...
	// el color, que existe porque el contenido de un array...
	// no se puede mostrar directamente. Se le agregarán "0s"...
	// si tiene menos de lo debido:
	ColoraAsignar = ColorElegido.toString(16).toUpperCase();
	while (ColoraAsignar.length < 6) {
		ColoraAsignar = "0"+ColoraAsignar;
	}
	set("_level0.ShowerDePosibleColor"+NroDePosibleColoraAsignar, ColoraAsignar);
	NroDePosibleColoraAsignar++;
}

Eso se supone que está bien explicado y lo entiendo, no le veo problema tampoco.

// El color asociado de los posibles colores de los cuadraditos...
// tendrá el color del extremo:
_level0.PosiblesColores[_parent.ColorAsociado] = ColorDelExtremo.getRGB();
// A continuación se modificará la variable que muestra...
// el color, que existe porque el contenido de un array...
// no se puede mostrar directamente. Se le agregarán "0s"...
// si tiene menos de lo debido:
ColoraAsignar = ColorDelExtremo.getRGB().toString(16).toUpperCase();
while (ColoraAsignar.length < 6) {
	ColoraAsignar = "0"+ColoraAsignar;
}
set("_level0.ShowerDePosibleColor"+_parent.ColorAsociado, ColoraAsignar);

Esto sería lo más importante, que el color cliqueado se transmita al valor que muestra el texto. La mención a cuadraditos es porque aparecerán en pantalla unos, que deben poder tener el color cliqueado. Con todo esto y otro código se logra.

_level0.InsertarCuadros();
gotoAndStop (1);

Eso inserta dibujos con cuadraditos y el goto hace que el botón vuelva a quedar normal, mostrando en su centro qué color pondrá en el texto si se cliquea.


Todo esto es que empecé a revisarlo y no lo entendía, y algunas cosas aún no las entiendo, si se pueden hacer mejor o no. Díganme cómo hacerlo mejor o explíquenme por qué no se puede.