cuando le pongo ñ a charset no funciona:

charset = "abcdefghijklmnñopqrstuvwxyz"
with open("passwords.txt", "w", encoding="utf-8") as txt :
  for a in charset :
    for b in charset :
      for c in charset :
        for d in charset :
          txt.write(a + b + c + d + "\n")

¿qué hago para que funcione con ñ?

¿Se supone que en eso está la solución?

Lo que me sucede es que el archivo py se cierra enseguida y no se genera el archivo que quiero.

No es un low level run xD

Sobre el juego de la niña, vi una teoría de que fue violada y está, en cierto modo, recordabndo su triste pasado. Pensé que era cierta, ahora al leer Wikipedia no sé, no tiene historia dice.

En el siguiente video hay 2 pruebas.

En la 1era, cuando el personaje camina tiene 2 estados, y en uno es más ancho que en el otro, estira los pies hacia adelante. Eso hace que el barril sea empujado muchas veces en un mismo contacto, lo cual le da demasiada velocidad, está mal. El error ocurre porque en este caso el contacto se produjo cuando el personaje era menos ancho, luego se ensancha y entonces el programa sigue detectando que está tocando el barril, hasta que por fin se aleja suficiente.

En la 2nda prueba, el personaje no cambia al caminar, siempre tiene el mismo ancho, el movimiento del barril está bien, pero el personaje debería cambiar al caminar.

https://youtu.be/eWPQZnodI1U

¿Cómo logro que quede bien?

Puedo poner un ancho único. Que, sin importar el ancho del personaje, el contacto se produzca siempre a la misma distancia. Pero no me gusta eso.

Puedo poner que al ocurrir el hecho una variable cambie durante un tiempo, en el cual el barril no podrá ser empujado de nuevo. Tampoco me parece buena idea.

Busco una solución digamos lógica o realista. Si alguien va caminando, cuando adelanta la pierna tiene más ancho, entonces empuja algo que está más lejos. Si justo lo empuja cuando tiene las 2 piernas juntas, es como si lo empujara varias veces, pero ¿con menos fuerza? No sé, e intentando encontrar fallas cambié varias cosas así que algunas puede que hayan quedado mal.

El código en resumen es:
1- Cuando el personaje camina, se calcula su distancia con respecto al barril:
DistanciaPlayerBarril = ValorAbsoluto(PlayerX-BarrilX);
Las coordenadas que se consideran son los centros de los objetos, o sea, distancia entre el centro del personaje y el centro del barril.

2- Se calcula esto:
MinDistanciaSinChoque = PlayerAncho/2+14+0.2;
O sea, el ancho del personaje/2 + el ancho del barril/2 (da 14) y 0.2 que es lo que el personaje se moverá.
Es la mínima distancia a la que están sin chocar. Como el personaje se moverá 0.2, se agrega eso.

3- Se compara la distancia con eso, para detectar si el personaje tocará el barril o no:
if (DistanciaPlayerBarril<MinDistanciaSinChoque) {

4- Supongamos que habrá contacto, ya que es lo relevante aquí. En tal caso tengo esto:
// Determinar movimientos:
// MinDistanciaSinChoque -> mov 0.2, empuje 0.
// 0 -> mov 0, empuje 0.2.
MovimientoDelPers = DistanciaPlayerBarril*0.2/MinDistanciaSinChoque;
...la idea es que normalmente el personaje se mueva 0.2, pero si va a tocar el barril se mueva menos, y lo que reste se aplique a la velocidad del barril, en el siguiente paso del programa.
Entre más cerca estén, menos se moverá el personaje.

5- Aquí puse que el barril aumente siempre la misma velocidad independientemente de cuánto sea MovimientoDelPers, porque eso me daba problemas. Deberá mejorarse:
BarrilSpeed = BarrilSpeed+0.3;
...antes creo que tenía esto:
BarrilSpeed = BarrilSpeed+0.2-MovimientoDelPers;
Como el barril se detiene si su velocidad es muy poca, eso me daba problemas, creo que era así.

Creo que eso es todo. Luego se reduce la velocidad del barril debido a rozamiento, pero eso creo que ya está bien, ya pregunté aquí.


En Mario Bros, cuando Mario toca un caparazón de tortuga o similar, ésta adquiere más velocidad que la que él puede tener y además no tiene rozamiento, por eso en ese juego no ocurren estos problemas xP

Me lo dieron pero nunca lo probé, nunca tuve una idea pulida que quisiera probar ahí. Pero más o menos entendí la idea.

Creo que vi un gameplay, pero no le vi mucho sentido, no sé la historia, igual no me llamó tanto la atención. Lo acabo de ver, sí, es que hay otros parecidos, como este:
https://www.youtube.com/watch?v=2QAjIJeccbw
La historia del que dices es que quiere matar al padre o algo así, Wikipedia no dice mucho.

Pero lo mío son juegos de consola antiguos y más normales. Ese, si es del que leí hace tiempo, tiene historia interesante pero el juego en sí parece desagradable de jugar, como si fuera una tortura, y tampoco parece tener mucho sentido.

Bueno, yo ni lo conocía, y si me dices que cobran entonces menos me atrae.

Un dato cierto. En mi caso es que, me gusta más así, además si no entiendo algo puedo preguntar.

En varios casos.

Investigaré, aunque a estas alturas ya no soy un gamer, estoy a otro nivel xP Siento que debo terminar de pensar por mi cuenta.
Un low level run es pasar el juego de modo que en ningún momento se haya tenido un alto LV, es como la fila 1 y columna 3 de aquí:

Hay muchos más runs posibles, estoy pensando cuales...

Aquí un ejemplo más concreto:

Uso el Windows Media Classic y si bien tiene esa función, no funciona en los videos que lo preciso, quizá debido al formato (asf, y cambiarle la extensión manualmente no lo soluciona).

Lo puedo subir a YT y tal vez ahí podría verlo lento, pero debe haber algo mejor.

Para Windows 7, ligero, y gratis.

No particularmente, pero por no haber visto muchas creo que las prefiero comparado con cosas que las vi variadas muchas veces, aunque al final supongo que depende de cómo estén hechas.

Stein;Gate tiene un poco de hackeos.

Ghost in the Shell también pero es más bien como paralizar robots y esas cosas, o alterar cerebros mecánicos de humanos, es medio incomprensible.

En Cowboy Bebop hay un/a niñ@ hacker, y hay una historia de un ajedrecista que se venga de una empresa hackeándola, o algo así.

Matrix creo que tiene pero más bien parece magia, hackea la realidad virtual simplemente con desearlo.

En Ralph el demoledor se podría decir que alguien hackeó un juego, pero fue más bien que se coló en él, como si fuera magia o cosa de fuerza física.

https://foro.elhacker.net/juegos_y_consolas/sugerencias_para_historia_de_hackers-t522688.0.html

Ya lo entiendo más...

Lo había visto pero en el resultado me pareció que faltaban casos, ahora lo probé de nuevo y no, no sé qué pasó.


Lo que tenía en AS por ahora es:

Mayu = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
Minu = "abcdefghijklmnñopqrstuvwxyz ";
// Para determinar qué tan lejos puede llegar,
// ya que si va a modificar el 1er caracter...
// o el último, no debe ser espacio:
MaximoChar = 26;
Chars = 4;
Char1 = 0;
Char2 = 0;
Char3 = 0;
Char4 = -1;
PunteroDeChars = 4;
function MakePassword () {
	CharaModificar = "Char"+PunteroDeChars;
	EvaluedCharaModificar = eval(CharaModificar);
	// Si el caracter señalado puede cambiar:
	if (EvaluedCharaModificar < MaximoChar) {
		// Cambiarlo:
		// EvaluedCharaModificar++;
		set (CharaModificar, EvaluedCharaModificar+1);
		// Formar el password desde el caracter 2:
		Password = Minu.charat(Char2);
		PunteroDeChars2 = 2;
		do {
			PunteroDeChars2++;
			Password = Password+Minu.charat(eval("Char"+PunteroDeChars2));
		} while (PunteroDeChars2<Chars);
		// Formar el password que inicia con minúscula:
		MinuPassword = Minu.charat(Char1)+Password;
		trace (MinuPassword);
		// Agregarle número:
		trace (MinuPassword+"6");
		// Formar el password que inicia con mayúscula:
		Password = Mayu.charat(Char1)+Password;
		trace (Password);
		// Agregarle número:
		trace (Password+"6");
		// Resetear puntero y el máximo valor del char:
		PunteroDeChars = Chars;
		MaximoChar = 26;
	} else {
		// Resetearlo:
		set (CharaModificar, 0);
		// Si el puntero puede bajar:
		if (PunteroDeChars>1) {
			// Bajarlo:
			PunteroDeChars--;
			if (PunteroDeChars>1) {
				MaximoChar = 27;
			} else {
				MaximoChar = 26;
			}
		} else {
			// El largo del password llegó a lo especificado, fin:
			gotoAndStop(2);
		}
	}
}
stop();

La finalización no sé si está bien. La idea era correr ese programa cambiando el bnúmero cada vez, pero como sea es muy lento. Seguiré intentando aprender Python para poder hacer algo medio así, con casos especiales.

Acabo de ver que for puede significar otras cosas además de para o por:
Pero en algunos casos también puede indicar dirección (hacia, con destino a) y tiempo (durante).
Intento lo de la mente flexible pero si lo que leo no parece tener una traducción digamos lógica, no me gusta xD
¿Cómo se traduciría más o menos literalmente al español, esa línea de código?
"Juntar en combinacion, lo que está en combinaciones", podría ser, pero ¿por qué dice combinacion 2 veces?
¿Y los corchetes, las comillas y el punto, para qué?
Pregunto por si tiene algún motivo importante digamos, si es como una configuración, sino bueno, es así y ya xD

Entonces ¿no hay algo más eficiente que itertools? Algo que cree un array de strings, por ejemplo.

Yo las combinaciones las suelo generar con variables, whiles e ifs. Eso que me dijo GPT es mucho más simple, claro, a 1era vista, porque si por ejemplo se quiere que la 1era letra sea mayúscula... o que pueda haber espacio pero no al principio ni al final... En fin, por ahora me limité a intentar entender lo que me dijeran.

Esto no lo entendí mucho. Entiendo lo que hace el código, pero no cómo se relaciona con el resultado, es como si me dijeran que escribir "guitar" convierte números en strings.
Supongamos que las combinaciones fuesen 4: [['a','a'], ['a','b'], ['b','a'], ['b','b']]
Entonces, la traducción del código podría ser: Poner en resultado cada output (llamado combinacion), de: De combinaciones, ir tomando cada lista, convertirla en string, y formar una nueva lista.
Supongo que es más simple, pero no imagino cómo, porque están usando una variable combinacion que parece servir de puente, cuando podría ser un proceso más directo, algo como:
resultado = join(each list in combinaciones)
o
combinaciones = join(each list in combinaciones)
¿no?

...

"for combinacion in resultado:"
A ver, sería como "A cada elemento en resultado, tomarlo de a uno y ponerlo en combinacion"
Creo que así me queda mucho más claro, o puesto en el mismo orden original sería:
"En combinacion, ir guardando uno a la vez los elementos de resultado"
Luego combinacion puede ser usado para algo...


Entendí que with cierra el archivo pero no qué tiene que ver la palabra esa con cerrar un archivo. El método manual que pusiste es mucho más claro.

Mi pregunta fue si tu foro, que quieres hacer, tienes pensado que sea sobre videojuegos, o al menos que sea bastante enfocado en eso.

¿Qué has programado ahí? ¿me puedes decir qué diferencias tiene ese software con Flash?

No quiero desanimarte pero veo muy difícil que mucha gente se registre en un foro de ese software (tú mismo lo dices) o en uno general (esto por lo que ambos comentamos), o lo veo un poco contradictorio, que es para el software pero pocos irían, pero a uno general lo dudo también... Te recomendaría que fuese sobre programación, especialmente de videojuegos, especialmente de ese programa que dices. Puedes ponerlo en orden inverso:
Foro de Clickteam, programación de videojuegos, programación en general, y temas generales.

Los quiero en español. Usaba Meristation hace años, hasta que lo adquirió una revista o no sé qué y quitaron el foro. O porque cambiaron de dueños, y originalmente era una revista, no sé. Hubo una mudanza de usuarios pero no le presté atención porque pensé que sería fácil hallar otro foro de videojuegos por ahí, además en aquella época no tenía tanto interés.

De programación de videojuegos estuve en 2, mucho antes de Meri. Uno empezó a funcionar mal, no lo arreglaban y dejé de ir, y el otro no me acuerdo bien, creo que anunciaron que cerraría.

Los que tienen problemas para hacer juegos ¿dónde lo hablan? ¿por Facebook?

Lo que pasa es que el personaje cuando camina tiene 2 posibles imágenes y una es más ancha >___<

Visto eso y con una recomendación de GPT solucioné ese problema, además corregí un poco el código:

// Indica si el juego continúa o no:
Game = "Ok";
// Por motivos que no recuerdo, las imágenes se ponen...
// en un objeto I.
// Agregar personaje:
I.attachMovie("sMedaMan", "Player", 1);
// X es porque la posición real del personaje no admite...
// tantos valores, los simplifica, se pierde parte;
// de este modo no:
I.Player.X = 0;
I.Player._X = I.Player.X;
I.Player._Y = 584;
I.Player.Action = "Quiet";
I.attachMovie("sBarril", "Barril2", 2);
I.Barril2.X = 80;
I.Barril2._X = I.Barril2.X;
I.Barril2._Y = 584;
LV = 1;
Recorrido = 0;
// /////////////////////////////////////////////
// /////////////////  MedaMan  /////////////////
// /////////////////////////////////////////////
function AumentarRecorrido () {
	Recorrido++;
	if (Recorrido == 50) {
		Recorrido = 0;
		LV++;
	}
}
function Walk () {
	I.Player.Action = "Walking";
	I.Player.gotoAndStop(2);
	// Ver si empuja algún barril:
	I.Player.Empujar = "No";
	// (tal vez convenga chequear desde el último)
	BarrilesChequeados = 1;
	BarrilesChequeados++;
	BarrilaChequear = "I.Barril"+BarrilesChequeados;
	BarrilX = eval("I.Barril"+BarrilesChequeados+".X");
	// Si el barril existe:
	if (BarrilX != undefined) {
		DistanciaPlayerBarril = Math.abs(I.Player.X-BarrilX);
		trace ("DistanciaPlayerBarril: "+DistanciaPlayerBarril);
		// La distancia a la que se tocan depende del...
		// dibujo de Medaman, ya que al caminar, uno...
		// es más ancho. Además se agregará 0.2 porque...
		// es lo que se podría llegar a mover:
		MinDistanciaSinChoque = I.Player._width/2+14+0.2;
		if (DistanciaPlayerBarril<MinDistanciaSinChoque) {
			trace ("Empuja");
			I.Player.Empujar = "Sí";
		}
	}
	if (I.Player.Empujar == "No") {
		// El personaje avanza:
		// Hay que ver si tocaría un barril, arreglarlo.
		I.Player.X = I.Player.X+0.2;
		I.Player._X = I.Player.X;
		AumentarRecorrido();
	} else {
		// Determinar movimientos:
		// MinDistanciaSinChoque -> mov 0.2, empuje 0.
		// 0 -> mov 0, empuje 0.2.
		MovimientoDelPers = DistanciaPlayerBarril*0.2/MinDistanciaSinChoque;
		I.Player.X = I.Player.X+MovimientoDelPers;
		I.Player._X = I.Player.X;
		// Recorrido debe aumentar acorde a eso, arreglarlo:
		AumentarRecorrido();
		// Empuja un barril:
		// Esto sólo aumenta la velocidad, ojo que si no se mueve puede que quede tocando al personaje:
		BarrilSpeed = BarrilaChequear+".Speed";
		set (BarrilSpeed, eval(BarrilSpeed)+0.2-MovimientoDelPers);
		trace ("BarrilSpeed: "+eval(BarrilSpeed));
		// BarrilSpeed = BarrilaMover+"Speed";
		// EvaluedBarrilSpeed = eval(BarrilSpeed);
	}
}
function Quiet () {
	I.Player.Action = "Quiet";
	I.Player.gotoAndStop(1);
}
// Whens:
function RightWhenQuiet () {
	// Ver si toca algún barril:
	BarrilesChequeados = 1;
	BarrilesChequeados++;
	if (I.Player.hitTest(eval("I.Barril"+BarrilesChequeados)) == true) {
		trace ("Apareció en barril");
		// Game over:
		Game = "Over";
		I.Player.gotoAndStop(2);
	}
	if (Game == "Ok") {
		Walk();
	} else {
		gotoAndStop (3);
	}
}
function RightWhenWalking () {
	// AumentarRecorrido();
	Walk();
}
function QuietWhenWalking () {
	Quiet();
}
// QuietWhenQuiet nada hace.
function ControlPlayer () {
	if (Key.isDown(39)) {
		// Si se presiona derecha:
		eval("RightWhen"+I.Player.Action)();
	} else {
		// Si nada se presiona:
		eval("QuietWhen"+I.Player.Action)();
	}
}
// /////////////////////////////////////////////
// ////////////////  Barriles  /////////////////
// /////////////////////////////////////////////
function MoveBarriles () {
	Moved = 1;
	Moved++;
	BarrilaMover = "I.Barril"+Moved;
	BarrilSpeed = BarrilaMover+".Speed";
	EvaluedBarrilSpeed = eval(BarrilSpeed);
	// Aplicar rozamiento:
	if (EvaluedBarrilSpeed>0) {
		EvaluedBarrilSpeed = EvaluedBarrilSpeed/1.0025;
		if (EvaluedBarrilSpeed<0.05) {
			EvaluedBarrilSpeed = 0;
		}
		set (BarrilSpeed, EvaluedBarrilSpeed);
	}
	BarrilX = eval(BarrilaMover+".X")+EvaluedBarrilSpeed;
	// Si ya no está en la pantalla:
	if (BarrilX>850) {
		// Quitarlo:
		removeMovieClip (BarrilaMover);
	} else {
		// Actualizar posición y girar su parte:
		setProperty (BarrilaMover, _x, BarrilX);
		// Res = BarrilaMover+".Part";
		// setProperty (Res, _rotation, getProperty(Res, _rotation)+EvaluedBarrilSpeed*2);
		// Si toca al personaje y él se está moviendo:
		if (I.Player.hitTest(eval(BarrilaMover)) == true && I.Player.Action == "Walking") {
			DistanciaPlayerBarril = Math.abs(I.Player.X-BarrilX);
			trace ("Golpeado");
			trace ("DistanciaPlayerBarril: "+DistanciaPlayerBarril);
			// Game over:
			gotoAndStop (3);
		} else {
			// Ver si tocó al barril anterior, que está delante:
			BarrilAnterior = "I.Barril"+(Moved-1);
			if (eval(BarrilaMover).hitTest(eval(BarrilAnterior)) == true) {
				// Pasarle la velocidad:
				set (BarrilAnterior+"Speed", eval(BarrilAnterior+".Speed")+EvaluedBarrilSpeed);
				// Quedar sin velocidad:
				set (BarrilSpeed, 0);
			}
		}
	}
}
 

Pero aviso que ese código no sirve mucho porque cuando el barril es empujado, puede que sea tan poco (o nada) que el personaje termine tocándolo. Voy a corregirlo, espero no necesitar ayuda >__<