Vuoi l'angolo della freccia in qualsiasi momento. Ti sei ricordato che per calcolare un angolo c'è una tangente. Ma qui è dove il tuo pensiero ha iniziato a sbagliare:
- Quello che vuoi è delta y / delta x, perché la pendenza è la velocità di variazione (menzionata in una delle altre risposte). Nota che x è solo la posizione in cui ti trovi in qualsiasi momento, non dx.
Ok, quindi se trascuri l'attrito dell'aria, la velocità x della freccia è una costante.
Innanzitutto, decomporre la velocità in componenti xey. Potresti sparare con un angolo di 45 gradi o 60 gradi. Quindi hai bisogno di launchVelocity e un angolo, non è uno scalare.
Secondo, calcola tutto come doppio, non float. Non sei abbastanza numericamente sofisticato da sapere quando l'errore di arrotondamento non ti ucciderà, quindi non provare. Non è comunque un grande risparmio di tempo.
Terzo, non usare Math.pow, è lento e non accurato come moltiplicarsi per i poteri interi. Inoltre puoi risparmiare molto tempo usando il modulo di Horner (vedi sotto)
final double DEG2RAD = Math.PI/180;
double ang = launchAngle * DEG2RAD;
double v0x = launchVelocity * cos(ang); // initial velocity in x
double v0y = launchVelocity * sin(ang); // initial velocity in y
double x = (v0x * time);
// double y = (v0y * time) + (0.5 * g * (float)Math.Pow(time, 2));
double y = (0.5 * g * time + v0y) * time
Se sei alla disperata ricerca di prestazioni, puoi anche pre-calcolare 0,5 * g, ma il codice sopra ti porterà al 90% del percorso senza fare nulla di troppo folle. Se lo desideri, fai questo benchmark 10 milioni di volte, è vero che non è un tempo enorme, ma in termini percentuali è piuttosto grande - le librerie sono molto lente in Java
Quindi, se volevi l'angolo in cui la freccia dovrebbe andare, quello che vuoi è
atan(dy/dx)
E in questo caso, funzionerebbe perché dx è una costante. Ma in generale, dx può essere zero, quindi di solito si desidera utilizzare:
atan2(dy, dx)
che è una funzione appositamente progettata per questo lavoro.
Ma come ho detto, le funzioni di libreria in Java sono tremendamente lente, e in questo caso c'è un modo migliore di farlo senza come accennato da @FxIII sopra.
Se la velocità orizzontale è sempre v0x e la velocità verticale è:
double vy = v0y - 0.5 * g * time;
allora il tuo delta è: vx, vy
Non hai bisogno dell'angolo. Se vuoi disegnare una freccia, usa qualcosa di nominalmente come:
trama (x, y, x + vx, y + vy);
Non so cosa stai disegnando, quindi se hai bisogno dell'angolo per ruotarlo (come se stessi usando JOGL), allora sicuramente usa l'angolo.
Non dimenticare se stai usando Opengl per riportare l'angolo in gradi, perché ATAN2 restituisce radianti:
final double RAD2DEG = 180 / Math.PI;
double ang = Math.atan2(vy,vx); // don't forget, vy first!!!
double deg = ang * RAD2DEG;
