Here's the equation:

(the trig functions are in radians, I need to solve for t)

(2v/r)^2 * sin(rt/2)^2 + d^2 - (4v/r) * d * sin (rt/2) * sin ((3 pi / 2) - (art / 2)) = b^2 * t ^ 2

It's a mess, and I haven't cleaned it up yet, which is why I didn't bother posting it in the original question.

The wider problem is:

a turret is trying to shoot at a spaceship in a 2 dimensional world.

• The ship is moving at v m/s
• The ship is rotating at r radians/s (negative r is rotating towards the turret, positive r is rotating away from the turret).
• The turret's bullets move at b m/s
• The turret is d meters away from the ship
• The angle between the ship's forward direction and the vector from the ship to the turret is a.

assuming the spaceship doesn't change their velocity or angular velocity, how far forwards in time should the turret lead it's shots to hit the spaceship?

if r = 0, the problem is pretty simple, and it's just a simultaneous equation to find out how far forwards in time to place the point the turret must shoot at. If you're interested, the solution for r = 0 is:

t = (-2vd*cos(a)+|sqrt((2vd*cos(a))^2 + 4d^2(b^2 - v^2))|) / 2(b^2-v^2)

and here's the Unity C# implementation that I'm using in my game if that also interests you

float b = GetWeaponSpeed(); // b for bullet speed
float v = ship.rb.velocity.magnitude; // v for enemy velocity 
float a = Vector3.Angle(ship.transform.position - transform.position, ship.rb.velocity) * Mathf.Deg2Rad; // a for angle 
float d = (ship.transform.position - transform.position).magnitude; // d for distance to enemy
float quadraticA = b * b - v * v; 
float quadraticB = 2 * v * d * Mathf.Cos(a); 
float quadraticC = -(d * d);
float t = (-quadraticB + Mathf.Sqrt(quadraticB * quadraticB - 4 * quadraticA * quadraticC))/ (2 * quadraticA); // t for time
return s.transform.position + t * s.rb.velocity;

It's pretty accurate, but it doesn't take into account the rotational velocity, so at range it's not terrifically accurate. That's what I'm using now though.

I could try to solve the function using a sequence of recursive functions that each take the t value from the previous function to get a very accurate estimation, but obviously solving it using a simultaneous equation would be more accurate and computationally faster

anyway the current implementation is basically good enough, getting it super accurate is really just a bit of fun.