201 lines
4.5 KiB
Lua
201 lines
4.5 KiB
Lua
|
|
|
|
local jumpHeight = 10
|
|
local jumpDist = 20
|
|
local jumpDirs = {
|
|
-- { se-axis, sw-axis, path x-multiplier, path reverse }
|
|
ne = {0, -1, -1, true},
|
|
nw = {-1, 0, 1, true},
|
|
se = {1, 0, 1, false},
|
|
sw = {0, 1, -1, false},
|
|
}
|
|
|
|
--[[
|
|
|
|
Jump equation, assuming y is up the screen and gravity down, chosen so
|
|
that vy and ay are +ve:
|
|
|
|
y = y0 - vy*t + ay*t*t (A)
|
|
x = x0 + vx*t (B)
|
|
|
|
Jump starts at t0, y0 and x0.
|
|
Jump ends at tend, yend and xend.
|
|
Jump peak is at ypeak.
|
|
These are all known.
|
|
|
|
We want to infer vx, ay and vy.
|
|
|
|
We can get vx thus:
|
|
|
|
xend = x0 + vx*tend
|
|
vx = (xend - x0) / tend (C)
|
|
|
|
Next to get ay and vy. For simplicity, let:
|
|
|
|
yend2 = yend - y0
|
|
ypeak2 = ypeak - y0
|
|
|
|
|
|
Using (A) to get vy:
|
|
|
|
y = y0 - vy*t + ay*t*t
|
|
vy*t = y0 - y + ay*t*t
|
|
vy*t = ay*t*t - yend2
|
|
vy = (ay*t*t - yend2)/t
|
|
vy = ay*t - yend2/t (D)
|
|
|
|
Using (D) at time tend:
|
|
|
|
vy = ay*tend - yend2/tend (E)
|
|
|
|
Using (D) at time tpeak:
|
|
|
|
vy = ay*tpeak - ypeak2/tpeak (F)
|
|
|
|
Unfortunately we still don't know tpeak, but we can eliminate it.
|
|
|
|
Knowing that dy/dt = 0 means:
|
|
|
|
dy/dt = -vy + 2*ay*t = 0
|
|
|
|
By definition the time at this point is tpeak, so:
|
|
|
|
vy = 2*ay*tpeak
|
|
tpeak = 0.5*vy/ay
|
|
|
|
So eliminating tpeak in (F):
|
|
|
|
vy = ay*tpeak - ypeak2/tpeak = ay*(0.5*vy/ay) - ypeak2/(0.5*vy/ay)
|
|
vy = 0.5*vy - ypeak2*ay/(0.5*vy)
|
|
vy = 0.5*vy - 2*ypeak2*ay/vy
|
|
2*vy = vy - 4*ypeak2*ay/vy
|
|
4*ypeak2*ay/vy = vy - 2*vy
|
|
4*ypeak2*ay/vy = -vy
|
|
4*ypeak2*ay = -vy^2
|
|
ay = -0.25*vy^2/ypeak2 (G)
|
|
|
|
vy = sqrt(-4*ypeak2*ay)
|
|
vy = 2*sqrt(-ypeak2*ay) (H)
|
|
|
|
Eliminating vy using (H) and (E):
|
|
|
|
vy = 2*sqrt(-ypeak2*ay) = ay*tend - yend2/tend
|
|
-4*ypeak2*ay = (ay*tend - yend2/tend)^2
|
|
-4*ypeak2*ay = ay^2*tend^2 + yend2^2/tend^2 - 2*ay*tend*yend2/tend
|
|
0 = ay^2*tend^2 + yend2^2/tend^2 - 2*ay*yend2 + 4*ypeak2*ay
|
|
0 = ay^2*tend^2 + 4*ypeak2*ay - 2*ay*yend2 + yend2^2/tend^2
|
|
0 = ay^2*tend^2 + ay*(4*ypeak2 - 2*yend2) + yend2^2/tend^2
|
|
|
|
This is a quadratic of the form:
|
|
|
|
0 = a*ay^2 + b*ay + c
|
|
|
|
Using the quadratic solution equation:
|
|
|
|
ay = (-b +/- sqrt(b^2 - 4*a*c)/(2*a)
|
|
|
|
With
|
|
|
|
a = tend^2
|
|
b = 4*ypeak2 - 2*yend2
|
|
c = yend2^2/tend^2
|
|
|
|
Having calculated ay, we can get vy from
|
|
|
|
vy = ay*tend - yend2/tend (E)
|
|
|
|
]]--
|
|
|
|
local function newJumpPath(jumpDist, jumpHeight)
|
|
local steps = 5
|
|
local vx = jumpDist/steps
|
|
|
|
local x0 = 0
|
|
local y0 = 0
|
|
local ypeak = -jumpHeight/2
|
|
local yend = jumpHeight
|
|
local ypeak2 = ypeak - y0
|
|
local yend2 = yend - y0
|
|
local tend = 5
|
|
local a = tend^2
|
|
local b = 4*ypeak2 - 2*yend2
|
|
local c = yend2^2/tend^2
|
|
local ay = 0.5*(-b + math.sqrt(b^2 - 4*a*c))/a
|
|
local vy = ay*tend - yend2/tend
|
|
local path = {}
|
|
-- print(vy, ay) # DEBUG
|
|
for t = 0,tend do
|
|
table.insert(path, {x0 + vx*t,
|
|
y0 - vy*t + ay*t*t})
|
|
end
|
|
--[[ DEBUG
|
|
for i in ipairs(path) do
|
|
print (i, path[i][1], path[i][2])
|
|
end
|
|
]]--
|
|
|
|
return path
|
|
end
|
|
|
|
local frameDuration = 0.1 -- millis
|
|
local function time2frame(time)
|
|
return 1 + math.floor(time / frameDuration)
|
|
end
|
|
|
|
local function jumpDelta(frame, dir, path)
|
|
local _, _, mx, isReverse = unpack(jumpDirs[dir])
|
|
local ox, oy = unpack(path[1]) -- path offset
|
|
if isReverse then -- reverse the path sequence
|
|
frame = 1 + #path - frame
|
|
ox, oy = unpack(path[#path])
|
|
end
|
|
local dx, dy = unpack(path[frame])
|
|
return dx*mx-ox*mx, dy-oy
|
|
end
|
|
|
|
-- constructor
|
|
return function(arena, draw, update)
|
|
assert(arena ~= nil, "arena must not be nil")
|
|
local jumpTime = nil
|
|
local jumpDir = "se"
|
|
local jumpFrame = 1
|
|
local se, sw = 0, 0
|
|
local jumpPath = newJumpPath(arena.getColWidth(), arena.getRowHeight())
|
|
return {
|
|
jump = function(dir)
|
|
if jumpTime ~= nil then
|
|
return -- already jumping
|
|
end
|
|
-- print("jump",dir) -- DEBUG
|
|
if jumpDirs[dir] then -- it's a valid direction
|
|
jumpTime = 0
|
|
jumpDir = dir
|
|
end
|
|
end,
|
|
|
|
draw = function()
|
|
local cx, cy = arena.qpos2Coords(se, sw)
|
|
local dx, dy = jumpDelta(jumpFrame, jumpDir, jumpPath)
|
|
draw(cx+dx, cy+dy, se, sw)
|
|
end,
|
|
|
|
update = function(dt)
|
|
if jumpTime ~= nil then
|
|
jumpTime = jumpTime + dt
|
|
jumpFrame = time2frame(jumpTime)
|
|
if jumpFrame > #jumpPath then
|
|
jumpTime = nil -- finished
|
|
jumpFrame = 1
|
|
|
|
-- update qpos (se, sw)
|
|
local dse, dsw = unpack(jumpDirs[jumpDir])
|
|
-- print("update ", se, sw, dse, dsw) -- DEBUG
|
|
se = se + dse
|
|
sw = sw + dsw
|
|
end
|
|
end
|
|
update(dt, se, sw, jumpTime, jumpFrame, jumpDir)
|
|
end,
|
|
}
|
|
end
|