3D Trigonometry

Hey guys! I'm making a plugin which launches TNT via cannons. Right now the TNT has predesignated paths, but I'm working to improve that by making it launch to wherever you look at. Specifically I need a way to calculate a vector of TNT which goes from 1 block to another in an arc.
I've made a drawing to demonstrate the process: http://sketchtoy.com/51223008
Any ideas? Even just pointing me in the right direction to learn this would be great.

 

You would need to know the gravity of a falling primed TNT entity, but I did this for potions (yay for quadratics):

Code:java

public static final double POTION_GRAVITY = 0.115;
 
public static Vector getPotionVelocity(Location fromLoc, Location toLoc, int heightGain){
Vector from = fromLoc.toVector();
Vector to = toLoc.toVector();
 
//Block locations
int endGain = to.getBlockY() - from.getBlockY();
double horizDist = fromLoc.distance(toLoc);
 
//Height gain
int gain = heightGain;
double maxGain = (gain > (endGain + gain) ? gain : (endGain + gain));
 
//Solve quadratic equation for velocity
double a = -horizDist * horizDist / (4 * maxGain);
double b = horizDist;
double c = -endGain;
double slope = -b / (2 * a) - Math.sqrt(b * b - 4 * a * c) / (2 * a);
 
//Vertical velocity
double veloY = Math.sqrt(maxGain * POTION_GRAVITY);
 
//Horizontal velocity
double vH = veloY / slope;
 
//Calculate horizontal direction
int distX = to.getBlockX() - from.getBlockX();
int distZ = to.getBlockZ() - from.getBlockZ();
double mag = Math.sqrt(distX * distX + distZ * distZ);
double dirX = distX / mag;
double dirZ = distZ / mag;
 
//Horizontal velocity components
double veloX = vH * dirX;
double veloZ = vH * dirZ;
 
//Actual velocity
Vector velocity = new Vector(veloX, veloY, veloZ);
 
return velocity;
}

//EDIT: Perhaps this is possible with vectors? LucasEmanuel

 

This just needs a bit of vector magic.
Get the view vector with "player.getLocation().getDirection()".
Launch the tnt in this direction with a specific force, and offset this force with the gravity and a final value for traveled blocks.

 

How would I go about making vectors which aim TNT just to the left and right of a vector produced by this method?
By the way, thanks a ton for the code, I really appreciate it!

 

AGuyWhoSkis I wouldn't change the returned vector, but change the location parameters in the method.

 

chasechocolate Do you know how precise this is? Because as far as I am aware, there is "air drag" in minecraft, so the entities don't fly in a perfect parabolic curve, but more in a curve like shown in this image: http://de.wikipedia.org/wiki/Datei:Ballistik_bei_schuss_mit_gelaendewinkel.svg

The drag for the different entities (and their acceleration values) can be found in the minecraft wiki: http://minecraft.gamepedia.com/Entity#Motion_of_entities

In the past I also tried to find some equation for this (but I failed). So I solved it in a different attempt:
In my case my vector's length (projectile's speed) is fixed (so I can't shoot infinite far targets).
The idea is to prepare some sort of table with precalculated angles for the different locations (in range/each entry in the table represents one block location) and later pick the right one from it.

I first create a table of fixed size (I think in my case I limited it to 100 blocks range in x-z-direction and 50 blocks up and 50 blocks down in y direction -> results in a 100 * 100 large table).

I also limited the angles I am interested in to -45 degree to 45 degree and I limited the flight duration to something like 100 ticks.

Then I took the acceleration and drag values from the minecraft wiki and "simulated" the entities motion in a loop, tick by tick, for each 1-angle-step between -45 and 45 degree, and inserted the current angle into the entry of my table, which represents the projectiles current location after 1 tick.

After that I fill the remaining empty entries in my table with the nearest upper angle.

And that's it. If I now need the angle to shoot a certain location in the range of my calculated table, I just do a quick lookup in my table.


And here is the code (note, that, while it seems to work quite well, I have written this a long time ago and then never took a clear look on it again. So it is very likly that it can be improved.)

Creating the table:

Code:java

 
/**
 * You are welcome to use, redistribute and modify your own copies of this source as long as you provide credit publicly to the original source.
 * 
 * @author blablubbabc
 */
 
private Double[][] table;
private int ySize;
private double fixedSpeed;
 
calculateTable(angleMin, angleMax, ticks, xSize, ySize, fixedSpeed);
 
private void calculateTable(int angleMin, int angleMax, int ticks,
            int xSize, int ySize, double fixedSpeed) {
        this.ySize = ySize;
 
        // if ySize = 50 -> size = 2*50: y-Size in both directions, up and down:
        // 0=> 50
        table = new Double[xSize][2 * ySize];
 
        // this are the acceleration and drag values for snowballs from the minecraft wiki
        Double drag = 0.01D;
        Double g = 0.03D;
        Double vyMin = -3.0D;
 
        // default values
        for (int i = 0; i < table.length; i++) {
            for (int j = 0; j < table[i].length; j++) {
                table[i][j] = null;
            }
        }
 
        for (int a = angleMin; a <= angleMax; a++) {
            Double tan = Math.tan(a * Math.PI / 180.0);
            // t=0:
            Double vx = Math.cos(a * Math.PI / 180.0) * fixedSpeed;
            Double vy = Math.sin(a * Math.PI / 180.0) * fixedSpeed;
            Double x = 0.0D;
            Double y = 0.0D;
 
            for (int t = 1; t <= ticks; t++) {
                x += vx;
                y += vy;
                vx = vx * (1 - drag);
                if (vy > vyMin)
                    vy = vy - g;
                vy = vy * (1 - drag);
 
                int tx = x.intValue();
                int ty = y.intValue();
                if (tx < table.length && (ty + ySize) < 2 * ySize
                        && (ty + ySize) >= 0) {
                    table[tx][ty + ySize] = tan;
                }
            }
        }
        // 0 Location gets angle 0
        table[0][ySize] = 0.0D;
 
        // fill empty squares between max and min angle curve:
        for (int x = 0; x < xSize; x++) {
            int yMin = 0;
            int yMax = 2 * ySize - 1;
            // find min:
            for (int y = 0; y < 2 * ySize; y++) {
                if (table[x][y] != null) {
                    yMin = y;
                    break;
                }
            }
            // find max:
            for (int y = 2 * ySize - 1; y >= 0; y--) {
                if (table[x][y] != null) {
                    yMax = y;
                    break;
                }
            }
            // fill empty squares between:
            for (int y = yMax - 1; y > yMin; y--) {
                if (table[x][y] == null) {
                    // insert value from above
                    table[x][y] = table[x][y + 1];
                }
            }
        }
    }
[/i][/i]

Can-be-shot-check and getAimVector:

Code:java

 
private boolean canBeShoot(Vector pos, Vector target, Vector dir) {
            int x = ((Double) target.clone().setY(0).distance(pos.clone().setY(0))).intValue();
            int y = ((Double) (target.getY() - pos.getY())).intValue();
            if (x < table.length && (y + ySize) < 2 * ySize && (y + ySize) >= 0) {
                return (table[x][y + ySize] != null);
            } else {
                return false;
            }
        }
 
        private Vector getAimVector(Vector pos, Vector target, Vector dir) {
            Vector aim = dir.clone().normalize();
            int x = ((Double) target.clone().setY(0).distance(pos.clone().setY(0))).intValue();
            int y = ((Double) (target.getY() - pos.getY())).intValue();
            Double tan = null;
 
            if (canBeShoot(pos, target, dir)) {
                tan = table[x][y + ySize];
            } else {
                int yTarget;
                int xTarget;
                // find nearest y
                if ((y + ySize) >= 2 * ySize) {
                    yTarget = 2 * ySize - 1;
                } else if ((y + ySize) < 0) {
                    yTarget = 0;
                } else {
                    yTarget = (y + ySize);
                }
                // find nearest x (x is always positive because of direction change)
                if (x > table.length) {
                    xTarget = 0;
                } else {
                    xTarget = x;
                }
 
                // find max X for this y
                for (int tablex = table.length - 1; tablex >= 0; tablex--) {
                    if (table[tablex][yTarget] != null) {
                        tan = table[tablex][yTarget];
                        break;
                    }
                }
                if (tan == null) {
                    // find max y for this x
                    for (int tabley = 2 * ySize - 1; tabley >= 0; tabley--) {
                        if (table[xTarget][tabley] != null) {
                            tan = table[xTarget][tabley];
                            break;
                        }
                    }
                }
                // shoot with nearly nearest angle:
            }
            if (tan == null) {
                // default angle 45; tan 45 = 1.619
                tan = 1.619D;
            }
            return aim.setY(tan).normalize().multiply(fixedSpeed);
        }
 
    }
 

Between, the array of Double's does requires about 200kb I guess. So having one of those tables in memory shouldn't be a problem.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

blablubbabc good point, I hadn't really considered that.

 

Loc

Here's some code I used to fire snowballs from one player to another. No trig needed. Maybe it can be slightly adjusted (by adding a calculated height and extra multiply() value).

Code:

Player p1 = event.getPlayer();
Player p2 = ???;//other player
Location locSrc = p1.getEyeLocation().add(0.0D, 0.25D, 0.0D);
Location locDest = p2.getEyeLocation();
Vector trans = new Vector(locDest.getBlockX()-locSrc.getBlockX(), locDest.getBlockY()-locSrc.getBlockY(), locDest.getBlockZ()-locSrc.getBlockZ());
Snowball snowball = (Snowball)locSrc.getWorld().spawnEntity(locSrc, EntityType.SNOWBALL);
snowball.setShooter(p1);
snowball.setVelocity(trans.normalize().multiply(2.0D));

 

Assuming that Notch based the air-resistance somewhat on reality, you might be able to use real-world math to calculate the trajectory. By doing so, you could be able to calculate what the initial velocity needs to be and the inclination needed in order to get the object from one spot to the other.

 

Also note that there are multiple possible arcs from the source to the target, if both, angle and velocity are variable:

You could either shoot a low, more direct arc with a very high velocity, or you shot a higher arc, with a lower velocity.

 

Precisely, you could replicate a modern artillery-cannon that way and make it fire the TNT with different inclination and force to make several explosives hit the target at the same time