pico-8 cartridge // http://www.pico-8.com
version 41
__lua__

-- vacuum gambit automatic brake test
-- by kistaro windrider

function usplit(str)
 return unpack(split(str))
end
function csv(s)
 local ret = split(s, "\n")
 for i, v in ipairs(ret) do
  ret[i] = type(v) == "string" and split(v) or { v }
 end
 return ret
end

-- generate standard "overlay"
-- constructor for type tt.
-- if more is defined, generated
-- new calls more(ret) after
-- ret is definitely not nil
-- before calling setmetatable.
-- use to initialize mutables.
--
-- if there was a previous new,
-- it is invoked on the new
-- object *after* more, because
-- this works better with the
-- `more` impls i use.
function mknew(tt, more)
 local mt, oldnew = { __index = tt }, tt.new
 tt.new = function(ret)
  if (not ret) ret = {}
  if (more) more(ret)
  if (oldnew) oldnew(ret)
  setmetatable(ret, mt)
  return ret
 end
end

function _init()
 pal(1,129,1)
 the_ship = ship.new()
 constraints:setup()
 slomo = 1
 sloc = 0
 reroll()
end

function reroll()
 frames=0
 sloc=0
 the_ship:reroll()
end

function _update60()
 if (btnp(4)) reroll()
 if (btnp(5)) constraints:cycle()
 if (btnp(3)) slomo <<= 1
 if (btnp(2)) slomo >>= 1
 slomo = (slomo < 1) and 1 or (slomo > 8192) and 8192 or slomo
 sloc += 1
 if sloc >= slomo then
  frames += 1
  the_ship:update()
  sloc=0
 end
end

function _draw()
 cls(1)
 constraints:draw()
 the_ship:draw()
 print("frames: " .. frames, 4, 64, 7)
 print("speed: 1/" .. slomo, 8, 70, 7)

 print("thrust: ".. actual_t, 4, 80, 7)
 meter(80, 80, 128, 84, actual_t/the_ship.thrust/2)
 print("dx: ".. the_ship.dx, 20, 86, 7)
 meter(80, 86, 128, 90, the_ship.dx/the_ship.maxspd/2)
 print("x: "..the_ship.x, 24, 92, 7)
 print("bx: "..gbx, 20, 98, 7)

 print("xmin:"..tostr(constraints.xmin), 12, 108, 7)
 print("xmax:"..tostr(constraints.xmax), 12, 114, 7)
end

function meter(x0, y0, x1, y1, frac)
 local c = 11
 if frac < 0 then
  frac = -frac
  c = 8
 end
 local range = x1-x0
 local midpoint = x0 + (range/2)
 rectfill(x0, y0-1, x0, y1+1, 13)
 rectfill(midpoint, y0-1, midpoint, y1 + 1, 13)
 local width = range * frac
 if (width ~= 0) rectfill(x0, y0, x0 + width, y1, c)
end

-->8
-- ship

ship = {
 maxspd=4,
 thrust=0.25,
 drag=0.0625,
 y=32,
}
mknew(ship)

function ship:reroll()
 self.x=rnd(128)
 self.dx=rnd(2*self.maxspd)-self.maxspd
end

function ship:draw()
 if self.x < -7 then
  spr(2, 0, self.y-7)
  spr(2, 0, self.y+8)
 elseif self.x > 127 then
  spr(2, 120, self.y-7, 1, 1, true)
  spr(2, 120, self.y+8, 1, 1, true)
 else
  spr(1,self.x,self.y)
 end

 --if (self.dx == 0) return
 local bd, f = brake_dist(self.dx, self.thrust + self.drag)
 gbx = self.x+bd
 spr(3, gbx-2,self.y-2)
 print(tostr(f), gbx-2, self.y - 8, 14)
end

function calc_velocity(v0, t, vmax, drag)
 v0 = mid(v0 + t, vmax, -vmax)
 return v0 - mid(drag, -drag, v0)
end

function ship:update()
 local t = btn(0) and -1 or btn(1) and 1 or 0
 t *= self.thrust
 t = constraints:constrain(self, t)
 -- t = constraints:constrain(self, t)
 -- t = constraints:constrain(self, t)
 local s = calc_velocity(self.dx, t, self.maxspd, self.drag)

 self.x += s
 self.dx = s
 actual_t = t
end

-->8
-- constraints

constraints = {
 ymin=20,
 ymax=52,
 color=10
}

function constraints:constrain(s, want)
 self.color=10
 if (not self.xmin) return want

 -- bmx: brake max
 local v1, bmx = calc_velocity(s.dx, want, s.maxspd, s.drag), s.thrust + s.drag
 local bd, bf = brake_dist(v1, bmx)
 local bx, txm = s.x + bd + v1, self.xmax
 if bx < self.xmin then
  -- predicted brake point left
  -- of xmin; apply max reverse
  -- thrust, treat xmin as our
  -- max target, and handle
  -- overbraking by coalescing
  -- with past +xmax case
  self.color = 9
  want = s.thrust
  txm = self.xmin
  v1 = calc_velocity(s.dx, want, s.maxspd, s.drag)
  bd, bf = brake_dist(v1, bmx)
  bx  = bd + s.x + v1
 end
 if (bx <= txm) return want
 self.color = 8
 local overage = bx - txm
 want -= overage/max(bf,1)
 if (want < -s.thrust) want = -s.thrust
 return want
end

function brake_dist(v0, brake_max)
 local tri_frames = abs(v0\brake_max)
 local chunks = tri_frames * (tri_frames - 1) >> 1
 local chunk_zone = chunks * brake_max
 local overage = abs(v0) - tri_frames * brake_max
 return (chunk_zone + overage * (tri_frames + 1)) * sgn(v0), (overage > 0) and tri_frames + 1 or tri_frames
end

function constraints:cycle()
 if self.ctype=="bounds" then
  self.ctype="point"
 elseif self.ctype=="point" then
  self.ctype="off"
 else
  self.ctype="bounds"
 end
 self:setup()
end

function constraints:setup()
 if self.ctype=="point" then
  self.xmin = 64
  self.xmax = 64
 elseif self.ctype=="bounds" then
  self.xmin = 32
  self.xmax = 96
 else
  self.xmin = nil
  self.xmax = nil
 end
end

function constraints:draw()
 if (not self.xmin) return
 rect(self.xmin, self.ymin, self.xmax, self.ymax, self.color)
end

-->8
-- fx

-- todo: spark ring buffer

__gfx__
000000008000000000080000a000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000006666000080000009090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000067777600800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000675555758008888009090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000006750007508000000a000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000067777500080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000005555000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000