2D Space Shooter Part 5: Firing

Last chapter was quick, this one will be longer. We will now deal with weapons!

Cannons

Remember how we defined cannons in our Ship class ? It is now time to implement them. A cannon is basically something that will throw bullets repeatedly. Create a new file named 'cannon.lua' and paste the following code:

Cannon=Core.class(Object)

function Cannon:init(def,scale,ship)
	self.x=def.x*scale
	self.y=def.y*scale
	self.type=def.type
	self.rate=def.rate
	self.angle=def.angle or 0
	self.ship=ship
	self.reload=0
end

function Cannon:fire()
	if self.reload==0 then
		local x,y=self.ship:localToGlobal(self.x,self.y)
		local bullet=Bullet.new(self.type,self.angle+self.ship:getRotation(),x,y)
		bullet.friendly=self.ship.friendly
		self.reload=self.rate
	else
		self.reload-=1
	end
end

The Cannon class isn't a Sprite, but a basic Object. In the 'init' method, we mostly copy the cannon definition locally and initialize our reload counter that will be used to count time between each shot. We also compute the ship-relative position of the cannon.

In the 'fire' method, we decrement the reload counter until it reaches 0. When at 0, we create a Bullet and reset our reload counter to the cannon rate value.

Bullets

The Bullet class needs more work: it will be a graphic object (inherited from Pixel), but will also have to check collisions. Here is the Bullet code, to copy into a bullet.lua file:

local BULLETS_DEF={
laser={ file="laser.png", speed=5, damage=1 },
missile={ file="rocket.png", speed=1, damage=10 },
}

Bullet=Core.class(Pixel,function (type) end)

function Bullet:init(type,angle,x,y)
	local bullet_def=BULLETS_DEF[type]
	assert(bullet_def,"No such bullet type: "..type)
	local texture=Texture.new("gfx/"..bullet_def.file,true)
	local tw,th=texture:getWidth(),texture:getHeight()
	local scale=0.3
	self:setTexture(texture)
	self:setDimensions(tw*scale,th*scale)
	self.damage=bullet_def.damage
	self.speed=bullet_def.speed
	self:setAnchorPoint(0.5,0.5)
	self:setRotation(angle)
	self:setPosition(x,y)
	local ax,ay=self:getAnchorPosition()
	self.dx,self.dy=math.sin(^<angle),math.cos(^<angle)
	BULLETS:addChild(self)
	-- Add to actors list
	ACTORS[self]=true
	-- Add to collision world
	BUMP_WORLD:add(self,x-ax,y-ay,tw*scale,th*scale)
end

function Bullet:destroy()
	-- Remove from collision world
	BUMP_WORLD:remove(self)
	-- Remove from actors list
	ACTORS[self]=nil
	-- Remove from screen
	self:removeFromParent()
end

-- This function will check collisions between this bullet (item) and some other object (other)
local function collision_filter(item,other)
	-- Other can be a Ship or another Bullet
	-- If it has a property named 'damage' then it is a Bullet, and we don't want bullets to collide with each others
	if other.damage then return nil end
	-- We also want to avoid being killed by our own shots, or enemies killing each others
	if item.friendly==other.friendly then return nil end
	-- Now we have a Bullet colliding with an enemy ship
	return 'touch'
end

function Bullet:tick(delay)
	local x,y=self:getPosition()
	x+=self.dx*self.speed
	y-=self.dy*self.speed
	self:setPosition(x,y)
	local cols,colslen
	x,y,cols,colslen=BUMP_WORLD:move(self,x,y,collision_filter)
	for k,col in pairs(cols) do
		col.other:hit(self.damage)
	end
	if x<SCR_LEFT or x>SCR_RIGHT or y<SCR_TOP or y>SCR_BOTTOM or colslen>0 then
		self:destroy()
	end
end

We borrowed a lot of code from the Ship class: the setting up of the sprite itself is very similar, and the bullet is being added and removed from collision world and actors in the same way.

There are two major changes:

• The bullet will move by itself.

For that we precomputed its movement direction from its angle with a little bit of help from trigonometry (sin/cos) in 'Bullet:init', and we use that direction (self.dx,self.dy) and the bullet speed in 'Bullet:tick' to increment the bullet position.

• The collision detection

Once we have computed the new bullet position, we pass it to bump engine and check for eventual collisions. If something is hit, we call its 'hit' method and give it the amount of damage the bullet should cause.

We don't want the bullet to collide with other bullets, and we don't want either a bullet to hit the ship type that fired it. To tell this to bump engine, we use a collision filter function. The filter function returns nil (or false) if objects don't collide. Otherwise it returns a collision type, which is, in our case 'touch'.

Testing

Now that our cannons and bullets are defined, we can uncomment the Cannon instancing in ships.lua, 'init' method:

		self.cannons[k]=Cannon.new(cdef,scale,self)

We'll also need to place the weapons graphics in gfx folder.

Now your ship will fire when you hold the mouse button down:

2D Space Shooter Part 6: Enemies