Mi idea, que me está siendo imposible de aplicar o no es buena, incluye:

- Cuando la bola va hacia ti, puedes presionar Q, W, A o S. Q hace que la bola rebote (si te toca) hacia arriba-izquierda, W arriba-derecha, A izquierda y S derecha. O sea en vez de que la bola rebote según con qué parte la toques, rebota hacia donde indiques con teclas. Incluso si es mala idea, es una práctica para un posible videojuego de tenis más adelante.

Opinen de ese y los siguientes puntos. ¿No es bueno, por qué, qué sería mejor?

- Una vez que presionaste una de esas teclas y la soltaste, presionar Q o A hace que la bola tenga rotación hacia la izquierda y presionar W o S rotación a la derecha.
No es posible lanzar al centro y con rotación. Para lanzar al centro debes no tocar tecla, y la rotación sólo se puede asignar luego de haber tocado tecla, elegido dirección. Podría poner la opción con Z, pero tirar al centro no lo veo muy útil, incluso si tiene rotación.

- La rotación hace que la bola vaya aumentando su velocidad hacia el lado correspondiente. En la realidad puede que también disminuya la velocidad hacia adelante, pero ya me fue muy difícil conseguir las fórmulas matemáticas para todo lo anterior, por ahora no quiero cambiar esto.

- La rotación va disminuyendo a medida que pasa el tiempo. Creo que en la realidad es conforme a cuánto avanza la bola, pero mismo comentario.

- Cuando la bola toca una pared, la rotación influye en cómo rebota. Es como cuando toca el piso con efecto liftado o cortado, en este caso rebotará adquiriendo velocidad o perdiendo. Si pierde demasiado puede quedarse quieta o ir hacia atrás, esto puede ser la causa de un bug muy poco probable que aún no intenté corregir. También, la rotación se pierde luego de rebotar, pero adquiere otra un poco.

- El rival tiene una variable ReactionProgress que marca cuánto tarda en reaccionar a tus tiros.

- Cuando haces un punto, muchas cosas aumentan: La velocidad de las naves, la velocidad mínima y máxima de la bola, de la intensidad de la rotación... ReactionProgress también al resetearse es mayor, digamos, tardará menos en llegar a 100%.

- Las naves tienen una estadística puntería y maxPuntería, que empiezan muy bajas. De momento es coherente con lo dicho anteriormente. Quisiera que suban por experiencia (lo demás también), pero como algo está fallando, aún no lo intento.

- Cuando presionas una tecla para apuntar, tu puntería alcanzada comienza a aumentar sin llegar a superar tu MaxPuntería. Esto es una 3er variable, para entenderlo pueden pensar en la velocidad en juegos de coches: 1) Qué tan rápido aumenta tu velocidad actual, 2) cual es la máxima, 3) tu velocidad actual. Acá hay cuan rápido aumenta tu puntería cuando apuntas, cual es la máxima puntería que puedes alcanzar así, y cuánto alcanzaste de momento. Así que entre más antes presiones una tecla para apuntar, más probable es que tus tiros salgan bien.

- Cuando presionas de nuevo para rotar, tu puntería baja a 0 y empieza a aumentar/caer (según hacia dónde elijas rotar) la variable Rotando, funciona muy parecido a lo de puntería, y puntería sigue subiendo luego. En vez de que baje a 0 la voy a dividir entre 2, pero bueno, el fundamento de esto es que al causar rotación se pierde puntería, y no es que se tenga 0 si reaccionas suficientemente rápido.

- Cuando tu puntería no es 100 (tienes que hacer muchos puntos para que lo sea), tus tiros pueden ser menos veloces de lo normal, ir menos hacia un costado, o ir al opuesto, y tener menos rotación o la opuesta. Entre menos puntería hayas alcanzado, con más intensidad pueden ocurrir esas cosas.

Creo que eso es todo lo relevante. A mí me parece bonito pero en la práctica la bola tiene velocidades hacia el costado demasiado altas (teniendo en cuenta que es el inicio del juego y en comparación con las velocidades hacia adelante) y es muy difícil hacer puntos. Intenté arreglarlo y seguiré pero consulto porque ya medio como que no sé qué tengo que hacer.

El exe si quieren experimentarlo:
https://drive.google.com/file/d/1Pav6Swvi58bhHP2x5S8i2EchzHZKPRkC/view?usp=sharing

El siguiente video se ve como cortado porque fue a 60fps y el juego va a 120:
https://youtu.be/lmWi6YhDgVk

// 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);
// Velocidad conque se mueve:
PlayerSpeed = 3;
// Velocidad conque aumenta la puntería cuando...
// se prepara un rebote:
PlayerPunteria = 5;
// Siempre es PlayerPunteria^2:
PlayerMaxPunteria = 25;
PlayerScore = 0;
// Puntería alcanzada, en este momento el jugador saca...
// así que tiene la máxima. Entre más baja sea,
// peor puede que sea el rebote:
Punteria = PlayerMaxPunteria;
// ApuntandoX se define como si...
// el medio de la pantalla fuese 0:
ApuntandoX = 350*(2*random(2)-1);
ApuntandoY = 20.5+279.5*random(2);
// Hay una cantidad máxima que el meteoro puede rotar,
// hacia un lado u otro (valor negativo), depende de Dificultad.
// Rotando es un porcentaje, se rotará ese porcentaje del máximo:
Rotando = 100*(2*random(2)-1);
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAPunteria = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
MeteorX = 400;
MeteorY = 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;
// /////////////////////////////////////////////
// ////////////// Nave de Jugador //////////////
// /////////////////////////////////////////////
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 (ApuntandoX == 0) {
			if (Key.isDown(65)) {
				// Tecla A, a la izquierda:
				ApuntandoX = -350;
				ApuntandoY = 300;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 50);
				setProperty ("Mira", _y, 300);
				// Para luego saber que la tecla fue soltada:
				TeclaPresionada = "A";
				Punteria = 0;
				Rotando = 0;
			} else if (Key.isDown(83)) {
				// S, a la derecha:
				ApuntandoX = 350;
				ApuntandoY = 300;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 750);
				setProperty ("Mira", _y, 300);
				TeclaPresionada = "S";
				Punteria = 0;
				Rotando = 0;
			} else if (Key.isDown(81)) {
				// Q, a la izquierda arriba:
				ApuntandoX = -350;
				ApuntandoY = 20.5;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 50);
				setProperty ("Mira", _y, 20.5);
				TeclaPresionada = "Q";
				Punteria = 0;
				Rotando = 0;
			} else if (Key.isDown(87)) {
				// W, a la derecha arriba:
				ApuntandoX = 350;
				ApuntandoY = 20.5;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 750);
				setProperty ("Mira", _y, 20.5);
				TeclaPresionada = "W";
				Punteria = 0;
				Rotando = 0;
			}
			// Si ya se eligió a donde apuntar pero aún no se soltó la tecla:
		} else {
			Punteria = Math.min(Punteria+PlayerPunteria, PlayerMaxPunteria, 100);
			if (TeclaPresionada != "Ninguna") {
			if (TeclaPresionada == "A" && !Key.isDown(65)) {
				TeclaPresionada = "Ninguna";
			} else if (TeclaPresionada == "S" && !Key.isDown(83)) {
				TeclaPresionada = "Ninguna";
			} else if (TeclaPresionada == "Q" && !Key.isDown(81)) {
				TeclaPresionada = "Ninguna";
			} else if (TeclaPresionada == "W" && !Key.isDown(87)) {
				TeclaPresionada = "Ninguna";
			}
			// Si ya se eligió a dónde apuntar y se soltó la tecla pero no se eligió cómo rotarlo:
		} else if (Rotando == 0) {
			if (Key.isDown(65) or Key.isDown(81)) {
				// Rotar a la izquierda. Representa un porcentaje,
				// por ejemplo se aplicará el 1% de...
				// la rotación que se elija al azar*-1.
				Punteria = 0;
				Rotando = -PlayerSpeed;
			} else if (Key.isDown(83) or Key.isDown(87)) {
				Punteria = 0;
				Rotando = PlayerSpeed;
			}
		} else if (Rotando<0) {
			Rotando = Math.max(Rotando-PlayerSpeed, -100);
		} else if (Rotando>0) {
			Rotando = Math.min(Rotando+PlayerSpeed, 100);
		}
		// setProperty ("Mira", _xscale, 200-Punteria);
		// setProperty ("Mira", _yscale, 200-Punteria);
		// setProperty ("Mira", _alpha, 50+Punteria/2);
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	IAReactionProgress++;
	if (IAReactionProgress>500) {
		// 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;
			if (IA._x<75) {
				IA._x = 75;
			}
		}
	}
}
// /////////////////////////////////////////////
// /////////////////  Meteor  //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
// esto no viene al caso
}
VariarMeteoro();
function MeteorMoves () {
	MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
	MeteorRotation = MeteorRotation/1.01;
	MeteorX = MeteorX+MeteorXSpeed;
	Meteor._x = MeteorX;
	MeteorY = MeteorY+MeteorYSpeed;
	Meteor._y = MeteorY;
	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) {
		// Estas 2 serán modificadas por baja Punteria luego:
		MeteorYSpeed = Math.min(-Dificultad/10*Math.random()-1, -1);
		MeteorRotation = (90*Math.random()+Dificultad*2)*Rotando/100;
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = MeteorY-ApuntandoY;
		// 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 = ApuntandoX+400-MeteorX;
		// Determinar cuánto de moverá debido a la curva (falta considerar la reducción):
		MovimientoPorCurva = MeteorRotation/1000*(101*TardanzaY-10100+10100*Math.pow(1.01, -TardanzaY));
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado,
		// pero luego será modificada por baja Punteria:
		MeteorXSpeed = (DistanciaX-MovimientoPorCurva)/TardanzaY;
		// Modificaciones por baja Punteria:
		InfluenciaDeError = Math.random()*(100-Punteria)/10;
		MeteorYSpeed = Math.min(MeteorYSpeed+InfluenciaDeError, -1);
		InfluenciaDeError = Math.random()*(100-Punteria)/10;
		if (Rotando < 0) {
			MeteorRotation = MeteorRotation+InfluenciaDeError;
		} else if (Rotando > 0) {
			MeteorRotation = MeteorRotation-InfluenciaDeError;
		} else {
			MeteorRotation = MeteorRotation+InfluenciaDeError*(2*random(2)-1);
		}
		InfluenciaDeError = Math.random()*(100-Punteria)/10*(2*random(2)-1);
		MeteorXSpeed = MeteorXSpeed+InfluenciaDeError;
		MeteorYDirection = 1;
		// Probablemente innecesario:
		TeclaPresionada = "Ninguna";
		attachMovie("sMira", "Mira", 4);
		setProperty ("Mira", _x, 400+ApuntandoX);
		setProperty ("Mira", _y, ApuntandoY);
		// removeMovieClip ("Mira");
		IAReactionProgress = Dificultad/10;
		IAPunteria = PlayerMaxPunteria;
		IAApuntandoX = 350*(2*random(2)-1);
		IAApuntandoY = 579.5-279.5*random(2);
		IARotando = 100*(2*random(2)-1);
	} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
		MeteorYSpeed = Math.max(Dificultad/10*Math.random()+1, 1);
		MeteorRotation = (90*Math.random()+Dificultad*2)*IARotando/100;
		DistanciaY = IAApuntandoY-MeteorY;
		// 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 = IAApuntandoX+400-MeteorX;
		// Determinar cuánto de moverá debido a la curva (falta considerar la reducción):
		MovimientoPorCurva = -MeteorRotation/1000*(101*TardanzaY-10100+10100*Math.pow(1.01, -TardanzaY));
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = (DistanciaX-MovimientoPorCurva)/TardanzaY;
		InfluenciaDeError = Math.random()*(100-IAPunteria)/10;
		MeteorYSpeed = Math.max(MeteorYSpeed-InfluenciaDeError, 1);
		InfluenciaDeError = Math.random()*(100-IAPunteria)/10;
		if (Rotando < 0) {
			MeteorRotation = MeteorRotation+InfluenciaDeError;
		} else if (Rotando > 0) {
			MeteorRotation = MeteorRotation-InfluenciaDeError;
		} else {
			MeteorRotation = MeteorRotation+InfluenciaDeError*(2*random(2)-1);
		}
		InfluenciaDeError = Math.random()*(100-IAPunteria)/10*(2*random(2)-1);
		MeteorXSpeed = MeteorXSpeed+InfluenciaDeError;
		MeteorYDirection = -1;
		attachMovie("sMira", "Mira", 4);
		setProperty ("Mira", _x, 400+IAApuntandoX);
		setProperty ("Mira", _y, IAApuntandoY);
		Punteria = 0;
		ApuntandoX = 0;
		ApuntandoY = 20.5;
		Rotando = 0;
		// removeMovieClip ("Mira");
	} else if (Meteor._y<0) {
		// Punto de humano:
		PlayerScore++;
		Dificultad++;
		PlayerSpeed = PlayerSpeed+0.1;
		PlayerPunteria = PlayerPunteria+0.1;
		PlayerMaxPunteria = Math.min(PlayerPunteria*PlayerPunteria, 100);
		IASpeed = IASpeed+0.1;
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 55.5);
		MeteorX = 400;
		MeteorY = 55.5;
		// La IA va a sacar,
		// ergo obtiene su máxima puntería:
		IAPunteria = PlayerMaxPunteria;
		IAApuntandoX = 350*(2*random(2)-1);
		IAApuntandoY = 579.5-279.5*random(2);
		IARotando = 100*(2*random(2)-1);
		ShowScore();
	} else if (Meteor._y>600) {
		IAScore++;
		Dificultad--;
		PlayerSpeed = PlayerSpeed-0.1;
		PlayerPunteria = PlayerPunteria-0.1;
		PlayerMaxPunteria = Math.min(PlayerPunteria*PlayerPunteria, 100);
		IASpeed = IASpeed-0.1;
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 544.5);
		MeteorX = 400;
		MeteorY = 544.5;
		Punteria = PlayerMaxPunteria;
		ApuntandoX = 350*(2*random(2)-1);
		ApuntandoY = 20.5+279.5*random(2);
		Rotando = 100*(2*random(2)-1);
		ShowScore();
	}
}
// 
function ShowScore () {
// esto no viene al caso
}