Difference between revisions of "2D Space Shooter Part 5: Firing"
Line 8: | Line 8: | ||
function Cannon:init(def,scale,ship) | function Cannon:init(def,scale,ship) | ||
− | + | self.x=def.x*scale | |
− | self.x=def.x*scale | + | self.y=def.y*scale |
− | self.y=def.y*scale | ||
self.type=def.type | self.type=def.type | ||
self.rate=def.rate | self.rate=def.rate | ||
Line 20: | Line 19: | ||
function Cannon:fire() | function Cannon:fire() | ||
if self.reload==0 then | if self.reload==0 then | ||
− | local x,y=self.ship: | + | local x,y=self.ship:localToGlobal(self.x,self.y) |
− | |||
− | |||
local bullet=Bullet.new(self.type,self.angle+self.ship:getRotation(),x,y) | local bullet=Bullet.new(self.type,self.angle+self.ship:getRotation(),x,y) | ||
bullet.friendly=self.ship.friendly | bullet.friendly=self.ship.friendly |
Revision as of 15:06, 3 January 2020
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: