conf.lua

function love.conf(t)
  t.screen.width = 400
  t.screen.height = 700
end

hexagon.lua

Hexagon = {}

function Hexagon:new(height)
  local obj = {}
  setmetatable(obj, self)
  self.__index = self

  obj.height = height
  obj:generate_points()

  return obj
end

function Hexagon:generate_points()
  local h = self
  h.l  = (h.height / 2) / math.sin(45)
  h.dX = math.cos(45) * h.l
  h.dY = math.sin(45) * h.l
  h.cX = h.dX + (h.l / 2)
  h.cY = h.dY
  h.width = h.dX * 2 + h.l
  h.vertices = {
      0,                 h.dY
    , h.dX,              0
    , h.dX + h.l,        0
    , h.dX + h.l + h.dX, h.dY
    , h.dX + h.l,        h.dY + h.dY
    , h.dX,              h.dY + h.dY
  }

  local temp = {}
  local n
  for i, v in ipairs(h.vertices) do
    if i % 2 == 1 then
      n = v - h.cX
    else
      n = v - h.cY
    end
    table.insert(temp, n)
  end
  h.vertices = temp
end

function Hexagon:draw(r, g, b, a)
  local h = self

  love.graphics.setColor(r, g, b, a)
  love.graphics.polygon('line', h.vertices)
end

main.lua

require("player")
require("scrolling_bg")

function love.load()
  player = Player:new()
  background = ScrollingBG:new()
end

function love.update(dt)
  player:update(dt)
  background:update(dt)
end

function love.draw()
  love.graphics.setCaption(tostring(love.timer.getFPS()) .. "FPS")

  love.graphics.push()

  if player.movementLock then
    player:translateCollisionShake()
  end

  player:draw()
  background:draw()

  love.graphics.pop()
end

math_helpers.lua

function math.copysign(v)
  return (v < 0 and -1 or 1)
end

player.lua

require("hexagon")
require("math_helpers")

Player = {}

function Player:new()
  local obj = {}
  setmetatable(obj, self)
  self.__index = self

  obj:init()
  
  return obj
end

function Player:init()
  local p = self
  p.x = love.graphics.getWidth() / 2
  p.y = love.graphics.getHeight() - 100
  p.speedX = 200
  p.speedY = 200
  p.velX = 0
  p.velY = 0

  p.hexagon    = Hexagon:new(20)
  local boxImg = love.graphics.newImage("box.png")
  p.exhaust    = love.graphics.newParticleSystem(boxImg, 40)
  p.exhaust:setSizes(2, 1)
  p.exhaust:setColors(51, 153, 255, 255, 68, 161, 255, 255, 119, 187, 255, 255)
  p.exhaust:setLifetime(-1)
  p.exhaust:setParticleLife(0.5)
  p:exhaustFloatingDefault()
  p.exhaust:start()
end

function Player:exhaustFloatingDefault()
  local p = self
  p.exhaust:setEmissionRate(2)
  p.exhaust:setSpeed(50)
  p.exhaust:setDirection(math.pi / 2)
  p.exhaust:setSpread(math.pi / 6)
end

function Player:checkMovementKeys()
  local p = self

  if p.movementLock then return end

  if love.keyboard.isDown("up") then
    p.velY = -p.speedY
  elseif love.keyboard.isDown("down") then
    p.velY = p.speedY
  else
    p.velY = 0
  end

  if love.keyboard.isDown("left") then
    p.velX = -p.speedX
  elseif love.keyboard.isDown("right") then
    p.velX = p.speedX
  else
    p.velX = 0
  end
end

function Player:translateCollisionShake()
  local p = self
  love.graphics.translate(p.shakeVelocity * math.sin(p.shakeTime * 10), p.shakeVelocity * math.cos(p.shakeTime * 10))
end

function Player:update(dt)
  local p = self

  p:checkMovementKeys()

  if p.movementLock then
    p.exhaust:setSpread(math.pi * 2)
    if p.shakeVelocity < 2 then
      p.movementLock = false
      p:exhaustFloatingDefault()
    end

    p.shakeTime = p.shakeTime + dt
    p.shakeVelocity = p.shakeVelocity * math.pow(0.02, dt)
    p.velX = p.velX  * math.pow(0.10, dt)
    p.x = p.x + (p.velX * dt)
  elseif p.velX ~= 0 or p.velY ~= 0 then
    p.x = p.x + (p.velX * dt)
    p.y = p.y + (p.velY * dt)

    if p.x <= 25 or p.x >= love.graphics.getWidth() - 25 then
      p.movementLock = true
      p.shakeVelocity = 20
      p.shakeTime = 0
      p.velX = p.x <= 25 and p.speedX or -p.speedX
      p.velY = 0
    end

    p.y = math.max(0, math.min(love.graphics.getHeight(), p.y))

    p.exhaust:setEmissionRate(15)
    p.exhaust:setSpeed(100, 300)
    p.exhaust:setDirection(-(math.atan2(p.velX, p.velY) + math.pi / 2))
  else
    p:exhaustFloatingDefault()
  end

  p.exhaust:update(dt)
end

function Player:getParticleCoords()
  local p = self
  local h = p.hexagon
  local hX = (h.l / 2) + (h.dX / 2)
  local hY = h.dY / 2
  local x, y = 0, 0

  if p.velX ~= 0 and p.velY ~= 0 then
    x = hX * -math.copysign(p.velX)
    y = hY * -math.copysign(p.velY)
  elseif p.velX ~= 0 then
    x = h.dX * -math.copysign(p.velX)
  elseif p.velY ~= 0 then
    y = h.dY * -math.copysign(p.velY)
  else
    y = h.dY
  end

  return x, y
end

function Player:draw()
  local p = self

  love.graphics.push()
  love.graphics.translate(p.x, p.y)
  love.graphics.point(0, 0)
  love.graphics.setLineWidth(2)
  p.hexagon:draw(51, 153, 255, 255)
  love.graphics.draw(p.exhaust, p:getParticleCoords())
  love.graphics.pop()
end

scrolling_bg.lua

require("hexagon")

ScrollingBG = {}

function ScrollingBG:new()
  local obj = {}
  setmetatable(obj, self)
  self.__index = self

  obj:init()

  return obj
end

function ScrollingBG:init()
  local bg = self

  bg.speed       = 350
  bg.hexHeight   = 30
  bg.refHexagon  = Hexagon:new(bg.hexHeight)
  bg.leftX       = bg.refHexagon.width / -2
  bg.rightX      = love.graphics.getWidth()
  bg.offset      = 0
  bg.numHexagons = love.graphics.getHeight() / bg.hexHeight + 1
  bg.wrapY       = math.ceil(love.graphics.getHeight() / bg.hexHeight) * bg.hexHeight
end

function ScrollingBG:update(dt)
  local bg = self

  bg.offset = bg.offset + (bg.speed * dt)
  if bg.offset > love.graphics.getHeight() then
    bg.offset = bg.offset - love.graphics.getHeight()
  end
end

function ScrollingBG:draw()
  local bg = self

  local r, g, b, a
  if player.movementLock then
    r, g, b, a = 255, 50, 50, 120
  else
    r, g, b, a = 51, 153, 255, 255
  end

  love.graphics.setLineWidth(1)
  for i = 0, bg.numHexagons do
    love.graphics.push()
    love.graphics.translate(0, ((bg.offset + i * bg.hexHeight) % bg.wrapY) - bg.refHexagon.dY)
    bg.refHexagon:draw(r, g, b, a)
    love.graphics.translate(bg.rightX, 0)
    bg.refHexagon:draw(r, g, b, a)
    love.graphics.pop()
  end
end