Aquí vas a ver muchas cosas que parecen contrarias a la intuición, pero resultan claras una vez que se entiende bien el tema. Trataré de darte ejemplos breves para aclarar tus dudas, pero lo ideal es tener unas buenas bases de trigonometría y algo de física (mecánica, en concreto) para entenderlo al 100%.

Como recordatorio: el ángulo representa la distribución de velocidades. Como en tu programa se busca que la pelota avance (obviamente, no es aceptable tirar la pelota hacia atrás), mientras mayor sea el ángulo, habrá más velocidad hacia arriba y menos hacia adelante, o sea, la pelota se elevará más.

La principal confusión que veo que tienes es sobre la manera en que el ángulo influye en la distancia recorrida. No es válido decir que si le das más altura a la pelota, mayor será la distancia, ni tampoco lo opuesto. La realidad es que depende. Cuando el lanzamiento es muy bajo, hay mayor velocidad hacia adelante (horizontal), y se avanza más rápido, pero como la pelota está cerca del suelo, también cae rápido, así que no tiene tiempo de viajar mucho. Si el tiro es elevado, avanza hacia adelante más lentamente, pero tarda más en caer, lo que le da más tiempo para avanzar. Por lo tanto, si se quisiera que la pelota llegara lo más lejos posible, no debería ir ni muy elevada ni muy baja. Para cada tiro existe un ángulo que ofrece el mejor balance y da la mayor distancia posible con la fuerza disponible. Dicho de otra forma, si lo que se busca es recorrer una distancia específica, este es el ángulo que te permite lograrlo usando menos fuerza. No es tan simple decir cuál es este ángulo más eficiente, ya que depende de la altura y velocidad iniciales de la pelota, pero de cualquier forma no lo necesitas. Baste saber que ese ángulo existe, y que mientras más te alejes de él (ya sea hacia arriba o hacia abajo) menor será la eficiencia, y por lo tanto, mayor la cantidad de fuerza necesaria para recorrer una distancia d.


Eso podría ser correcto si sólo interesara elevar la pelota, sin importar donde caiga ni nada más, pero aquí de lo que se trata es de que llegue a un punto específico (y se eleve a cierta altura al pasar por la red), lo cual hace que no sea tan simple, como expliqué arriba. Si se diera el caso de que para llegar al punto deseado y alcanzar una altura de 18.6 m al pasar la red, requirieras más fuerza de la disponible, lo que habría que hacer es intentar acercarse al ángulo más eficiente: si el ángulo que se usó es mayor que el óptimo, hay que hacer tiros más bajos; si es menor, hay que hacer tiros más altos. En este último caso, para llegar al destino buscado, un tiro más elevado requeriría menos fuerza que uno más bajo. Obviamente, no necesitas estar probando ángulos, ya que el método del otro foro y el de aquí te calculan directamente el que debes usar, pero el ejemplo sirve para ilustrar el punto.


Sí, me había confundido porque acababa de ver el video que pusiste, y como no me quedaba muy claro que sucedía, pensé que te referías a otra cosa.


Creo que eso ya quedó aclarado con lo anterior: son suposiciones que, aunque puedan sonar lógicas, no son del todo correctas. En ciertos cases se cumplen y en otros ocurre lo contrario.


Pues creo que ya lo había explicado al inicio, aunque supongo que pudiera ser algo confuso porque está repartido en dos mensajes. Ahora no tengo tiempo, pero cuando pueda pongo los pasos en uno sólo.

Miro el foro todos los días o casi, no entiendo cómo no vi tu mensaje antes

Pienso lo mismo pero en mis ejemplos no parece ocurrir. ¿No?

Debes que imaginar que el jugador es perfecto en cuanto a inteligencia y puntería y quiere que la bola caiga en cierto punto, para lo cual usará toda la fuerza que pueda (según la que tenga, en ese sentido no es perfecto), no la mínima necesaria; no hará globitos si puede hacer que el tiro sea rápido y pase cerca de la red. No sé si has entendido eso. Si tiene la fuerza suficiente, el tiro debería pasar cerca de la red, sino sí haría un globito por lo que has explicado arriba, porque si golpea muy hacia abajo no llega. Mira el video
https://drive.google.com/file/d/1jyrIyycu_joxlfIblj5IDEwZ_Y3giSPR/view
Entre más fuerza tenga más bajo pasa la bola, excepto cuando ni siquiera tiene suficiente fuerza como para hacerla pasar. O piensa que, si hará un smash, apuntará a un punto usando toda la fuerza que pueda , no la mínima necesaria.
https://www.youtube.com/watch?v=BLaHot9vIKo
2:44, pudo haber golpeado más suave ¡pero no es la idea!

...

¡Vaya ecuaciones!

Me quedó así:

// Datos para determinar velocidades del tiro.
DistanciahastaDestinoX = BallX-280.1;
DistanciahastaDestinoY = BallY-180;
DistanciahastaDestinoXY = Math.sqrt(DistanciahastaDestinoX*DistanciahastaDestinoX+DistanciahastaDestinoY*DistanciahastaDestinoY);
// Se calcula el ángulo o ángulos.
Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));
// Si Disc < 0, no puedes hacer el tiro.
// Si Disc == 0, hay un solo angulo posible.
// Si Disc > 0, hay dos angulos.
theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
// Se calcula el tiempo que se tarda en llegar a la red.
DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallZ)/Math.abs(DistanciahastaDestinoY);
TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
if (Disc>0) {
    // Si hay dos ángulos, se calcula el 2ndo.
    TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
    // Se calcula la altura a la que pasa la bola al llegar a la red.
    AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;
    AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
    // Se elige el ángulo conque la bola pasa más bajo.
    if (AlturaEnRedTheta<AlturaEnRedPhi) {
        Angulo = AlturaEnRedTheta;
    } else {
        Angulo = AlturaEnRedPhi;
    }
} else {
    Angulo = AlturaEnRedTheta;
}
// Cálculo de las velocidades.
VelocidadAdelante = AlexFuerzadetiros*Math.cos(Angulo);
VelocidadArriba = AlexFuerzadetiros*Math.sin(Angulo);
// Esta variable es redundante, pero clarifica lo que se esta haciendo.
VelocidadZ = VelocidadArriba;
if (DistanciahastaDestinoX == 0) {
    BallXSpeed = 0;
    BallYSpeed = VelocidadAdelante*-1;
} else {
    AnguloPendiente = Math.atan(DistanciahastaDestinoY/DistanciahastaDestinoX);
    BallXSpeed = VelocidadAdelante*Math.cos(AnguloPendiente)*-1;
    BallYSpeed = VelocidadAdelante*Math.sin(AnguloPendiente)*-1;
}
// Datos para determinar posiciones de la pelota.
Tiempotranscurridodeltiro = 0;
BallXwhenstriked = BallX;
BallYwhenstriked = BallY;
BallZwhenstriked = BallZ;

El cálculo de las posiciones lo estoy haciendo en base al tiempo, así:

function Ballmoving () {
    Tiempotranscurridodeltiro = Tiempotranscurridodeltiro+1;
    BallX = BallXwhenstriked+BallXSpeed*Tiempotranscurridodeltiro;
    BallY = BallYwhenstriked+BallYSpeed*Tiempotranscurridodeltiro;
    BallZAnterior = BallZ;
    BallZ = BallZwhenstriked+VelocidadZ*Tiempotranscurridodeltiro-(Gravedad*Tiempotranscurridodeltiro*Tiempotranscurridodeltiro)/2;
    BallZSpeed = BallZ-BallZAnterior;
    if (BallZ<=0) {
        // Si la pelota llega al suelo, BallZSpeed se invierte con disminución según la cancha.
        BallZ = 0;
        BallZSpeed = BallZSpeed*Fuerzaderebotedepelota;
        // Si BallZSpeed es menor que 0.01: Queda en 0.
        if (BallZSpeed<0.01) {
            BallZSpeed = 0;
        }
        // La pelots, al rozarse con el suelo, disminuye sus velocidades.
        // BallXSpeed = BallXSpeed+Influenciadelrozamiento;
        if (BallXSpeed>0) {
            BallXSpeed = 0;
        }
        // BallYSpeed = BallYSpeed+Influenciadelrozamiento;
        if (BallYSpeed>0) {
            BallYSpeed = 0;
        }
    }
}

No sé qué está mal.
https://drive.google.com/file/d/1vDabAavB-YZrNTW1s6YW7o7y-kSBzyj_/view?usp=share_link
¿Te digo algún dato que no haya dicho ahí, cual?

Ah, el tema del pique se me complica, mejor luego del pique vuelvo al método simple de sumar ¿no? Aunque la pelota bajará a distinta velocidad. Yo lo que hacía es que cuando tocaba el suelo la bola, a su velocidad Z se le hacía *-1 y se reducía un poco, pero ahora de momento no sé cómo hacerlo.
La bola que queda en la red o en pantalla no es un error, hago que aparezca para ver qué tan cerca de la red pasó.

He estado pensando en otras cosas o cansado, pero aquí vuelvo

Vale, luego de leer tu post.

Ok, asumí que RedY era la altura así que lo llamé RedZ, y cuando vi -BallY me confundí y lo cambié por BallZ, supongo que fue por eso. Me confunde que Y sea Z...

¿Qué sucede si se calcula? Pensé que el tiro saldría corto ¿no ocurre eso? Si no se tiene suficiente fuerza igual debe haber un tiro, como si el personaje hubiera querido hacer un buen tiro. No tiene sentido que no se haga un tiro.

Sí ¿y si el más cercano tampoco sirve?

Pensé que tu método indicaba si pasaban o no.
...
Se me hizo líoso hacerlo, pero creo que está. También corregí, creo, que en vez de usar los ángulos usaba las alturas. ¿Disc qué abrevia o qué significa?

Creo que eso me quedó sin borrar del método anterior, creo que no influye salvo en el pique, que aún no lo arreglé. Gracias igual, si llego a eso y no lo puedo resolver te consulto. Lo borro por ahora a ver.

Probablemente no, el personaje es muy bajo por ejemplo. En el juego original los saques se hacen por encima del alcance de la raqueta y no se nota, pero en mi caso son acordes al alcance y me parece un poco bajo. El juego original:
https://www.youtube.com/watch?v=fc0_P2IGgJ4
¿Crees que habrá mucha diferencia en las escalas con el mío? Que yo sepa lo único que hice fue que la cancha entrara toda en la pantalla y también parte del fondo y los laterales, ya que en el juego original hay como paredes invisibles que si la bola toca es punto (no se nota salvo casos muy poco probables). También achiqué un poco al personaje porque ahí pareciera que ocuparan demasiado de la cancha.

En mi juego la cancha mide 239.9 de ancho (sin contar el corredor de dobles) y 480 de largo. Ese .9 es por motivos que no comprendo ni sé arreglar (ni volveré a dedicar tiempo a intentarlo), pero es mínimo, debería ser 240. La altura de la red es de unos 17.4 (pero la bola debe pasar a 18.6 mínimo). En fin, puse la gravedad que me pareció agradable a mi vista, no creo que sea ni tan poca ni tanta, pero ahora que lo dices, si con tu método es menos intensa aunque se use el mismo número, puede que deba aumentarla.
En el juego la fuerza de los tiros depende del tiempo de preparación, la fuerza de brazos, piernas, calidad de la raqueta y cuánto se usó en darle efecto a la bola, no sé si algo más... No he pensado o consultado tanto sobre eso. No tiene sentido que te de más detalles de eso tampoco ¿no? Te digo porque me llama la atención el 25 que pusiste ¿a qué se debe?

No tengo mucho interés en que sea tan realista en cuanto a velocidades o tamaños (especialmente la bola, sino no la veo mucho), tengo pensado que haya gran variedad de campeonatos variando el tamaño de algunas cosas por ejemplo. En otros aspectos sí quiero que sea realista, como he explicado.

Bueno, reviso el código de principio a fin, lo comparo con lo que has puesto.

Pusiste:
Disc = v0 * v0 * v0 * v0 - (g * (g * DistanciahastaDestinoXY * DistanciahastaDestinoXY - 2 * v0 * v0 * h))

Puse:

Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));

Luego debido a los ifs es complicado poner parte por parte, lo haré más adelante; este es el código con las partes más relevantes de este contexto supongo:

Gravedad = 0.01;
RedZ = 18.6;
// Datos para determinar velocidades del tiro.
DistanciahastaDestinoX = BallX-280.1;
DistanciahastaDestinoY = BallY-180;
// DistanciahastaRed = BallY-300;
// DistanciahastaMinsafeBallZ = BallZ-18.6;
DistanciahastaDestinoXY = Math.sqrt(DistanciahastaDestinoX*DistanciahastaDestinoX+DistanciahastaDestinoY*DistanciahastaDestinoY);
// Se calcula el ángulo o ángulos.
Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));
if (Disc<0) {
    // Fuerza insuficiente, si es posible habrá que acercar el destino.
    TiroRealizable = "Fuerza insuficiente";
} else {
    DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallY)/Math.abs(DistanciahastaDestinoY);
    // Le he llamado RedZ a lo que has llamado RedY.
    // Se calcula el ángulo Z;
    theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
    // Se calcula el tiempo que se tarda en llegar a la red.
    TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
    // Se calcula la altura a la que pasa la bola al llegar a la red.
    AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;
    if (Disc == 0) {
        // Sólo hay 1 ángulo Z posible.
        if (AlturaEnRedTheta>=18.6) {
            // Si la bola pasa la red con ese ángulo, usarlo.
            TiroRealizable = "1 ángulo, ok";
            Angulo = theta;
        } else {
            TiroRealizable = "1 ángulo, imposible";
            // Probar acercar destino supongo.
            Angulo = "Ninguno";
        }
    } else {
        // Disc>0, hay 2 angulos posibles, calcular el faltante.
        phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
        TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
        AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
        if (AlturaEnRedTheta>=18.6) {
            if (AlturaEnRedPhi>=18.6) {
                // Con ambos ángulos la bola pasa la red, usar el más bajo.
                if (AlturaEnRedTheta<AlturaEnRedPhi) {
                    Angulo = theta;
                } else {
                    Angulo = phi;
                }
            } else {
                // Sólo sirve el 1er ángulo.
                Angulo = theta;
            }
        } else if (AlturaEnRedPhi>=18.6) {
            // Sólo sirve el 2ndo ángulo.
            Angulo = phi;
        } else {
            // Ningún ángulo sirve.
            Angulo = "Ninguno";
            // Probar acercar destino supongo.
        }
    }
    if (Angulo != "Ninguno") {
        // Cálculo de las velocidades.
        VelocidadAdelante = AlexFuerzadetiros*Math.cos(Angulo);
        VelocidadArriba = AlexFuerzadetiros*Math.sin(Angulo);
        // Esta variable es redundante, pero clarifica lo que se esta haciendo.
        VelocidadZ = VelocidadArriba;
        if (DistanciahastaDestinoX == 0) {
            BallXSpeed = 0;
            BallYSpeed = VelocidadAdelante*-1;
        } else {
            AnguloPendiente = Math.atan(DistanciahastaDestinoY/DistanciahastaDestinoX);
            BallXSpeed = VelocidadAdelante*Math.cos(AnguloPendiente)*-1;
            BallYSpeed = VelocidadAdelante*Math.sin(AnguloPendiente)*-1;
        }
        // Datos para determinar posiciones de la pelota.
        Tiempotranscurridodeltiro = 0;
        BallXwhenstriked = BallX;
        BallYwhenstriked = BallY;
        BallZwhenstriked = BallZ;
    }
}

Dijiste:
Si Disc < 0, no puedes hacer el tiro

Puse:
Y que yo sepa nada ocurrirá ahí, en el caso de true. Lo de cambiar destino lo haré más adelante.

Dijiste:
Si Disc == 0, hay un solo angulo posible
Si Disc > 0, hay dos angulos
Esos casos son mi else, calculo 1 ángulo y luego si Disc>0 calculo el otro. Alteré un poco el orden de tu código pero creo que no hay problema.

Haces:
theta = arctan((v0 * v0 + raiz(Disc)) / (g * DistanciahastaDestinoXY))
DistanciahastaRed = DistanciahastaDestinoXY * abs(RedY - BallY) / abs(DistanciahastaDestinoY)
TiempoHastaRedTheta = (DistanciahastaRed) / (v0 * cos(theta))

Hice:

DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallY)/Math.abs(DistanciahastaDestinoY);
// Le he llamado RedZ a lo que has llamado RedY.
theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;

Lo último te lo copié de esto:
AlturaEnRedTheta = h + v0 * sen(theta) * TiempoHastaRedTheta - (g * TiempoHastaRedTheta * TiempoHastaRedTheta) / 2

Luego lo que hago depende del caso como habías dicho:

if (Disc == 0) {
	// Sólo hay 1 ángulo Z posible.
	if (AlturaEnRedTheta>=18.6) {
		// Si la bola pasa la red con ese ángulo, usarlo.
		TiroRealizable = "1 ángulo, ok";
		Angulo = theta;
	} else {
		TiroRealizable = "1 ángulo, imposible";
		// Probar acercar destino supongo.
		Angulo = "Ninguno";
	}
} else {
	// Disc>0, hay 2 angulos posibles, calcular el faltante.
	phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
	TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
	AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
	if (AlturaEnRedTheta>=18.6) {
		if (AlturaEnRedPhi>=18.6) {
			// Con ambos ángulos la bola pasa la red, usar el más bajo.
			if (AlturaEnRedTheta<AlturaEnRedPhi) {
				Angulo = theta;
			} else {
				Angulo = phi;
			}
		} else {
			// Sólo sirve el 1er ángulo.
			Angulo = theta;
		}
	} else if (AlturaEnRedPhi>=18.6) {
		// Sólo sirve el 2ndo ángulo.
		Angulo = phi;
	} else {
		// Ningún ángulo sirve.
		Angulo = "Ninguno";
		// Probar acercar destino supongo.
	}
}

¿Todo bien?

Habías dicho:

Yo ahí puse:

phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;

Luego dices:

Puse:

Dices:

Puse:
Los *-1 los quito si veo que los tiros van para atrás o algo.

Los cambios en la pantalla por el movimiento los hago así:

Veo que habías dicho:
x = v0 * cos(θ) * t
y = v0 * sen(θ) * t - (g * t2)/2

Y más recientemente:
BallZ = h + VelocidadZ * t - (g * t * t)/2

Ahí me maree. BallZ lo tengo igual parece, lo otro no y como es la perspectiva 2d me confundo.

Bueno, pruebo el código, grabo video y demás y te muestro el resultado.
...
De momento me da errores gráficos no sé bien por qué (la pantalla se agranda o se achica, me ha pasado otras veces cuando se ordena modificar el tamaño de un objeto inexistente). He probado con distintas fuerzas y obtuve casos de fuerza insuficiente y de 2 ángulos pero que ninguno sirve. Agregué más estados de la variable TiroRealizable para ver eso. No sé, voy a probar quitar el código e irlo poniendo de a poco a ver cual es el problema. O pruebo desde la versión anterior mejor.
...
Ya arreglé el tema de los gráficos pero sólo obtengo casos de fuerza insuficiente si le pongo muy poca o casos de "2 ángulos pero ninguno sirve".
Por ejemplo:
Gravedad = 0.01
RedZ = 18.6
AlexFuerzadetiros = 2.975
AlexX = 488
AlexY = 548
DistanciahastaDestinoX = 240.9
DistanciahastaDestinoY = 368
DistanciahastaDestinoXY = 439.837253992883
Parte = 78.333562890625
Disc = 66.960524890625
DistanciahastaRed = 632.744136586501
theta = 1.31809820149062
TiempoHastaRedTheta = 850.689542137363
AlturaEnRedTheta = -1122.89688542468
phi = 0.150652307511496
TiempoHastaRedPhi = 215.123727738993
AlturaEnRedPhi = -90.2989548532666
TiroRealizable = "2 ángulos, pero ninguno sirve"
Angulo = "Ninguno"
BallXwhenstriked = 521
BallYwhenstriked = 548
BallZwhenstriked = 45.04

Medio supongo que tiene que ver con esas alturas negativas en la red, voy a revisar si hice algo mal ahí y si es el caso edito el post medio pronto, sino es que no sé.