https://youtu.be/TmACx8Du3as

Cuando el meteoro se está acercando a la nave de abajo, si presiono A o S aparece una mira, que se va moviendo a la izquierda si apreté A y a la derecha si apreté S.
Cuando el meteoro toque la nave de abajo, debe ir hacia donde haya quedado la mira.

Pueden ver que a veces funciona, y a veces no, no sé por qué...

La pantalla es de 800 pixeles de ancho y 600 de largo. Las coordenadas avanzan a la derecha y abajo, así que arriba a la izquierda es 0, 0
y abajo a la derecha es 800, 600
El 1er número corresponde a X, el 2ndo a Y.

La mira es algo provisorio para mostrar la falla, no habrá mira en el juego.

Creo que el error está acá:

	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;

Código completo:

// Algo como esto if (MeteorYSpeed>0) { se está haciendo 2 veces,
// pero evitarlo implicaría unir cosas del jugador y la IA?
//
fscommand ("fullscreen", "true");
// Varía según diferencia de puntajes:
Dificultad = 0;
// Player:
attachMovie("sShip", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
PlayerSpeed = 3;
PlayerScore = 0;
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
// Se define acá para que luego el programa considere que...
// hubo contacto entre la nave del jugador y el meteoro:
MeteorYSpeed = 1;
// Para que la curvatura dependa de MeteorYSpeed
// (1 es hacia arriba, -1 hacia abajo):
MeteorYDirection = -1;
// Valores del color más brillante del meteoro (F0D9C8):
MaxRojo = 255;
MaxVerde = 217;
MaxAzul = 200;
// /////////////////////////////////////////////
// /////////////////// Ship ////////////////////
// /////////////////////////////////////////////
function ControlShip () {
	if (Key.isDown(39)) {
		// Derecha.
		// Para evitar que se vaya demasiado al extremo derecho:
		if (Player._x<722) {
			Player._x = Player._x+PlayerSpeed;
		} else {
			Player._x = 725;
		}
	} else if (Key.isDown(37)) {
		// Izquierda.
		// Para evitar que se vaya demasiado al extremo izquierdo:
		if (Player._x>78) {
			Player._x = Player._x-PlayerSpeed;
		} else {
			Player._x = 75;
		}
	}
	// Si el meteoro va hacia abajo:
	if (MeteorYSpeed>0) {
		// Si aún no se eligió hacia dónde rebotarlo:
		if (Apuntando == 0) {
			if (Key.isDown(65)) {
				Apuntando = -1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 399);
				setProperty ("Mira", _y, 20.5);
			} else if (Key.isDown(83)) {
				Apuntando = 1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 401);
				setProperty ("Mira", _y, 20.5);
			}
		} else if (Apuntando < 0) {
			Apuntando = Apuntando-3;
			if (Apuntando < -400) {
				Apuntando = -400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		} else {
			Apuntando = Apuntando+3;
			if (Apuntando > 400) {
				Apuntando = 400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	// Si el meteoro va hacia arriba:
	if (MeteorYSpeed<0) {
		// La IA se moverá hacia él:
		Distancia = IA._x-Meteor._x;
	} else {
		// La IA irá hacia el centro:
		Distancia = IA._x-400;
	}
	if (Distancia < 0) {
		IA._x = IA._x+IASpeed;
		// Para evitar que se vaya demasiado a la derecha:
		if (IA._x > 725) {
			IA._x = 725;
		}
	} else if (Distancia > 0) {
		IA._x = IA._x-IASpeed;
		// Para evitar que se vaya demasiado a la izquierda:
		if (IA._x < 75) {
			IA._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// /////////////////  Meteor  //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
	Diametro = 44;
	Radio = Diametro/2;
	// Insertarle imágenes:
	Imagen = 0;
	do {
		Imagen++;
		Name = "Imagen"+Imagen;
		Meteor.attachMovie("sCirculo", Name, Imagen);
		Name = "Meteor."+Name;
		// Para los tamaños y rotación:
		setProperty (Name, _xscale, 400*Math.random());
		setProperty (Name, _yscale, 400*Math.random());
		setProperty (Name, _rotation, 360*Math.random());
		// Para las posiciones:
		X = Math.random()*Diametro - Radio;
		setProperty (Name, _x, X);
		MaxY = Math.sqrt(Radio*Radio - X*X);
		Y = Math.random() * (MaxY*2) - MaxY;
		setProperty (Name, _y, Y);
		// Para los colores:
		ColorDeName = new Color(Name);
		Brillo = 0.2 + 0.8 * Math.random();
		Rojo = Math.round(MaxRojo * Brillo);
		Verde = Math.round(MaxVerde * Brillo);
		Azul = Math.round(MaxAzul * Brillo);
		ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
		ColorDeName.setRGB(ColorElegido);
	} while (Imagen < 1000);
}
VariarMeteoro ();
function MeteorMoves () {
	MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
	MeteorRotation = MeteorRotation/1.01;
	Meteor._x = Meteor._x+MeteorXSpeed;
	Meteor._y = Meteor._y+MeteorYSpeed;
	Meteor._rotation = Meteor._rotation+MeteorRotation;
	// Choque con nave derecha:
	if (Meteor._x > 752.5) {
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	} else if (Meteor._x < 47.5) {
		// Choque con nave izquierda:
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	}
	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		if (Apuntando < -400) {
			Apuntando = -400;
		} else if (Apuntando > 400) {
			Apuntando = 400;
		}
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;
		MeteorRotation = 0;
		// MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = 1;
		trace("MeteorYSpeed: "+MeteorYSpeed);
		trace("Apuntando: "+Apuntando);
		trace("DistanciaY: "+DistanciaY);
		trace("TardanzaY: "+TardanzaY);
		trace("DistanciaX: "+DistanciaX);
		trace("MeteorXSpeed: "+MeteorXSpeed);
		removeMovieclip("Mira");
	} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
		MeteorYSpeed = Math.random()*(2+Dificultad)+1;
		MeteorXSpeed = Math.random()*(3+Dificultad)*(2*random(2)-1);
		MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = -1;
		Apuntando = 0;
	} else if (Meteor._y<0) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 55.5);
		PlayerScore++;
		Dificultad++;
		PlayerSpeed = PlayerSpeed+0.1;
		IASpeed = IASpeed+0.11;
		ShowScore();
	} else if (Meteor._y>600) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 544.5);
		IAScore++;
		Dificultad--;
		PlayerSpeed = PlayerSpeed-0.1;
		IASpeed = IASpeed-0.11;
		ShowScore();
	}
}
// 
function ShowScore () {
	attachMovie("sPuntaje", "Mensaje", 4);
	setProperty ("Mensaje", _x, 400);
	setProperty ("Mensaje", _y, 300);
	setProperty ("Player", _x, 400);
	setProperty ("IA", _x, 400);
	gotoAndStop (3);
}
// stop ();

La mira es a donde tiene que ir el meteoro cuando toque la nave de abajo. Cuando queda en una punta es como si estuvieses jugando al tenis y apuntando a la punta, es normal.

No importa aquí qué lugar de la nave de abajo toque el meteoro. Mover la nave no cambia la posición de la mira, es como un "charging", apretás A o S y en vez de que el tiro sea más fuerte debe ir más a la punta.

Tengo pensado hacer eso pero no veo que sea la solución al problema... Eso va a ser una 2nda etapa del charging, que vaya justo al centro y rebote, ya que es efectivo contra la IA. Así como está el juego es muy difícil hacerle un punto.

Creo que hay confusión, la trayectoria del tiro debe decidirse cuando toca la nave de abajo y por ahora no debe tocar las paredes. Hago un dibujo...

Cuando el meteoro toque la nave de abajo, debe rebotar siguiendo la línea verde, hacia la mira, sin tocar las paredes.
Si va a tardar 100 frames en recorrer la distanciaY, debe tardar 100 frames en recorrer la distanciaX. Ese es el razonamiento que hago y el cálculo que intento hacer, pero no sé qué pasa.


En tu ejemplo a veces choca en la pared, esa no es la idea, lo demás está bien, no sé cómo hiciste el cálculo...

Ignora la pared por ahora, se va a usar más adelante. Supón que es un juego de golf de cuando usas el palo que la pelota no sube, o sea, todo 2d, visto de arriba, y la mira el hoyo, y se quiere que la pelota vaya ahí.
Se determina una velocidad Y al azar:
MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
¿y luego? Capaz que me falla el cálculo porque esa velocidad es negativa, luego veo.