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
}

Bueno pero ojo que la ventaja principal de DoH no es saltarse bloqueos, para eso se podía simplemente usar cualquier DNS público (si el bloqueo es por DNS), lo prinicipal es su uso en privacidad. Como ya lo han mencionado, con eso se evita que el ISP y cualquier oyente no deseado sepa siquiera qué peticiones DNS estamos haciendo y por lo tanto no saber a qué sitios estamos tratando de acceder. Tampoco es necesario andar metiendo mano al registro de Windows si es una opción que ya se puede cambiar dentro de la configuración de los navegadores y del mismo Windows 11.

En Android también es posible hacerlo. Al menos en mi Xiaomi se puede en Configuración - Más opciones de conectividad - DNS privado

Tambien mencionar que por un tiempo yo estuve usando Zero Trust de Cloudflare One donde puedes crear DNS locations con endpoints DoT y DoH que puedes usar con listas personalizadas de bloqueo. Con el free tier es más que suficiente para uso diario y con las listas puedes bloquear publicidad y cualquier otra cosa no deseada, me resultó bastante práctico.

Actualmente no lo uso porque me armé un pi-hole como servidor dns, que no me da tanta privacidad como DoH pero sí más control.

Parece que Waydroid te está creando una red separada (normalmente mediante waydroid0, contenedores LXC y reglas propias de iptables/nftables), por lo que aunque tu sistema anfitrión use un proxy, Tor o una VPN gestionada por NetworkManager, el tráfico de Android puede estar saliendo por otra ruta.

Algunas cosas que conviene comprobar:

Ver qué interfaz usa Waydroid

ip addr
ip route

Busca interfaces como waydroid0, veth* o similares.

Entrar en el entorno Android

sudo waydroid shell

Y dentro:

ip addr
ip route
getprop | grep proxy

Así verás si Android tiene configurado algún proxy propio.

Comprobar las reglas NAT
En el host:

sudo iptables -t nat -L -n -v

o si usas nftables:

sudo nft list ruleset

Waydroid suele crear reglas de masquerading que pueden saltarse parte de tu configuración.

VPN
Si la VPN está funcionando a nivel de sistema (creando tun0, wg0, etc.), normalmente todo el tráfico enrutado por el host debería pasar por ella. Si Waydroid sale por fuera, revisa:

ip rule
ip route show table all

Puede haber tablas de routing separadas.

Tor
Si intentas forzar Waydroid a pasar por Tor mediante TransPort, normalmente tendrás que redirigir explícitamente el tráfico procedente de la subred de Waydroid hacia Tor con reglas iptables/nftables. No suele bastar con tener Tor ejecutándose en el host.
Prueba sencilla
Dentro de Waydroid abre un navegador y visita una página que muestre tu IP. Después activa la VPN en el host y vuelve a comprobar. Si la IP no cambia, entonces Waydroid está escapando de la ruta de la VPN y habrá que revisar el routing concreto.

Para poder ayudarte mejor, indica:

Distribución Linux.
Método de VPN (OpenVPN, WireGuard, ProtonVPN, Mullvad, etc.).

Salida de:

ip addr
ip route
sudo waydroid status
Si usas iptables o nftables.

Con esos datos se puede ver exactamente por dónde está saliendo el tráfico de Waydroid.

Hola, podes desinstalar tranquilamente ese controlador y para estar seguro y tranquilo, haz lo que te comentó el compañero Songoku, copia los datos exactos de ese controlador y si necesitas o deseas volver a instalarlo, simplemente descargas el mismo, lo instalas y listo.

Lo que decidí es no desconectar el cable, cuando quiera salir con auriculares usaré otro...

Prefiero no desinstalar el controlador, por miedo a no poder reinstalarlo, no es como un programa cualquiera, aunque puede que para muchos sí.

No se sabe por qué se rompió, probablemente al actualizarse algo, ya que aparentemente se reactivó una opción que el mismo solucionador de problemas me había recomendado quitar cuando empecé a usar esta PC y el sonido no funcionaba. Algo de efectos especiales, no me acuerdo.
No es normal que se rompa, otras cosas difícil que se rompan.

Tampoco estoy seguro de que sea un problema de Windows.

El concepto de DoT y DNSSEC no los conocía, la verdad. Y el DoH lo descubrí a principios de este año. En temas de redes estoy más verde de lo que pensaba. También es que hablamos de infraestructuras en constante evolución e introduciendo nuevos mecanismos cada X tiempo, y si uno no se mantiene con conocimientos actualizado pues...

Según la IA, el origen de DoH existe desde el 2018, DoT desde 2016 y DNSSEC desde el 2005 (como prototipo desde el año 1997).

Muchas gracias a ti y a el-brujo por ampliarnos conocimientos (venga, va, y a la IA también xD).