Missile Turret

We’ll be making 2 turrets, the first one will shoot missile, and to make things more interesting we’ll make them heat seeking missiles 🎯

Rotating Turret

Our turret will have 2 parts. The base which will be rotated to attach to the ground (or wall, or ceiling), and the turret, which will be rotate to aim at the player. The base and turret, will be frames 0 and 1 of sMissileTurret accordingly

Wait a second … drawing 2 sprites on top of each other with different rotations? This sounds awfully familiar, I don’t think you need me for this one

// oTurret Create Event
turret_angle = 0;

// oTurret Step Event
//// GUN ANGLE
{
	turret_angle = point_direction(x, y, oPlayer.x, oPlayer.y);
}

// oTurret Draw Event
// base
draw_sprite_ext(sprite_index, 0, x, y, image_xscale, image_yscale, image_angle, image_blend, image_alpha);
// turret
draw_sprite_ext(sprite_index, 1, x, y, abs(image_xscale), abs(image_yscale), turret_angle, image_blend, image_alpha);

When we test it out we should see a living rotating turret

Turret Damage

Now let’s have the turret take damage. I think you can actually handle this as well

So we want the turret to lose hp whenever the player’s bullets collide with it, and then die when it loses all hp. As a bonus making you can research image_blend and use it to adjust the turret color when it’s hurt

HINT: I ended up needing instance_place to get this working, so you can read up on that if you hit issues

// oTurret Create Event
hp = 3;

// oBullet Step Event
//// TURRET COLLISION
{
	if(place_meeting(x+dx, y+dy, oTurret)){
		var turret = instance_place(x+dx, y+dy, oTurret);
		with(turret){
			hp--;
			image_blend = c_red;
			alarm[0] = 10;
		}
		instance_destroy();
	}
}
//// WALL COLLISION
//// APPLY MOVEMENT

// oTurret Alarm 0 event
image_blend = c_white;

// oTurret Step Event
//// GUN ANGLE
//// DEATH
{
	if(hp <= 0){
		instance_destroy();
	}
}

Once we’ve added all that our turrets should be killable

Basic Missiles

So now we can fight the turrets, but it’s kind of an unfair fight. Let’s give it some missiles to fight back

I’ll let you handle the basic missiles first, then I’ll take the wheel and help with the heat seeking. The basic missiles will essentially be the same as the bullets. We want the turret’s to make the missiles using a recurring alarm, and then after that the bullets should continue to move in the direction they were shot

// oTurret Create Event
alarm[1] = random_range(3*room_speed, 5*room_speed);
center_to_turret_end_dist = 64;

// oTurret Alarm 1 Event
alarm[1] = random_range(3*room_speed, 5*room_speed);

var turret_end_x = lengthdir_x(center_to_turret_end_dist , turret_angle);
var turret_end_y = lengthdir_y(center_to_turret_end_dist , turret_angle);
with(instance_create_layer(x+turret_end_x, y+turret_end_y, layer, oMissile)){
	image_angle = other.turret_angle;
}

// oMissile Create Event
mv_speed = 3;

// oMissile Step Event
//// MOVEMENT
{
	var dx = lengthdir_x(mv_speed, image_angle);
	var dy = lengthdir_y(mv_speed, image_angle);
}
//// DEATH
{
	if(not place_free(x, y)){
		instance_destroy();
	}
}
//// APPLY MOVEMENT
{
	x += dx;
	y += dy;
}

Now our turret can actually shoot!

Heat Seeking

It doesn’t really matter, since the missiles can’t hurt you yet, but you may have noticed that they’re pretty easy to dodge. Let’s fix that by making them angle toward the player as they fly along

I’ve been making you do alot of the driving on this section, and you can probably give this one a try as well, but I think I’ll take the wheel on this one (I’m getting rusty)

I’ll start with a simple approach

// oMissile Create Event
rot_speed = 5;
// oMissile Step Event
//// HEAT SEEKING
{
	var target_angle = point_direction(x, y, oPlayer.x, oPlayer.y);
	if(abs(target_angle-image_angle) < rot_speed){
		image_angle = target_angle;
	}else if(target_angle > image_angle){
		image_angle += rot_speed;
	}else{
		image_angle -= rot_speed;
	}
}
//// MOVEMENT
//// DEATH
//// APPLY MOVEMENT

target_angle: The represents the target or goal for the missile. I couldn’t just done image_angle = target_angle;, but this would have made the missile rotate too quickly, and it would be hard to dodge. Instead we have a target, and the missile will work toward that target over multiple steps

When you test this out it works pretty good 😊

… or at least for the most part 😩

Heat Seeking Edge Case

An example of where we’d hit this issue is if the target_angle is 10, and the image_angle is 350

To the eye to clear shortest path is for image_angle to increase, but the code see that target_angle < image_angle and so it decreases. It’s doesn’t take into account that the angle wraps around and that 360 and 0 are the same place. Luckily game maker has a function called angle_difference() to the rescue. If we test out angle_difference(10, 350) it’s smart enough to figure out the actual shortest distance and it returns 20

// oMissile Step Event
//// HEAT SEEKING
{
	var target_angle = point_direction(x, y, oPlayer.x, oPlayer.y);
	var diff = angle_difference(target_angle, image_angle);
	if(abs(diff) < rot_speed){
		image_angle = target_angle;
	}else if(diff > 0){
		image_angle += rot_speed;
	}else{
		image_angle -= rot_speed;
	}
}
//// MOVEMENT
//// DEATH
//// APPLY MOVEMENT

abs(diff): Hopefully this feels like a naturaly extension of the previous implementation. We used to apply abs() to target_angle-image_angle, which is the error prone way to find the difference, so we just replace that with the angle_difference() output to fix things

diff > 0: This is also a natural extension of the previous code, but it’s a little less obvious. The original version was target_angle > image_angle, but we could write that as target_angle-image_angle > 0 and that’ll still be valid because math (if you subtract the same value from both sides, in this case image_angle, then comparison will still be the same). Now we can see the error prone difference again target_angle-image_angle, so we just replace that with the new diff and we’re done

Can you do this in less than 9 lines of code? It’s kind of bulky isn’t it 🤓. I was trying to think through shorter way, but then I realized that the angle_difference documentation example already has a slick 3 line solution docs. Just be aware that they opted to reverse the order of the angle_difference parameters. I think my ordering is more intuitive, but to each their own I guess

Now we have true edge-caseless heat seeking missiles 🎉🍾