Yo también recuerdo algo de eso, pero no muy detalladamente ¿qué significa fecha 0? ¿la fecha que tuviera el sistema actual?

No es que lo jure, es como que descargue esta página, que dice Publicado en: 5 Mayo 2024, pero el archivo diga (en Windows) que la última modificación fue en 2003.

A la fecha de creación no le doy bola porque no me aparece en los exploradores y además como son archivos copiados desde cds o dvds quedan con la fecha conque los copié.

Ya está (sin líneas):


Con líneas queda negro:

No hay modo de achicarlas... que yo sepa. Les puse el mínimo tamaño de trazo. Tal vez si las convierto en relleno y achico el relleno, pruebo.

Estuvo buena tu idea pero no sirvió:

Voy a probar otras cosas.

Quiero hacer más rápido esto que me resulta difícil.

Nota: X puede ser monedas, estrellas, cualquier cosa de un videojuego, en esta tarea no es necesario especificarla.

La hoja 1 está completa:


La hoja 2 está completa (vean que lo obtenido en la hoja 1 es usado aquí como base):


La hoja 3 no, y no sé cuántas hojas quiero hacer:


El problema de que un programa lo haga (sólo una lista, no como las imágenes) es que hay casos especiales, no es tan fácil saberlos a priori o que el programa los produzca bien cuando debe ¿qué me recomiendan?

Estás jugando Don Doko Don 2, es una secuela de Don Doko Don (1), y te dije que ese es más difícil que el 2, al menos para mí. Este es el 1:
https://www.youtube.com/watch?app=desktop&v=BxjU_SFKx8Q
Ese nunca lo pasé, el 2 sí.

Si tengo una tablero de XxX casilleros y quiero distribuir Y colores ¿cómo defino de qué color es cada casillero?
Por ejemplo si X es 3 e Y es 6 quiero esto:
112
233
456
Es decir, se reparte 9 entre 6 y lo que sobre se da a los 1eros colores.
El casillero 1 debe ser de color 1.
El 2 de color 1.
El 3, 2.
4, 2.
5, 3.
6, 3.
7, 4.
8, 5.
9, 6.
¿Cómo logro eso? X e Y pueden variar, claro.

Me dieron una supuesta solución en otro lado pero no pude hacerlo funcionar:
Mi código (no es sobre asignar colores sino "ModificacionesRequeridas", pero la idea es la misma):

DibujosPorFila = 5;
MaxCuadro = DibujosPorFila*DibujosPorFila;
CuadraditosPorFila = 4;
MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila;
DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila);
Resto = MaxCuadro%CuadraditosPorFila;
on (release) {
	// Los dibujos serán como el de encima de este botón
	// y mutarán:
	Dibujo = 0;
	// Repetir para el dibujo 1, 2, etc:
	do {
		Dibujo++;
		// El dibujo a copiar no necesita ser modificado:
		if (Dibujo != _parent.ID) {
			Cuadradito = 0;
			// Repetir hasta que todo cuadradito se haya copiado,
			// por ahora no hay mutación:
			do {
				Cuadradito++;
				ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
				ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
				ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
			} while (Cuadradito<_level0.MaxCuadradito);
			// 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;
			if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) {
				ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
			} else {
				ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones);
			}
			trace(Dibujo+": "+ModificacionesRequeridas);
			// Cosas que no vienen al caso.
		}
	} while (Dibujo<_level0.MaxCuadro);
}

Resultado:
(Nro de casillero, número asignado (que puede entenderse como color)):
2: 1
3: 1
4: 1
5: 1
6: 1
7: 1
8: 3
9: 3
10: 3
11: 3
12: 3
13: 4
14: 4
15: 4
16: 4
17: 4
18: 4
19: 5
20: 5
21: 5
22: 5
23: 5
24: 5
25: 6

Necesito que sea:
Del 1 al 7: Son de 1.
De 8 a 13: De 2.
De 14 a 19: De 3.
De 20 a 25: De 4.
11111
11222
22233
33334
44444

¿Te refieres al mío o al que escribiste? Si es el mío ¿por qué te da pereza?

Un espacio de XxX píxeles se divide en YxY cuadraditos. X no recuerdo cuánto es e Y va aumentando a medida que se muestran los dibujos posibles de 2 colores. Así, el tamaño de los cuadraditos va disminuyendo porque deben entrar cada vez más en el espacio pero el espacio disponible es fijo.
Aquí tienes una pequeña muestra, algo antigua:
https://www.youtube.com/watch?v=0x5fEw8LGP4

No entiendo la pregunta, pero si te refieres a que si habrá de esos, supongo pero cuando la cantidad de cuadraditos por fila sea igual al tamaño de la hoja, cosa que no he llegado a probar. Estoy intentando evitar ciertos dibujos indeseados antes de dejar que el programa llegue a tantos cuadraditos por fila.

No se cuentan así, se cuentan individualmente, un cuadradito es el mínimo tamaño en un dibujo, es una simulación de un pixel, simplemente se ve más grande.

Por ahora sólo negros, pero entiende que lo blanco también son cuadraditos de color blanco que pueden cambiar a negro y viceversa, digo que son fondo porque... cuando sean más colores (aún no), es así, como el fondo de la hoja, no es el dibujo...

Podía dar el código completo pero no creí que alguien quisiera leer tanto, además ya puse similares en temas anteriores. Lo subo a un txt para que no ocupe tanto espacio en el post:
https://drive.google.com/file/d/13dSzreVp-WgV0RMKvaRTncqB84lMj3mJ/view?usp=sharing
Y aquí tienes el editable:
https://drive.google.com/file/d/11ksgI1ZEgOSTf0o7X_TRVFLAXPmStT9F/view?usp=sharing
No funciona y aunque dice "ifs terminados", en realidad es sólo un grupo. Se me ocurrió una forma de simplificar la tarea, básicamente es tener guardado cuales coordenadas (filas y columnas) están pintadas, lo estaba evitando porque quería evitar crear variables innecesarias; si funciona como pienso cuando lo tenga hecho lo posteo.

Ok, si no me funciona lo que se me ocurrió intento aplicar lo tuyo, no lo entiendo bien.

Edit: Tras los cambios requeridos en el fotograma 2 que no vienen mucho al caso, tengo esto:

function Variar () {
	ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero;
	ColoraModificar = eval(ReferenciaAlColoraModificar);
	// ¿El cuadradito puede cambiar de color?
	if (ColoraModificar<1) {
		// Sí, hacer los cambios:
		set (ReferenciaAlColoraModificar, ColoraModificar+1);
		NuevoColor = new Color("Cuadradito"+Puntero);
		NuevoColor.setRGB(0);
		// Obtener fila y columna del cuadradito:
		Fila = Math.ceil(Puntero/CuadraditosPorFila);
		Columna = (Puntero-1)%CuadraditosPorFila+1;
		set("Cuadradito"+Fila+"_"+Columna, 0);
		// Para juzgar:
		// ¿El dibujo tiene menos de Largo/2 cuadraditos aislados?
		// Se actualizará el contador de pintados aislados:
		// De cada pintado al lado del recién pintado,
		// se verá si estaba aislado,
		// en cuyo caso disminuirá el contador.
		// Si no hay pintados al lado del nuevo, aumentará.
		// Esta variable puede cambiar:
		CuadraditoAislado = "Sí";
		Fila2 = Fila+1;
		Columna2 = Columna+1;
		// Si su inferior derecho existe y está pintado,
		// entonces el actual no está aislado,
		// y se mira si el infder estaba aislado:
		// Cuántos de sus contiguos están pintados.
		// Por practicidad se cuenta también el recién pintado.
		// Si la cantidad es 1, estaba aislado,
		// el contador de Aislados baja.
	// CONVERTIR EN FUNCIÓN:
		// ¿El contiguo indicado está pintado?
		if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0 ) {
			// Sí, el recién pintado no está aislado:
			CuadraditoAislado = "No";
			// Se contarán los contiguos de este (contiguo al recién...).
			ContiguosPintados = 0;
			Fila3 = Fila2+1;
			Columna3 = Columna2+1;
		// CONVERTIR EN FUNCIÓN2:
			// ¿El contiguo indicado está pintado?
			if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0 ) {
				// Sí, aumentar contador:
				ContiguosPintados++;
			}
		//
			Columna3--;
			// APLICAR FUNCIÓN2
			// Continuar modificando Col3 y fila3 y rellamando a la func2.
		}
	//
		Columna2--;
		// APLICAR FUNCIÓN
		// Continuar modificando Col2 y fila2 y rellamando a la func.
 
// en vez de usar CuadraditoAislado = "Sí"; se podría definir
// ContiguosPintados = 0; desde el inicio y si aumentó entonces
// se entiende que ek recién pintado no estaba aislado.
// Pero igual ese contador debe reiniciarse cada vez que se empieza a contar,
// pero en esos casos siempre es 1 mínimo.

No sé si funciona bien pero ahí está la idea. Falta agregar lo que dije ahí. En unos días o algo así supongo que estará.

Nah, lo suyo es más bien como ir a un hospital a preguntar dónde puede hablar con sicarios xD  Aunque tampoco es que aquí todo sea tan "white".

PD: Yo estoy aquí porque me gusta usar PC, la programación y videojuegos, mi interés por el hacking no es mucho, y no conozco otros foros de eso, ni he buscado.

Quiero llamar a una función variable de la raíz (level0) desde una película.

Si fuese una función fija sería: _level0.NombreDeLaFuncion();

Llamar a una función variable de la raíz, desde la raíz, creo que sería:
FuncionALlamar = "Funcion1";
eval(FuncionALlamar)();

Si fuese FuncionALlamar = "_level0.Funcion1";
quizá funcionaría desde una película, se me acaba de ocurrir, pero he estado probando cosas y nada funciona. ¿Cómo sería?
"_level0."+eval(_level0.FuncionALlamar)();
o
eval("_level0."+_level0.FuncionALlamar)();

No recuerdo qué cosas probé, la solución que puse funcionó (no me gustaba porque me parecía inconveniente extender innecesariamente el valor de la variable), pero estoy liado en cuanto a qué hacen esas líneas. eval usa texto y variables para indicar el nombre de una variable y si existe devuelve su valor, pero si luego hay un () entonces ese nombre es de una función a la cual llama. Hasta ahí entiendo ¿está bien, no? Pero con lo del _level0. me lié.

---------------------------------------------------------------------------------------------------------

Otra pregunta.

Tengo por ahí:
PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];

Y uso esta función luego:

function ModificarP2() {
	if (P2Valor<6) {
		P2Valor++;
		P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
	} else {
		Continuar = "No";
	}
}

La idea es que P2 cambie a "!=", luego a "<=", y así sucesivamente pero no funciona. Es que esto:
P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
lo hice basado en algo que me dijeron pero no entiendo qué hace. Obtiene la parte [a definir] del array llamado PosiblesSignos ¿no? Ahora creo que alcanza con decir:
P2 = PosiblesSignos[P2Valor];
Sí, ahora me funcionó. ¿Pero qué es esto:
P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
? Debo haber copiado mal  

---------------------------------------------------------------------------------------------------------

Finalmente: ¿Es posible simplificar este código, cómo?

// Este programa genera una comparación simple y su evaluación, pero:
// Debe haber alguna parte cuyo contenido no está definido.
// Ejemplo: 1 < ... : true
// Luego intenta asignar el contenido faltante,
// pero por ahora sólo si falta sólo 1.
// Las siguientes funciones se usan en Resolvedor1, etc:
function Comparacion() {
	if (P2 == "==") {
		Resultado = P1 == P3;
	} else if (P2 == "!=") {
		Resultado = P1 != P3;
	} else if (P2 == "<=") {
		Resultado = P1 <= P3;
	} else if (P2 == ">=") {
		Resultado = P1 >= P3;
	} else if (P2 == "<") {
		Resultado = P1 < P3;
	} else {
		Resultado = P1 > P3;
	}
	return Resultado+"" == P4;
}
function ModificarP1() {
	if (P1<10) {
		P1++;
	} else {
		Continuar = "No";
	}
}
function ModificarP2() {
	if (P2Valor<6) {
		P2Valor++;
		P2 = PosiblesSignos[P2Valor];
	} else {
		Continuar = "No";
	}
}
function ModificarP3() {
	if (P3<10) {
		P3++;
	} else {
		Continuar = "No";
	}
}
function ModificarP4() {
	if (P4 == "true") {
		P4 = "false";
	} else {
		Continuar = "No";
	}
}
// Se repite en F2, cuando hay 1 contenido indefinido y es el 1:
function Resolvedor1 () {
	trace("Se probará el Candidato "+eval("P"+Indefinido));
	if (Comparacion()) {
		trace ("Solución hallada, ver respuesta.");
		Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4;
		gotoAndStop (3);
	} else if (Continuar == "Sí") {
		// Se modificará el candidato:
		eval(ModificadoraUsar)();
	} else {
		trace ("No se pudo hallar una solución.");
		gotoAndStop (3);
	}
}
PosiblesTiposDeContenido = ["Normal", "Indefinido"];
PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];
// Generar las 4 partes hasta que se cumpla la condición:
do {
	Indefinidos = 0;
	// Parte 1 (cosa 1 a comparar):
	TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte1 == "Normal") {
		Parte1 = random(10);
	} else {
		Parte1 = "...";
		Indefinidos++;
		Indefinido = 1;
		// set("Indefinido"+Indefinidos, 1);
	}
	// Parte 2 (símbolo comparador):
	TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte2 == "Normal") {
		Parte2 = PosiblesSignos[random(6)];
	} else {
		Parte2 = "...";
		Indefinidos++;
		Indefinido = 2;
		// set("Indefinido"+Indefinidos, 2);
	}
	// Parte 3 (cosa 2 a comparar):
	TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte3 == "Normal") {
		Parte3 = random(10);
	} else {
		Parte3 = "...";
		Indefinidos++;
		Indefinido = 3;
		// set("Indefinido"+Indefinidos, 3);
	}
	// Parte 4 (evaluación):
	TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte4 == "Normal") {
		// Definir esta parte según las anteriores:
		// ¿Fueron definidas?
		if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") {
			// Sí, ver qué definición corresponde:
			if (Parte2 == "==") {
				Parte4 = Parte1 == Parte3;
			} else if (Parte2 == "!=") {
				Parte4 = Parte1 != Parte3;
			} else if (Parte2 == "<=") {
				Parte4 = Parte1 <= Parte3;
			} else if (Parte2 == ">=") {
				Parte4 = Parte1 >= Parte3;
			} else if (Parte2 == "<") {
				Parte4 = Parte1 < Parte3;
			} else {
				Parte4 = Parte1 > Parte3;
			}
		} else {
			// No toda parte fue definida,
			// definir esta al azar:
			Parte4 = random(2);
			if (Parte4 == 0) {
				Parte4 = "true";
			} else {
				Parte4 = "false";
			}			
		}
	} else {
		Parte4 = "...";
		Indefinidos++;
		Indefinido = 4;
		// set("Indefinido"+Indefinidos, 4);
	}
} while (Indefinidos == 0);
Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4;
// Marca si algún canditato puede modificarse:
Continuar = "Sí";
// Decidir qué resolvedor usar y preparar variables:
if (Indefinidos == 1) {
	P1 = Parte1;
	P2 = Parte2;
	P3 = Parte3;
	P4 = Parte4;
	// Asignar un valor al contenido indefinido:
	if (Indefinido == 1) {
		P1 = 0;
	} else if (Indefinido == 2) {
		P2Valor = 0;
		P2 = "==";
	} else if (Indefinido == 3) {
		P3 = 0;
	} else {
		P4 = "true";
	}
	ResolvedoraUsar = "_level0.Resolvedor"+Indefinidos;
	ModificadoraUsar = "ModificarP"+Indefinido;
} else {
	Mensaje = Mensaje+"\nAún no hay resolvedor para esta duda.";
	stop();
}

La idea es solucionar problemas así cada vez más complejos. Esto es sólo el comienzo...

Ha habido frío y cuando eso sucede no uso mucho el mouse, así que sobre esto no había hecho mucho más hasta ayer. Además he estado ocupado, sólo pasó 1 día, cuando me quede cómodo te respondo bien, ahora estoy comiendo.

Ya.

Eso también lo había visto, pero parece demasiado complejo ponerme a hacer cálculos para esto. Mira, esto me dijeron en Quora:
Si entiendo bien lo que dices en tu comentario eso se llama "perspectiva".

En todos los programas de edición de imágenes, como Photoshop, Illustrator, GIMP o Inkscape, hay herramientas para transformar un objeto plano en un objeto con perspectiva.

En GIMP (editor de imágenes en mapa de bits gratuito) está en el menú Herramientas > Herramientas de transformación > Perspectiva:



Eso era lo que buscaba pero como ese programa no me sirvió (los ladrillos se agrandan demasiado) decidí hacerlo a mano, agrandé la imagen y le encontré la vuelta:
- En vez de los colores que usaré, usar en principio colores vistosos, cambiarlos luego.
- Ir pintando los ladrillos de modo horizontal, que ahí es diagonal, es decir, 1ero una fila, luego la otra, etc. Yo estaba haciendo de arriba hacia abajo. Es simplemente buscar la siguiente raya | borrarla y pintar.
Por ahora lo tengo así:

Vista ampliada de una parte:

Básicamente sólo me falta poner los colores rojizos y líneas. Los tamaños quedaron mal porque Flash delira en eso, yo iba estirando las líneas de a una a la vez y algunas filas quedaron más altas que otras, no lo voy a cambiar por ahora, no lo necesito perfecto xP

Las nuevas cosas que dices me parecen más sencillas que lo de hacer cálculos pero aún no lo capto bien.