370 lines
15 KiB
Lua
370 lines
15 KiB
Lua
|
--[[
|
||
|
|
MIT License
|
||
|
|
|
||
|
|
Copyright (c) 2017 SSYGEN
|
||
|
|
|
||
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
|
|
of this software and associated documentation files (the "Software"), to deal
|
||
|
|
in the Software without restriction, including without limitation the rights
|
||
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
|
copies of the Software, and to permit persons to whom the Software is
|
||
|
|
furnished to do so, subject to the following conditions:
|
||
|
|
|
||
|
|
The above copyright notice and this permission notice shall be included in all
|
||
|
|
copies or substantial portions of the Software.
|
||
|
|
|
||
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
|
|
SOFTWARE.
|
||
|
|
]]--
|
||
|
|
|
||
|
|
local function lerp(a, b, x) return a + (b - a)*x end
|
||
|
|
local function csnap(v, x) return math.ceil(v/x)*x - x/2 end
|
||
|
|
|
||
|
|
-- Shake according to https://jonny.morrill.me/en/blog/gamedev-how-to-implement-a-camera-shake-effect/
|
||
|
|
local function newShake(amplitude, duration, frequency)
|
||
|
|
local self = {
|
||
|
|
amplitude = amplitude or 0,
|
||
|
|
duration = duration or 0,
|
||
|
|
frequency = frequency or 60,
|
||
|
|
samples = {},
|
||
|
|
start_time = love.timer.getTime()*1000,
|
||
|
|
t = 0,
|
||
|
|
shaking = true,
|
||
|
|
}
|
||
|
|
|
||
|
|
local sample_count = (self.duration/1000)*self.frequency
|
||
|
|
for i = 1, sample_count do self.samples[i] = 2*love.math.random()-1 end
|
||
|
|
|
||
|
|
return self
|
||
|
|
end
|
||
|
|
|
||
|
|
local function updateShake(self, dt)
|
||
|
|
self.t = love.timer.getTime()*1000 - self.start_time
|
||
|
|
if self.t > self.duration then self.shaking = false end
|
||
|
|
end
|
||
|
|
|
||
|
|
local function shakeNoise(self, s)
|
||
|
|
if s >= #self.samples then return 0 end
|
||
|
|
return self.samples[s] or 0
|
||
|
|
end
|
||
|
|
|
||
|
|
local function shakeDecay(self, t)
|
||
|
|
if t > self.duration then return 0 end
|
||
|
|
return (self.duration - t)/self.duration
|
||
|
|
end
|
||
|
|
|
||
|
|
local function getShakeAmplitude(self, t)
|
||
|
|
if not t then
|
||
|
|
if not self.shaking then return 0 end
|
||
|
|
t = self.t
|
||
|
|
end
|
||
|
|
|
||
|
|
local s = (t/1000)*self.frequency
|
||
|
|
local s0 = math.floor(s)
|
||
|
|
local s1 = s0 + 1
|
||
|
|
local k = shakeDecay(self, t)
|
||
|
|
return self.amplitude*(shakeNoise(self, s0) + (s - s0)*(shakeNoise(self, s1) - shakeNoise(self, s0)))*k
|
||
|
|
end
|
||
|
|
|
||
|
|
-- Camera
|
||
|
|
local Camera = {}
|
||
|
|
Camera.__index = Camera
|
||
|
|
|
||
|
|
local function new(x, y, w, h, scale, rotation)
|
||
|
|
return setmetatable({
|
||
|
|
x = x or (w or love.graphics.getWidth())/2, y = y or (h or love.graphics.getHeight())/2,
|
||
|
|
mx = x or (w or love.graphics.getWidth())/2, my = y or (h or love.graphics.getHeight())/2,
|
||
|
|
screen_x = x or (w or love.graphics.getWidth())/2, screen_y = y or (h or love.graphics.getHeight())/2,
|
||
|
|
w = w or love.graphics.getWidth(), h = h or love.graphics.getHeight(),
|
||
|
|
scale = scale or 1,
|
||
|
|
rotation = rotation or 0,
|
||
|
|
horizontal_shakes = {}, vertical_shakes = {},
|
||
|
|
target_x = nil, target_y = nil,
|
||
|
|
scroll_x = 0, scroll_y = 0,
|
||
|
|
last_target_x = nil, last_target_y = nil,
|
||
|
|
follow_lerp_x = 1, follow_lerp_y = 1,
|
||
|
|
follow_lead_x = 0, follow_lead_y = 0,
|
||
|
|
deadzone = nil, bound = nil,
|
||
|
|
draw_deadzone = false,
|
||
|
|
flash_duration = 1, flash_timer = 0, flash_color = {0, 0, 0, 1},
|
||
|
|
last_horizontal_shake_amount = 0, last_vertical_shake_amount = 0,
|
||
|
|
fade_duration = 1, fade_timer = 0, fade_color = {0, 0, 0, 0},
|
||
|
|
}, Camera)
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:attach()
|
||
|
|
love.graphics.push()
|
||
|
|
love.graphics.translate(self.w/2, self.h/2)
|
||
|
|
love.graphics.scale(self.scale)
|
||
|
|
love.graphics.rotate(self.rotation)
|
||
|
|
love.graphics.translate(-self.x, -self.y)
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:detach()
|
||
|
|
love.graphics.pop()
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:move(dx, dy)
|
||
|
|
self.x, self.y = self.x + dx, self.y + dy
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:toWorldCoords(x, y)
|
||
|
|
local c, s = math.cos(self.rotation), math.sin(self.rotation)
|
||
|
|
x, y = (x - self.w/2)/self.scale, (y - self.h/2)/self.scale
|
||
|
|
x, y = c*x - s*y, s*x + c*y
|
||
|
|
return x + self.x, y + self.y
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:toCameraCoords(x, y)
|
||
|
|
local c, s = math.cos(self.rotation), math.sin(self.rotation)
|
||
|
|
x, y = x - self.x, y - self.y
|
||
|
|
x, y = c*x - s*y, s*x + c*y
|
||
|
|
return x*self.scale + self.w/2, y*self.scale + self.h/2
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:getMousePosition()
|
||
|
|
return self:toWorldCoords(love.mouse.getPosition())
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:shake(intensity, duration, frequency, axes)
|
||
|
|
if not axes then axes = 'XY' end
|
||
|
|
axes = string.upper(axes)
|
||
|
|
|
||
|
|
if string.find(axes, 'X') then table.insert(self.horizontal_shakes, newShake(intensity, duration*1000, frequency)) end
|
||
|
|
if string.find(axes, 'Y') then table.insert(self.vertical_shakes, newShake(intensity, duration*1000, frequency)) end
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:update(dt)
|
||
|
|
self.mx, self.my = self:toWorldCoords(love.mouse.getPosition())
|
||
|
|
|
||
|
|
-- Flash --
|
||
|
|
if self.flashing then
|
||
|
|
self.flash_timer = self.flash_timer + dt
|
||
|
|
if self.flash_timer > self.flash_duration then
|
||
|
|
self.flash_timer = 0
|
||
|
|
self.flashing = false
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
-- Fade --
|
||
|
|
if self.fading then
|
||
|
|
self.fade_timer = self.fade_timer + dt
|
||
|
|
self.fade_color = {
|
||
|
|
lerp(self.base_fade_color[1], self.target_fade_color[1], self.fade_timer/self.fade_duration),
|
||
|
|
lerp(self.base_fade_color[2], self.target_fade_color[2], self.fade_timer/self.fade_duration),
|
||
|
|
lerp(self.base_fade_color[3], self.target_fade_color[3], self.fade_timer/self.fade_duration),
|
||
|
|
lerp(self.base_fade_color[4], self.target_fade_color[4], self.fade_timer/self.fade_duration),
|
||
|
|
}
|
||
|
|
if self.fade_timer > self.fade_duration then
|
||
|
|
self.fade_timer = 0
|
||
|
|
self.fading = false
|
||
|
|
if self.fade_action then self.fade_action() end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
-- Shake --
|
||
|
|
local horizontal_shake_amount, vertical_shake_amount = 0, 0
|
||
|
|
for i = #self.horizontal_shakes, 1, -1 do
|
||
|
|
updateShake(self.horizontal_shakes[i], dt)
|
||
|
|
horizontal_shake_amount = horizontal_shake_amount + getShakeAmplitude(self.horizontal_shakes[i])
|
||
|
|
if not self.horizontal_shakes[i].shaking then table.remove(self.horizontal_shakes, i) end
|
||
|
|
end
|
||
|
|
for i = #self.vertical_shakes, 1, -1 do
|
||
|
|
updateShake(self.vertical_shakes[i], dt)
|
||
|
|
vertical_shake_amount = vertical_shake_amount + getShakeAmplitude(self.vertical_shakes[i])
|
||
|
|
if not self.vertical_shakes[i].shaking then table.remove(self.vertical_shakes, i) end
|
||
|
|
end
|
||
|
|
self.x, self.y = self.x - self.last_horizontal_shake_amount, self.y - self.last_vertical_shake_amount
|
||
|
|
self:move(horizontal_shake_amount, vertical_shake_amount)
|
||
|
|
self.last_horizontal_shake_amount, self.last_vertical_shake_amount = horizontal_shake_amount, vertical_shake_amount
|
||
|
|
|
||
|
|
-- Follow --
|
||
|
|
if not self.target_x and not self.target_y then return end
|
||
|
|
|
||
|
|
-- Set follow style deadzones
|
||
|
|
if self.follow_style == 'LOCKON' then
|
||
|
|
local w, h = self.w/16, self.w/16
|
||
|
|
self:setDeadzone((self.w - w)/2, (self.h - h)/2, w, h)
|
||
|
|
|
||
|
|
elseif self.follow_style == 'PLATFORMER' then
|
||
|
|
local w, h = self.w/8, self.h/3
|
||
|
|
self:setDeadzone((self.w - w)/2, (self.h - h)/2 - h*0.25, w, h)
|
||
|
|
|
||
|
|
elseif self.follow_style == 'TOPDOWN' then
|
||
|
|
local s = math.max(self.w, self.h)/4
|
||
|
|
self:setDeadzone((self.w - s)/2, (self.h - s)/2, s, s)
|
||
|
|
|
||
|
|
elseif self.follow_style == 'TOPDOWN_TIGHT' then
|
||
|
|
local s = math.max(self.w, self.h)/8
|
||
|
|
self:setDeadzone((self.w - s)/2, (self.h - s)/2, s, s)
|
||
|
|
|
||
|
|
elseif self.follow_style == 'SCREEN_BY_SCREEN' then
|
||
|
|
self:setDeadzone(0, 0, 0, 0)
|
||
|
|
|
||
|
|
elseif self.follow_style == 'NO_DEADZONE' then
|
||
|
|
self.deadzone = nil
|
||
|
|
end
|
||
|
|
|
||
|
|
-- No deadzone means we just track the target with no lerp
|
||
|
|
if not self.deadzone then
|
||
|
|
self.x, self.y = self.target_x, self.target_y
|
||
|
|
if self.bound then
|
||
|
|
self.x = math.min(math.max(self.x, self.bounds_min_x + self.w/2), self.bounds_max_x - self.w/2)
|
||
|
|
self.y = math.min(math.max(self.y, self.bounds_min_y + self.h/2), self.bounds_max_y - self.h/2)
|
||
|
|
end
|
||
|
|
return
|
||
|
|
end
|
||
|
|
|
||
|
|
-- Convert appropriate variables to camera coordinates since the deadzone is applied in terms of the camera and not the world
|
||
|
|
local dx1, dy1, dx2, dy2 = self.deadzone_x, self.deadzone_y, self.deadzone_x + self.deadzone_w, self.deadzone_y + self.deadzone_h
|
||
|
|
local scroll_x, scroll_y = 0, 0
|
||
|
|
local target_x, target_y = self:toCameraCoords(self.target_x, self.target_y)
|
||
|
|
local x, y = self:toCameraCoords(self.x, self.y)
|
||
|
|
|
||
|
|
-- Screen by screen follow mode needs to be handled a bit differently
|
||
|
|
if self.follow_style == 'SCREEN_BY_SCREEN' then
|
||
|
|
-- Don't change self.screen_x/y if already at the boundaries
|
||
|
|
if self.bound then
|
||
|
|
if self.x > self.bounds_min_x + self.w/2 and target_x < 0 then self.screen_x = csnap(self.screen_x - self.w/self.scale, self.w/self.scale) end
|
||
|
|
if self.x < self.bounds_max_x - self.w/2 and target_x >= self.w then self.screen_x = csnap(self.screen_x + self.w/self.scale, self.w/self.scale) end
|
||
|
|
if self.y > self.bounds_min_y + self.h/2 and target_y < 0 then self.screen_y = csnap(self.screen_y - self.h/self.scale, self.h/self.scale) end
|
||
|
|
if self.y < self.bounds_max_y - self.h/2 and target_y >= self.h then self.screen_y = csnap(self.screen_y + self.h/self.scale, self.h/self.scale) end
|
||
|
|
-- Move to the next screen if the target is outside the screen boundaries
|
||
|
|
else
|
||
|
|
if target_x < 0 then self.screen_x = csnap(self.screen_x - self.w/self.scale, self.w/self.scale) end
|
||
|
|
if target_x >= self.w then self.screen_x = csnap(self.screen_x + self.w/self.scale, self.w/self.scale) end
|
||
|
|
if target_y < 0 then self.screen_y = csnap(self.screen_y - self.h/self.scale, self.h/self.scale) end
|
||
|
|
if target_y >= self.h then self.screen_y = csnap(self.screen_y + self.h/self.scale, self.h/self.scale) end
|
||
|
|
end
|
||
|
|
self.x = lerp(self.x, self.screen_x, self.follow_lerp_x)
|
||
|
|
self.y = lerp(self.y, self.screen_y, self.follow_lerp_y)
|
||
|
|
|
||
|
|
-- Apply bounds
|
||
|
|
if self.bound then
|
||
|
|
self.x = math.min(math.max(self.x, self.bounds_min_x + self.w/2), self.bounds_max_x - self.w/2)
|
||
|
|
self.y = math.min(math.max(self.y, self.bounds_min_y + self.h/2), self.bounds_max_y - self.h/2)
|
||
|
|
end
|
||
|
|
|
||
|
|
-- All other follow modes
|
||
|
|
else
|
||
|
|
-- Figure out how much the camera needs to scroll
|
||
|
|
if target_x < x + (dx1 + dx2 - x) then
|
||
|
|
local d = target_x - dx1
|
||
|
|
if d < 0 then scroll_x = d end
|
||
|
|
end
|
||
|
|
if target_x > x - (dx1 + dx2 - x) then
|
||
|
|
local d = target_x - dx2
|
||
|
|
if d > 0 then scroll_x = d end
|
||
|
|
end
|
||
|
|
if target_y < y + (dy1 + dy2 - y) then
|
||
|
|
local d = target_y - dy1
|
||
|
|
if d < 0 then scroll_y = d end
|
||
|
|
end
|
||
|
|
if target_y > y - (dy1 + dy2 - y) then
|
||
|
|
local d = target_y - dy2
|
||
|
|
if d > 0 then scroll_y = d end
|
||
|
|
end
|
||
|
|
|
||
|
|
-- Apply lead
|
||
|
|
if not self.last_target_x and not self.last_target_y then self.last_target_x, self.last_target_y = self.target_x, self.target_y end
|
||
|
|
scroll_x = scroll_x + (self.target_x - self.last_target_x)*self.follow_lead_x
|
||
|
|
scroll_y = scroll_y + (self.target_y - self.last_target_y)*self.follow_lead_y
|
||
|
|
self.last_target_x, self.last_target_y = self.target_x, self.target_y
|
||
|
|
|
||
|
|
-- Scroll towards target with lerp
|
||
|
|
self.x = lerp(self.x, self.x + scroll_x, self.follow_lerp_x)
|
||
|
|
self.y = lerp(self.y, self.y + scroll_y, self.follow_lerp_y)
|
||
|
|
|
||
|
|
-- Apply bounds
|
||
|
|
if self.bound then
|
||
|
|
self.x = math.min(math.max(self.x, self.bounds_min_x + self.w/2), self.bounds_max_x - self.w/2)
|
||
|
|
self.y = math.min(math.max(self.y, self.bounds_min_y + self.h/2), self.bounds_max_y - self.h/2)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:draw()
|
||
|
|
if self.draw_deadzone and self.deadzone then
|
||
|
|
local n = love.graphics.getLineWidth()
|
||
|
|
love.graphics.setLineWidth(2)
|
||
|
|
love.graphics.line(self.deadzone_x - 1, self.deadzone_y, self.deadzone_x + 6, self.deadzone_y)
|
||
|
|
love.graphics.line(self.deadzone_x, self.deadzone_y, self.deadzone_x, self.deadzone_y + 6)
|
||
|
|
love.graphics.line(self.deadzone_x - 1, self.deadzone_y + self.deadzone_h, self.deadzone_x + 6, self.deadzone_y + self.deadzone_h)
|
||
|
|
love.graphics.line(self.deadzone_x, self.deadzone_y + self.deadzone_h, self.deadzone_x, self.deadzone_y + self.deadzone_h - 6)
|
||
|
|
love.graphics.line(self.deadzone_x + self.deadzone_w + 1, self.deadzone_y + self.deadzone_h, self.deadzone_x + self.deadzone_w - 6, self.deadzone_y + self.deadzone_h)
|
||
|
|
love.graphics.line(self.deadzone_x + self.deadzone_w, self.deadzone_y + self.deadzone_h, self.deadzone_x + self.deadzone_w, self.deadzone_y + self.deadzone_h - 6)
|
||
|
|
love.graphics.line(self.deadzone_x + self.deadzone_w + 1, self.deadzone_y, self.deadzone_x + self.deadzone_w - 6, self.deadzone_y)
|
||
|
|
love.graphics.line(self.deadzone_x + self.deadzone_w, self.deadzone_y, self.deadzone_x + self.deadzone_w, self.deadzone_y + 6)
|
||
|
|
love.graphics.setLineWidth(n)
|
||
|
|
end
|
||
|
|
|
||
|
|
if self.flashing then
|
||
|
|
local r, g, b, a = love.graphics.getColor()
|
||
|
|
love.graphics.setColor(self.flash_color)
|
||
|
|
love.graphics.rectangle('fill', 0, 0, self.w, self.h)
|
||
|
|
love.graphics.setColor(r, g, b, a)
|
||
|
|
end
|
||
|
|
|
||
|
|
local r, g, b, a = love.graphics.getColor()
|
||
|
|
love.graphics.setColor(self.fade_color)
|
||
|
|
love.graphics.rectangle('fill', 0, 0, self.w, self.h)
|
||
|
|
love.graphics.setColor(r, g, b, a)
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:follow(x, y)
|
||
|
|
self.target_x, self.target_y = x, y
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:setDeadzone(x, y, w, h)
|
||
|
|
self.deadzone = true
|
||
|
|
self.deadzone_x = x
|
||
|
|
self.deadzone_y = y
|
||
|
|
self.deadzone_w = w
|
||
|
|
self.deadzone_h = h
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:setBounds(x, y, w, h)
|
||
|
|
self.bound = true
|
||
|
|
self.bounds_min_x = x
|
||
|
|
self.bounds_min_y = y
|
||
|
|
self.bounds_max_x = x + w
|
||
|
|
self.bounds_max_y = y + h
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:setFollowStyle(follow_style)
|
||
|
|
self.follow_style = follow_style
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:setFollowLerp(x, y)
|
||
|
|
self.follow_lerp_x = x
|
||
|
|
self.follow_lerp_y = y or x
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:setFollowLead(x, y)
|
||
|
|
self.follow_lead_x = x
|
||
|
|
self.follow_lead_y = y or x
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:flash(duration, color)
|
||
|
|
self.flash_duration = duration
|
||
|
|
self.flash_color = color or self.flash_color
|
||
|
|
self.flash_timer = 0
|
||
|
|
self.flashing = true
|
||
|
|
end
|
||
|
|
|
||
|
|
function Camera:fade(duration, color, action)
|
||
|
|
self.fade_duration = duration
|
||
|
|
self.base_fade_color = self.fade_color
|
||
|
|
self.target_fade_color = color
|
||
|
|
self.fade_timer = 0
|
||
|
|
self.fade_action = action
|
||
|
|
self.fading = true
|
||
|
|
end
|
||
|
|
|
||
|
|
return setmetatable({new = new}, {__call = function(_, ...) return new(...) end})
|