How do i predict the enemy position, so the bullet will always hit it - regardless how fast the enemy moves, including other variables such as:

- Enemy speed

- Weapon cooldown

- Bullet speed

- Gun facing direction

- Gun rotation speed

My current approach is very simple, so does it not work always:

// @TODO(final): Much better prediction scheme
// Multiply delta time by some factor computed by:
// - Gun cooldown
// - Bullet Speed
// - Gun Rotation Speed/Delta
Vec2f predictedPosition = enemy->position + enemy->facingDirection * enemy->speed * input.deltaTime;
Vec2f distanceToEnemy = predictedPosition - tower.position;
Vec2f directionToEnemy = Vec2Normalize(distanceToEnemy);
float angleToEnemy = ArcTan2(directionToEnemy.y, directionToEnemy.x);
constexpr float tolerance = 0.1f;
float delta = angleToEnemy - tower.facingAngle;
if(Abs(delta) > tolerance) {
	float inc = delta < 0 ? -1.0f : 1.0f;
	float value = Min(input.deltaTime, Abs(delta));
	tower.facingAngle += tower.data->gunRotationSpeed * value * inc;
}

Is there a better approach?

I nailed it:

if(tower.hasTarget) {
	assert(tower.targetEnemy != nullptr);
	Creep *enemy = tower.targetEnemy;

	// First we compute how many frames we need until we can actually fire (Weapon cooldown)
	float framesRequiredToFire = (tower.gunTimer / input.deltaTime);
	float timeScale = Max(framesRequiredToFire, 1.0f);

	// Now we predict the enemy position based on the enemy speed and the number of frames required to fire
	Vec2f predictedPosition = enemy->position + enemy->facingDirection * enemy->speed * input.deltaTime * timeScale;
	Vec2f distanceToEnemy = predictedPosition - tower.position;

	// Second we compute how many frames we need the bullet to move to the predicted position
	assert(tower.data->bullet.speed > 0);
	float bulletDistance = Vec2Length(distanceToEnemy) / tower.data->bullet.speed;
	float framesRequiredForBullet = (bulletDistance / input.deltaTime);

	// Now we recompute the time scale and the predicted enemy position
	timeScale = Max(framesRequiredToFire + framesRequiredForBullet, 1.0f);
	predictedPosition = enemy->position + enemy->facingDirection * enemy->speed * input.deltaTime * timeScale;
	distanceToEnemy = predictedPosition - tower.position;

	// Smoothly rotate the gun
	Vec2f directionToEnemy = Vec2Normalize(distanceToEnemy);
	float angleToEnemy = Vec2AxisToAngle(directionToEnemy);
	float deltaAngle = angleToEnemy - tower.facingAngle;
	float anglePositiveIncrement = deltaAngle < 0 ? -1.0f : (deltaAngle > 0.0f ? 1.0f : 0.0f);
	if(!tower.gunIsRotating) {
		tower.rotationTimer[0] = 0;
		tower.rotationTimer[1] = 1.0f / tower.data->gunRotationSpeed;
		float anglePerFrame = Min(Pi32 / tower.rotationTimer[1], Abs(deltaAngle));
		tower.targetAngle[0] = tower.facingAngle;
		tower.targetAngle[1] = tower.facingAngle + anglePerFrame * anglePositiveIncrement;
		tower.gunIsRotating = true;
	} else {
		assert(tower.rotationTimer[1] > 0);
		tower.rotationTimer[0] += input.deltaTime;
		if(tower.rotationTimer[0] > tower.rotationTimer[1]) {
			tower.rotationTimer[0] = tower.rotationTimer[1] = 0;
			tower.targetAngle[0] = tower.targetAngle[1] = 0;
			tower.gunIsRotating = false;
		} else {
			float t = tower.rotationTimer[0] / tower.rotationTimer[1];
			tower.facingAngle = ScalarLerp(tower.targetAngle[0], t, tower.targetAngle[1]);
		}
	}

	// Fire when we have a target in sight
	if(tower.canFire) {
		Vec2f lookDirection = Vec2AngleToAxis(tower.facingAngle);
		float maxDistance = Vec2Length(distanceToEnemy) + enemy->data->collisionRadius;
		LineCastInput input = {};
		input.p1 = tower.position + lookDirection * tower.data->gunTubeLength;
		input.p2 = input.p1 + lookDirection * maxDistance;
		input.maxFraction = 1.0f;
		LineCastOutput output = {};
		bool willHit = LineCastCircle(input, predictedPosition, enemy->data->collisionRadius, output);
		if(willHit) {
			towers::ShootBullet(*state, tower);
		}
	}
}

1 hour ago, lawnjelly said:

I only had a quick look but does your code roughly guess where the enemy is, calculate the time of a bullet moving to that position, then recalculate the enemy predicted position based on its speed and that bullet travel time?

If so then it does not take account that the enemy could be moving closer or further away from the shooter, and thus the bullet travel time will be less or more than that, i.e. the enemy predicted position and the bullet travel time 'vary together'. So you will miss a lot I think.

I may be wrong on that though I only had a brief look. That's what the simultaneous equations sort out for you (I must admit it's beyond me mathematically, decades since I did it at school!).

Indeed there was a bug when i computed the bullet distance (Speed was not converted to a distance), now it is:

float bulletDistance = Vec2Length(distanceToEnemy) / (tower.data->bullet.speed / input.deltaTime);

6 hours ago, Finalspace said:

Is there a better approach?

In case projectile velocity is constant try to use a proportional aiming algo. It have perfect accuracy for targets with  low trajectory curvature and also not require distance measurment. It usualy used for guided missiles aiming, but can be extended to unguided projectiles with assumption of constant projectile velocity.

Key of method - when projectile goes to interseption point, line that connect the projectile and the target  is not rotating. So wee need just 2 consecutive trajectory points of the missile and the target to calculate viewing line angle difference, and than turn the missile proportionally to angle difference. It how "Sidewinder", "Stinger" and any other IR-guided missile works. Following this algo, a missile, guided to nonimmunithing target, starting part of his trajectory finding a vector to interseption  point, and than moves about lieary. So it is possible to extend this algo for unguided progectils, by finding а interception vector by proportionally rotating a barrel before shoot. Only that we need for it is to select а 2 tragectory points for projectile. First point is the muzzle of the barrel point. Second can be eaesly calculated too. It just a muzzle point moved on opposite direction by one bullet timeframe step distance, to match time of previous target point. So we need just make 2 lines that connecting points and calculate angle betwin them, then rotate barrel propotionally to it angle. Barrel will follow a interception point for selected target. When angle absolute value becomes less then tolerance angle we can fire a bullet. 

Also this algo give ability to control accuracy and aiming response time, by modifying a proporionl regulation coefficient and tolerance angle.