Tras cliquear en el dibujo superior izquierdo, los demás quedan igual excepto que en este caso los de la fila 1 deben tener 1 diferencia (excepto el que fue cliqueado), los de la fila 2 deben tener 2, y así. Eso no sucede aquí:

Señalé que en la fila 1 hay 1 cambio donde debe, pero en la 4 a veces hay 4, 3, 2 o incluso puede haber 1 porque mi código debe ajustarse para eso ¿cómo?

			// Repetir hasta que se haya variado esa cantidad...
			// de cuadraditos:
			CuadraditosModificados = 0;
			do {
				CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
				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());
				// Repetir mientras el color no cambie:
				do {
					NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
				} while (NuevoColor == SavedeColoraSustituirse);
				ColoraSustituirse.setRGB(NuevoColor);
				// trace ("NuevoColor: "+NuevoColor);
				CuadraditosModificados++;
			} while (CuadraditosModificados<ModificacionesRequeridas);

Si precisan más código avísenme, eso es para modificar los cuadraditos de 1 dibujo, en otras partes se varía cual dibujo. El problema es que se modifica un cuadradito al azar, repetidamente, de modo que cada nuevo modificado puede ser alguno que ya haya sido modificado, por eso aunque en el código se hacen las modificaciones la cantidad de veces requeridas, en la práctica y a la vista pueden ser menos.

¿Debo crear una lista de los modificados y repetir si el nuevo modificado ya lo fue? ¿ha<y alguna alternativa más eficiente, o cómo hago eso? Ya se está repitiendo el cambio de color hasta que efectivamente ocurre (ya que el nuevo es random pero por eso puede ser igual al anterior; se repite para evitar eso), así que en lo posible no quisiera repetir tanta cosa...

Edit:
Acabo de ver que el 2ndo de la 2nda fila es totalmente igual al cliqueado, así que el código está peor de lo que pensé ¿cómo lo mejoro? O tal vez se modificó 1 cuadradito y luego se volvi´a modificar de modo que quedó como estaba, sería como lo que expliqué entonces, no sería un error extra, tal vez.

Lo bueno:
- Es una opción a ver a quien le interese.
- Implicaría más actividad en el foro, si hay participación ahí.
- Puede atraer a más usuarios, tal vez.

Posibles problemas:
- Spammers. No me refiero a que muchos vengan, publiquen sus cosas una vez y adiós, eso no sé si sería un problema, sino que me refiero al caso de que la gente publique casi lo mismo a cada rato: "Agregué una opción al menú", "agregué otra", etc. Yo mismo podría ser que haga algo así, aunque no por gusto.
- Desorden. Si se postean muchas cosas será un tema de cosas un poco random, no sé si lo consideran un problema. Ya hay un tema donde la gente pùblica canales de YT, o sus blogs, esto sería parecido pero podría ser más activo.
- Más trabajo para los mods, posibles links a malware de usuarios que luego nunca más participen...

¿Hay posibles soluciones, o prevenciones?
Por ejemplo para el 1 se podría limitar el número de post por semana, o mes, o si trabajan en más de 1 proyecto podría limitarse la cantidad de post por semana/mes sobre cada proyecto (es decir se pueden hacer 2 mensajes por semana, por ejemplo, si es sobre 2 proyectos distintos). Pero eso no evita que se puedan postear pequeñeces o incluso "Esta semana se me complicó".
Para el 3, en caso de ser usuarios nuevos se podría exigir que pongan una imagen, código o video a YT, no sólo el link a quien sabe dónde y qué.

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?

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

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...

Por ejemplo aquí se considera que no hay:

En este contexto lo blanco no se considera pintado, es fondo. Todos los cuadraditos pintados tienen al menos 1 pintado al lado (diagonal también cuenta).

Estoy haciendo un generador de dibujos así y quiero que no muestre (o que no genere, sería lo ideal) los que tengan cierta cantidad de cuadraditos pintados aislados. La cantidad depende del tamaño del dibujo, no importa aquí cual es. El dibujo se va modificando de a 1 cuadradito, se pinta uno, o se despinta uno (o más) y se pinta otro. Así, debo hacer algo como:
- Cuando se pinte uno nuevo, mirar si al lado hay otro. Si no hay, incrementar el contador de aislados. Si hay, ver si ese o esos estaban aislados, en cuyo caso disminuir el contador cuanto corresponda (según cuantos eran los aislados).
- Cuando se despinte uno, mirar si hay cuadraditos pintados al lado. Si no hay, disminuir el contador de aislados. Si hay, mirar al lado de cada uno y aumentar el contador de aislados por cada uno que haya quedado aislado.

Mi pregunta es: ¿Hay un modo más fácil? ¿es posible que lo haga GPT o algo así? Es que es mucho código... Por ahora hice esto y luego vi que no sirven else ifs, sólo ifs:

		// 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á.
		CuadraditoAislado = "Sí";
		// ¿El modificado es el inferior derecho?
		if (Puntero == MaxPosiciondePuntero) {
			// Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu):
			// xSS
			// xS*
			if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
 
 
if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero > MinCuadraditoInferior) {
			// Inferior no en una esquina,
			// contar el +1 (derecho), -1, -L+1 (du), -L y -L-1:
			// SSS
			// S*S
			if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero == MinCuadraditoInferior) {
			// Inferior izquierdo,
			// contar el +1, -L+1 y -L:
			// SSx
			// *Sx
			if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero > CuadraditosPorFila) {
			// No es superior.
			if (Puntero%CuadraditosPorFila == 0) {
				// Central derecho,
				// contar el +L, +L-1, -1, -L y -L-1:
				// xSS
				// xS*
				// xSS
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				}
			} else if (Puntero%CuadraditosPorFila != 1) {
				// Central, contar todos los contiguos:
				// SSS
				// S*S
				// SSS
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				}
			} else {
				// Central izquierdo,
				// contar el +L+1, +L, +1, -L+1 y -L:
				// SSx
				// *Sx
				// SSx
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				}
			}
		} else if (Puntero == CuadraditosPorFila) {
			// Superior derecho,
			// contar el +L+1, +L y +1:
			// *Sx
			// SSx
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
			}
		} else if (Puntero > 1) {
			// Superior cemtral,
			// contar el +L+1, +L, +L-1, +1 y -1:
			// S*S
			// SSS
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else {
			// Superior izquierdo,
			// contar el +L+1, +L y +1:
			// *Sx
			// SSx
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
		}
		if (CuadraditoAislado == "Sí") {
			CuadraditosAislados++;
		}

Es decir, ahí sólo estoy viendo si el cuadradito nuevo está aislado ¡me falta ver si sus contiguos lo estaban! (o si lo están sin contar al nuevo) y me falta el caso en que se despinta un cuadradito. ¿Tal vez se podrían usar functions para evitar repetir código? No sé bien cómo. Además, siendo tanto, puede que haya cometido algún error :/

Algo cerca del cerro, hubo una fila de varias luces similares a las de estrellas, a considerable distancia entre sí. Entre todas ocuparían el largo del cielo que alguien puede ver, más o menos. Hubo también unas pequeñas luces instantáneas y a veces vi algunas que iban a otra dirección. En eso vi un avión hacer un movimiento distinto al que suelo ver hacer, pero a esta hora no suelo verlos. Hizo una especie de curva. Las luces iban a su misma velocidad más o menos.

Si alguien puede averiguar algo, agradezco.

Ah, cierto, no tenía con qué filmarlos ni tomarles fotos, sorry.

explícame cómo funciona el desplazamiento | en programación

GPT:

y el and?


para qué sirven esos desplazamientos, por qué se le llama desplazamientos?


dame un ejemplo de un operador or usado en un programa


dame otro ejemplo, pero relacionado con videojuegos


No entiendo ¿no es más fácil algo como:
HABILIDAD_SALTO = true
HABILIDAD_CORRER = true
HABILIDAD_ATACAR = true
HABILIDAD_PLANEAR = false
Si HABILIDAD_SALTO == true
  puede saltar
etc? O en vez de true/false, "Sí"/"No", 1/0, etc.

Yo quiero aprender eso del or y and si es algo que no se puede hacer de otro modo o resulta mucho más fácil hacerlo así. Si es por agilizar procesos, entiendo que es importante pero por ahora paso.

A un número le puedo sumar otro, eso es útil y difícilmente insustituible.

El or viene a decir que a 2 binarios los puedo transformar en 1, uno tiene más probabilidad de tener 1s ¿pero eso para qué sirve?

Capaz que los ejemplos que me dió son incorrectos, imagino que si se tienen 2 cosas a comparar, con muchas variables, en vez de hacer:
SumaDe1 = Objeto1TieneCuello+Objeto1TieneManos+Objeto1TienePiernas
SumaDe2 = Objeto2TieneCuello+Objeto2TieneManos+Objeto2TienePiernas
Si SumaDe1 == SumaDe2
  los objetos son iguales
...
usando or se podría hacer la comparación sin sumar ni usar 3 ifs ¿puede ser?

https://drive.google.com/file/d/1BSfitRU9lBvKPfmlnQ9Vw0W5aNcHVQyE/view?usp=sharing

Lo intenté pero no le veo mucho uso práctico por ahora ¿tal vez no es programación genética lo que hice?

No le puse interfase así que para usarlo mejor (modificarlo a voluntad) se requiere Flash (el editor de archivos fla). Actualmente genera 5*5 dibujos (hojitas) en la pantalla, cada uno de 10*10 cuadraditos, pero eso se puede cambiar, el código está en el frame 1:
DibujosPorFila = 5;
CuadraditosPorFila = 10;
Si cambian eso y ponen Probar película, ya está.

Los colores actuales son blanco, negro, azul y la separación entre los dibujos es verde, todo fácimente modificable también, pero ese código está en la película Cuadros:
PosiblesColores = [0xFFFFFF, 0x0000FF, 0x000000];
Se pueden modificar o agregar. Si quisieran muchísimos colores o todos entonces tendrían que hacer varios cambios, pero es que no lo hice con la intención de que pudiera haber tantos porque es más bien para generar sprites y suelen tener pocos.

Cuando hacen clic a un dibujo, los demás dibujos quedan como él excepto por un cuadradito, que es el mutado. Puede haber algún error en el proceso (el código está en el botón que hay en la película Botón) pero el resultado según veo es correcto (en algún caso me pareció que en algún dibujo la imagen no mutó), sólo que, como di a entender, no me parece tan útil como esperaba, es decir, la idea es que uno elija el dibujo que más le guste, se generan parecidos, reelige, y así, pero como los iniciales son tan sin sentido y sólo se va modificando de 1 cuadradito, el resultado es... dibujos sin sentido, demasiado similares como para ver rápido las diferencias, y parece que da igual cual se elija entonces, o uno quiere que se pinte cierto punto pero en tal caso conviene dibujar a mano.

¿Es posible mejorarlo? ¿cómo?

Algunas ideas que no he aplicado, y difícil que lo haga porque no creo que cambie mucho:

- Que en vez de variar sólo 1 cuadradito, varíe por ejemplo (CuadraditosPorFila) cuadraditos, es decir, si CuadraditosPorFila es 10 entonces los dibujos tienen 100 cuadraditos, de los cuales variarán 10.
Es que no le veo mucho sentido, si el dibujo elegido es el que más gusta ¿entonces por qué variarlo tanto? Ahora se me ocurre que en un dibujo se varíe 1, en otro 2, etc, eso podría ser...

- Que los dibujos tengan todos los colores especificados.
Que si dices que los posibles sean 9, en los dibujos siempre haya 9. Cuando se dice los colores posibles en realidad se está diciendo los que ha de tener el sprite, ni más ni menos, así que tiene sentido para mí.

- Evitar que lo producido en uno se produzca en otro.
También, aunque si tienen muchos cuadraditos y colores es poco probable que se produzcan iguales.

- Evitar que se produzcan dibujos antes producidos.
Sí pero bastante difícil de aplicar, al menos para mí, no le veo sentido a intentarlo por ahora.

- Posibilidad de que los dibujos no sean de X*X cuadraditos, sino de X*Y.
Es decir que puedan ser rectangulares en vez de siempre cuadrados. Puede ser útil si se quiere dibujos rectangulares porque sino es probable que lo que sería fondo tuviese cuadraditos que lo harían parecer otra cosa, ruido, pero no me convence del todo... Los dibujos rectangulares se pueden hacer en hojas cuadradas si son más grandes...

- Hacer que una imagen tomada de otro lado aparezca en cada dibujo.
En realidad esto sería otra cosa, un modificador random de imágenes, luego programación genética. Para esto, en vez de pintarse X*X cuadraditos (lo cual taparía la imagen), se insertaría 1 en el dibujo 1, 2 en el 2, etc, de colores al azar según los especificados, y cuando se cliqueé un dibujo eso se transmitiría a los demás, y mutarían. Un modo más fácil es que todos los cuadraditos estén en modo invisible, excepto los que fueron "insertados".
No sé si en algo hecho en Flash se puede pegar una imagen o especificar que se cargue una, un archivo, pero se puede poner en el editor y listo.

En fin, puede que intente algo de eso pero lo que haré es que los dibujos pue, ah, no, es un sin sentido >__< había pensado esto:
Eso sólo tiene sentido si los dibujos tienen 3*3 cuadraditos, o si fuesen de 5*5 y hubiera 25 dibujos, en el dibujo 1 se modificaría el cuadradito 1, en el 2 el 2, etc, m... en definitiva sirve sólo si la cantidad de dibujos es igual o mayor a la de cuadraditos por fila^2, ah, entonces sí puede servir. m... Nah, ya no le veo utilidad a la idea tampoco, sólo sirve para saber fácil qué cuadradito se modificó, pero eso es poco útil a menos que se busque que se modifique en cierto lugar pero en tal caso conviene modificarlo manualmente.

En fin ¿ideas? Por ahora intentaré el modificador de imágenes.

Supongamos que un anónimo de Internet (en teoría) quiere enviar algo a otro anónimo, de otro país, sin que se pierda el anonimato.

No sé cómo funciona el correo físico pero supongo que probablemente te piden tu nombre, y sobretodo la dirección a donde enviar el paquete.

Pero lo que digo podría ser algo así:
- A la persona a quien se lo vas a enviar, le dices un password.
- Vas a la oficina de correos y dices que se lleve a la oficina de X ciudad donde está la persona, y se lo den a la que diga el password.
- La persona va, dice el password, y le dan el paquete.

¿Eso existe o no?

GPT:
No entendí bien si es posible que no se den nombres. El paquete podría ser revisado por los del correo, en eso no hay drama, supongo que lo podrían querer robar pero eso incluso si en teoría no deben chequearlo, no sé cómo es el sistema, supongo que de algún modo lo chequean, por si es una bomba o algo así.

¿Le ven algún problema? ¿gente que le pueda dar un mal uso, cómo? ¿podría ser un buen negocio? Yo no creo tener la habilidad ni el capital como para iniciarlo, el que quiera y pueda aquí lo tiene.

- Puede haber gente que vaya y diga passwords random a ver si acierta. Lo veo difícil, ambos casos, pero se podría cobrar por cada password mal que se diga.

- Gente que envíe cosas al cohete, para molestar. También difícil, más si se cobra por enviarlo, nadie lo haría así. Además la oficina podría advertir que, pasado 1 mes sin que haya sido reclamado, el paquete quedará a su disposición.

- Diferente gente que envíe cosas distintas al mismo lugar con el mismo password. Uf, aunque es poco probable, esto sería una complicación, no se le puede decir "ese password ya existe, use otro", porque entonces podría decirle a su amigo que vaya a la oficina a decirlo y recibir un paquete que él no envió. Una posible solución es exigir que los passwords cumplan ciertas condiciones según los que hayan sido asignados. Por ejemplo si ya existe el password 0123456789, cuando se vaya a entregar algo se diría "¿De cuantos caracteres quiere que sea su password?", bah, nah, el password lo podría asignar la misma oficina, simplemente cambia el orden del proceso:
- Vas a la oficina, pides hacer el envío, te dan un password.
- Se lo dices a quien quieres que reciba el paquete.
- Va, dice el password y lo recibe.

¿Qué más?