200 lines
5.7 KiB
Lua
200 lines
5.7 KiB
Lua
--Character controller. Renders point particle.
|
|
local love = love
|
|
local marble = {}
|
|
local oldBuffer = love.graphics.newCanvas()
|
|
local newBuffer = love.graphics.newCanvas()
|
|
local oldState, curState, newState
|
|
|
|
local INERTIA = 0.01
|
|
local MAXSPEED = 6
|
|
local ddx, ddy = 0.0, 0.0
|
|
|
|
local function State( )
|
|
return { t = 0, x = 0, y = 0, dx = 0, dy = 0 }
|
|
end
|
|
|
|
function marble.Current() return curState end
|
|
|
|
function marble.Next() return newState end
|
|
|
|
function marble.GetAcceleration( ) return ddx, ddy end
|
|
|
|
function marble.SetAcceleration( x, y ) ddx = x; ddy = y end
|
|
|
|
function marble.Integrate( step )
|
|
newState.t = curState.t + step
|
|
newState.dx = (1.0 - INERTIA) * curState.dx + INERTIA * ddx
|
|
newState.dy = (1.0 - INERTIA) * curState.dy + INERTIA * ddy
|
|
newState.x = curState.x + newState.dx * step * MAXSPEED
|
|
newState.y = curState.y + newState.dy * step * MAXSPEED
|
|
end
|
|
|
|
function marble.OnImpact( impact, level )
|
|
--Adjust current trajectory according to collision.
|
|
if not impact.dt then return end
|
|
|
|
INERTIA = 0.03 - 0.02 * math.sqrt( level / 120.0 )
|
|
MAXSPEED = 2.0 + 4.0 * ( level / 120.0 )
|
|
|
|
local x, y = impact.r * math.cos( impact.th ), impact.r * math.sin( impact.th )
|
|
local vx, vy = newState.dx, newState.dy --Velocity of particle going into collision.
|
|
local unx, uny = math.cos( impact.normal ), math.sin( impact.normal ) --Outward-facing normal of wave.
|
|
local uvx, uvy --Unit vector velocity of particle.
|
|
local speed = math.sqrt( vx * vx + vy * vy )
|
|
if speed < 0.01 then
|
|
--If the marble is motionless, there is no angular velocity wrt 0,
|
|
--so the wave is headed directly inward.
|
|
--We handle the collision as if the marble is headed directly outward.
|
|
uvx, uvy = unx, uny
|
|
vx, vy = uvx, uvy
|
|
else
|
|
uvx, uvy = vx / speed , vy / speed
|
|
end
|
|
|
|
|
|
|
|
--Get signed angle between normal and incoming velocity (both unit vectors)
|
|
local dot = unx * uvy - uny * uvx
|
|
|
|
--Fudge factor: apply an impulse inward so that you don't stick or slide on the wave.
|
|
local inward = ( dot > 0 ) and dot or -dot
|
|
inward = inward * inward * inward
|
|
|
|
--Calculate the rotation matrix:
|
|
--counterclockwise rotation by 2 * pi - 2 * arccos( n dot v )
|
|
local c, s = 1 - 2 * dot * dot, - 2 * dot * math.sqrt( 1 - dot * dot )
|
|
--Apply:
|
|
local vxout, vyout =
|
|
inward * (- math.cos(impact.th) ) - (1.0 - inward) * ( vx * c - vy * s ),
|
|
inward * (- math.sin(impact.th) ) - (1.0 - inward) * ( x * s + vy * c )
|
|
|
|
curState.x, curState.y = x, y
|
|
curState.dx, curState.dy = vxout, vyout
|
|
|
|
--[[debugRenderImpact = { xi = x, yi = y, xf = x - vx, yf = y - vy,
|
|
xn = 0.2 * unx + x, yn = 0.2 * uny + y,
|
|
vxout = x + vxout, vyout = y + vyout}]]
|
|
|
|
return marble.Integrate( 1 / 120.0 ) --Hmm! Maybe this should be a fixed step instead for stability's sake.
|
|
end
|
|
|
|
function marble.Update()
|
|
--Roll the log.
|
|
for k, v in pairs( oldState ) do
|
|
oldState[k] = curState[k]
|
|
curState[k] = newState[k]
|
|
end
|
|
|
|
--Inertia.
|
|
--ddx, ddy = ddx * 0.95, ddy * 0.95
|
|
end
|
|
|
|
|
|
function marble.OnKey( w, a, s, d )
|
|
--print( w, a, s, d )
|
|
ddx = (d and 1.0 or 0.0) - (a and 1.0 or 0.0)
|
|
ddy = (w and 1.0 or 0.0) - (s and 1.0 or 0.0)
|
|
|
|
--print( tick, ddx, ddy )
|
|
local n = math.sqrt( ddx * ddx + ddy * ddy )
|
|
if n < 0.001 then return end
|
|
ddx, ddy = ddx / n, ddy / n
|
|
end
|
|
|
|
function marble.OnVictory()
|
|
|
|
--[[marble.Draw = function()
|
|
|
|
--Extrapolate forward for slightly smoother rendering.
|
|
local dt = love.timer.getTime() - curState.t
|
|
marble.Integrate( dt + 1 / 60.0 )
|
|
|
|
local xp, yp = transform:transformPoint( oldState.x, oldState.y )
|
|
local xc, yc = transform:transformPoint( curState.x, curState.y )
|
|
local xn, yn = transform:transformPoint( newState.x, newState.y )
|
|
|
|
love.graphics.setColor( 91 / 255, 206 / 255, 250 / 255, 1.0 ) --Trans blue.
|
|
love.graphics.setLineJoin( "bevel" )
|
|
love.graphics.setLineStyle( "smooth" )
|
|
love.graphics.setLineWidth( 8.0 )
|
|
love.graphics.line( xp, yp, xc, yc, xn, yn)
|
|
love.graphics.circle( "fill", xn, yn, 4.0 )
|
|
love.graphics.setCanvas()
|
|
|
|
|
|
end]]
|
|
end
|
|
|
|
function marble.Draw()
|
|
|
|
--Extrapolate forward for slightly smoother rendering.
|
|
local dt = love.timer.getTime() - curState.t
|
|
marble.Integrate( 2 / 120.0 )
|
|
|
|
local xp, yp = transform:transformPoint( oldState.x, oldState.y )
|
|
local xc, yc = transform:transformPoint( curState.x, curState.y )
|
|
local xn, yn = transform:transformPoint( newState.x, newState.y )
|
|
|
|
love.graphics.setCanvas( newBuffer )
|
|
love.graphics.setColor( 1.0, 1.0, 1.0 , 0.99 ) -- White.
|
|
love.graphics.draw( oldBuffer ) --Time-dependent fade: overlay canvas over itself.
|
|
|
|
--Render latest segment in trail.
|
|
love.graphics.setColor( 245 / 255, 169 / 255, 184 / 255, 1.0 ) --Trans pink.
|
|
--love.graphics.line( xi, yi, xf, yf )
|
|
--Segment stuff:
|
|
love.graphics.setLineJoin( "bevel" )
|
|
love.graphics.setLineStyle( "smooth" )
|
|
love.graphics.setLineWidth( 8.0 )
|
|
love.graphics.line( xp, yp, xc, yc, xn, yn)
|
|
love.graphics.circle( "fill", xn, yn, 4.0 )
|
|
|
|
love.graphics.setCanvas( oldBuffer )
|
|
love.graphics.clear( 1.0, 1.0, 1.0, 0.0 )
|
|
|
|
--Render circle directly to screen.
|
|
love.graphics.setCanvas()
|
|
love.graphics.draw( newBuffer )
|
|
love.graphics.setColor( 1, 1, 1, 1.0 ) --White.
|
|
love.graphics.setLineWidth( 1.0 )
|
|
--love.graphics.circle( "line", xn, yn, 4 )
|
|
|
|
oldBuffer, newBuffer = newBuffer, oldBuffer
|
|
|
|
end
|
|
|
|
marble._Draw = marble.Draw
|
|
|
|
function marble.Impact( impact )
|
|
|
|
end
|
|
|
|
--Window resize.
|
|
function marble.Resize()
|
|
newBuffer = love.graphics.newCanvas()
|
|
--TODO: render oldBuffer to new newBuffer, but scaled down.
|
|
oldBuffer = love.graphics.newCanvas()
|
|
|
|
|
|
end
|
|
|
|
function marble.Reset()
|
|
|
|
INERTIA = 0.05
|
|
MAXSPEED = 2.0
|
|
|
|
ddx, ddy = 0, 0
|
|
oldState, curState, newState = State(), State(), State()
|
|
marble.Resize()
|
|
marble.Draw = marble._Draw
|
|
end
|
|
|
|
function marble.Canvas()
|
|
return newBuffer
|
|
end
|
|
|
|
|
|
|
|
marble.Reset()
|
|
|
|
return marble |