Just enough trig to fire bullets in a space shooter!
From the #librelounge channel on irc.freenode.net

<dustyweb> trying to remember just enough trigenometry to make bullets move on
           angles  [14:59]
<dustyweb> which I think is honestly not much
<dustyweb> but I remember almost nothing
<davexunit> dustyweb: is this linear motion or by "move on angles" you mean
            change their angle as they travel?  [15:00]
<dustyweb> davexunit: just linear motion, so I think it's almost nothing.
           Probably to aim and fire at the enemy ship I just calculate the
           angle and then just extend from the initial position outward along
           the tangent?  [15:01]
<davexunit> leaving aiming aside for a moment. if you want to make something
            move at an angle (let's call it "theta") at a certain speed you
            can do this: dx = cos(theta) * speed, dy = sin(theta) * speed
                                                                        [15:02]
<davexunit> (dx, dy) becomes your bullet velocity vector.  [15:03]
<dustyweb> davexunit: I think I see
<dustyweb> that seems very simple
<davexunit> theta is assumed to be in radians, not degrees, in the above
            example.  [15:04]
<dustyweb> radians are the right way to do it yes :)
<davexunit> to make one of your ships aim at something, you need to first
            calculate the difference between the target position and the
            ship's position.  [15:06]
<davexunit> let's call that (dx, dy) again. it's a vector going from the ship
            that is shooting towards the target.
<davexunit> then you need to normalize that vector to get a vector that is 1
            unit in total length. (I can explain this further if you want)
                                                                        [15:07]
<davexunit> then finally you multiply the normalized vector by the speed of
            the bullet being fired and you have your desired velocity vector.
<dustyweb> 
<dustyweb> 4|         T
<dustyweb> 3|
<dustyweb> 2|
<dustyweb> 1| S
<dustyweb> 0|
<dustyweb>  '------------
<dustyweb>    0 1 2 3 4 5
<dustyweb> so if S is shooter
<dustyweb> and T is target
<dustyweb> S is at (0,1)
<dustyweb> T is at (4,4)  [15:09]
<dustyweb> dx would be 4
<dustyweb> dy would be 3
<davexunit> (4,4) - (0,1) = (4,3)
<davexunit> so yeah you are correct
<dustyweb> yeah
<dustyweb> so next I need to calculate the angle I guess
<davexunit> if you used that as your velocity, the bullet would reach the
            target instantaneously
<davexunit> so, if you want to shoot *directly* at the target, you don't need
            to compute the angle.
<dustyweb> press fire to win  [15:11]
<dustyweb> teleport bullet directly to target
<davexunit> do you know what the magnitude of a vector is?
<dustyweb> nope :D
<davexunit> and/or are you familiar with the distance formula between two
            points?
<dustyweb> I am familiar with that, yes  [15:12]
<davexunit> no worries, it's so simple. it's just M-x magnitude
* dustyweb checked to see if that existed
<dustyweb> foiled!
<davexunit> ;)
<dustyweb> I bet M-x calc has it though
<davexunit> so, magnitude is the same thing as calculating the distance
            between two points, only simpler.
<davexunit> so our vector is (4,3) right?  [15:13]
<dustyweb> yes
<davexunit> let's calculate the distance between that point and (0,0)
<davexunit> sqrt((4 - 0) ^ 2 + (3 - 0) ^ 2)
<davexunit> simplified: sqrt(4 * 4 + 3 * 3)
<davexunit> or 5  [15:14]
<dustyweb> right because a^2 + b^2 = c^2 right?
<davexunit> yes you can derive the distance formula that way
<davexunit> take generic vector (dx,dy)
<davexunit> magnitude = sqrt(dx * dx + dy * dy)
<davexunit> that tells you how long the vector is  [15:15]
<davexunit> that's cool and stuff, but we can use it to "normalize" a
            vector. which means we're gonna turn that vector of length 5 into
            a vector of length 1.
<davexunit> doing that is also easy.
<davexunit> the normalized vector is (dx / magnitude, dy / magnitude)  [15:16]
<davexunit> why did we want to do that? because now we can *scale* that vector
            by the bullet speed to get the desired velocity for the bullet!
<dustyweb> hold up, I think I get it
<dustyweb> but let me double check :)
<davexunit> yeah I'm pausing here
<dustyweb> the distance, by the distance formula, is 5 long.
<dustyweb> so, if we're assuming we're moving at "one unit per second"
<davexunit> "one space unit per time unit" if we want to get *real* generic ;)
<dustyweb> then we can simply divide the vector by the length of the line
           segment
<dustyweb> yes  [15:18]
<dustyweb> sorry
<davexunit> but yes, you're right
<dustyweb> and then, for instance, in 5 time units
<dustyweb> it would reach the target
<dustyweb> that makes a *heck* of a lot of sense
<dustyweb> thanks davexunit :)
<davexunit> normalizing a vector is a way to make direction vectors.  [15:19]
<davexunit> so if you want the bullet two move 2 space units per tick,
            multiply the normalized vector by 2.
<davexunit> to move*
<dustyweb> great :D  [15:20]
<dustyweb> this was an awesome tutorial davexunit   [15:21]
<dustyweb> exactly what I needed
<davexunit> if you want to do something more complex, like aim a bit off
            center of the target, then you need to do something different, but
            I didn't want to open that particular can of worms.
<dustyweb> davexunit: well couldn't a "lazy" way to do that just be change
           where the target is
<dustyweb> by offsetting it
<davexunit> yes
<dustyweb> eg, maybe we want to fire two spaces in front of the target because
           it's moving towards us
<dustyweb> and that's going to often be close enough  [15:22]
<dustyweb> cool
<dustyweb> great
<davexunit> something simple like that could work
<dustyweb> these are bots firing at the player, they don't have to be galaxy
           brain :)
<dustyweb> they shouldn't even :)
<davexunit> sometimes situations arise where you need to compute the exact
            angle between two points, and for that I believe you need to
            invoke the arctan function
<davexunit> but sounds like you won't need that.
<dustyweb> davexunit: I think I won't  [15:23]
<davexunit> arctan(dy,dx) will get you the angle of the vector, though. just
            fyi ;)
<dustyweb> davexunit: this was a great tutorial.  mind if I pastebin it and
           post it to the fediverse?  maybe some other people will benefit :)
                                                                        [15:24]
<davexunit> sure!
<davexunit> good luck with terminal phase
<dustyweb> thank you davexunit 
<davexunit> you're welcome
<davexunit> oh one gotcha: don't normalize a vector of length 0 because then
            you get divide by 0 errors  [15:33]
<davexunit> an enemy trying to shoot at something directly on top of it could
            create that scenario.
<dustyweb> davexunit: ah!  good point.  [15:36]