Logré algo que me parece aceptable a pesar de todo.

Básicamente puse que al momento de empujar se considere el ancho máximo del personaje.

Y tenía un error en que el ancho del barril es 24, o sea que el número en el cálculo era 12, no 14. Cuando tenía los números 14 y 12 en el cálculo y sustituí uno porque se considere el ancho variable del personaje, sustituí el incorrecto. Igual no sé si era el problema.

https://youtu.be/QltICF6s-Gw

Lo que sucede al final es que el personaje empezó a caminar cuando un barril lo estaba tocando, eso es otro tema.

// 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";
LV = 1;
Recorrido = 0;
BarrilesToAdd = 0;
// Aunque hay 0 barriles se pone 10 porque también es...
// el valor que determina qué tan adelante se ponen,
// y el valor 1 es del personaje,
// entonces realmente los barriles es esto-10:
Barriles = 10;
// La mínima distancia a la que Medaman y un barril se tocan...
// depende de qué dibujo tenga Medaman, ya que al caminar,
// uno es más ancho. Pero para simplificar,
// se considerará el más ancho: 32. El ancho del barril es 24.
// Además se agrega 0.2 porque es lo que Medaman...
// se podría mover, y 0.05 para evitar fallas por...
// inexactitudes al operar decimales.
MinDistanciaSinChoque = 16+12+0.25;
// /////////////////////////////////////////////
// /////////////////  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";
	// Se comienza desde 10 por lo ya explicado
	// (tal vez convenga chequear desde el último):
	BarrilesChequeados = 10;
	trace("Checking empuje");
	do {
		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);
			if (DistanciaPlayerBarril < MinDistanciaSinChoque) {
				trace ("Empuja");
				I.Player.Empujar = "Sí";
				break;
			}
		}
	} while (BarrilesChequeados<Barriles);
	if (I.Player.Empujar == "No") {
		// El personaje avanza lo normal:
		I.Player.X = I.Player.X+0.2;
		AumentarRecorrido();
	} else {
		// Avanza menos:
		I.Player.X = I.Player.X+0.1;
		// Ojo que fue hecho para que avance 0.2, puede que lo empuje desde muy lejos.
		// 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, 0.15);
	}
	I.Player._X = I.Player.X;
}
function Quiet () {
	I.Player.Action = "Quiet";
	I.Player.gotoAndStop(1);
}
// Whens:
function RightWhenQuiet () {
	// Ver si toca algún barril:
	BarrilesChequeados = 10;
	do {
		BarrilesChequeados++;
		if (I.Player.hitTest(eval("I.Barril"+BarrilesChequeados)) == true) {
			trace("Apareció en barril");
			// Game over:
			Game = "Over";
			I.Player.gotoAndStop(2);
			break;
		}
	} while (BarrilesChequeados<Barriles);
	if (Game == "Ok") {
		Walk();
	} else {
		// Esto probablemente esté bien antes del break:
		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 AddBarriles () {
	BarrilesToAdd = BarrilesToAdd+random(LV)/1000;
	while (BarrilesToAdd>=1) {
		BarrilesToAdd--;
		Barriles++;
		// Probablemente innecesario, y causante de bugs si no se parchea:
		if (Barriles>1010) {
			Barriles = 11;
		}
		BarrilAgreado = "Barril"+Barriles;
		I.attachMovie("sBarril", BarrilAgreado, Barriles);
		BarrilAgreado = "I."+BarrilAgreado;
		set(BarrilAgreado+".X", 0);
		setProperty (BarrilAgreado, _x, 0);
		setProperty (BarrilAgreado, _y, 584);
		set (BarrilAgreado+".Speed", random(LV)/10);
		set (BarrilAgreado+".Spin", 0.1+random(LV)/10);
	}
}
function MoveBarriles () {
	Moved = 10;
	// trace("Checking golpe");
	do {
		Moved++;
		BarrilaMover = "I.Barril"+Moved;
		BarrilSpeed = BarrilaMover+".Speed";
		EvaluedBarrilSpeed = eval(BarrilSpeed);
		// Aplicar rozamiento:
		if (EvaluedBarrilSpeed > 0) {
			EvaluedBarrilSpeed = EvaluedBarrilSpeed/1.0025;
			// Si la velocidad queda muy baja:
			if (EvaluedBarrilSpeed < 0.05) {
				// Frena completamente:
				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:
			set(BarrilaMover+".X", BarrilX);
			setProperty (BarrilaMover, _x, BarrilX);
			ParteaRotar = BarrilaMover+".Part";
			setProperty (ParteaRotar, _rotation, getProperty(ParteaRotar, _rotation)+EvaluedBarrilSpeed*2);
			// Si tocan al personaje y él se está moviendo:
			if (I.Player.hitTest(eval(BarrilaMover)) == true && I.Player.Action == "Walking") {
				trace("Golpeado");
				// Game over:
				gotoAndStop (3);
				break;
			} 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);
				}
			}
		}
	} while (Moved<Barriles);
}

No sé cómo funciona eso, pero podrías pedir a conocidos tuyos que confirmen que esa cuenta es tuya, que publiquen algo diciéndolo. Junta los links a esas publicaciones y envíalos a los admins.

Mr.Byte no dices cual era la falla...

¿el while mal escrito? ¿falta de espacios?

Revisado.

Dice que ocupa casi 3GB... espacio tengo, pero ¿todo eso para escribir y que corrija lo que escribo?

Por ahora haré eso.

Me sirvió lo de la consola también, si habré abierto archivos que se cerraban y no veía qué hacían...

A la izquierda tiene la mayoría de posibles comandos. Tiene modo normal y experto. El normal cuando hay un error te lo marca con rojo, además al cliquear la línea, abajo te muestra qué se debe poner. Yo uso el modo experto que es más rápido y libre de editar, pruebo el programa y los errores de sintaxis si hay los dice en la salida.
Lo que me hace falta es que las letras se vean más grandes, pero para eso está el bloc de notas xD

Funcionó.

Me sirvió esto:

En cuanto a esto:
Me parece que la lupa de Windows termina siendo más cómoda, porque si agrandas la imagen y lo que quieres ver cambia donde está, es un lío buscarlo moviendo la pantalla.

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.