pico-8 cartridge // http://www.pico-8.com
version 42
__lua__
bx0=0
by0=0
bx1=127
by1=127
lx0=0
ly0=0
lx1=127
ly1=127

-->8

function collides()
	local tmin,tmax=0,1
	
	local ldx,ldy=lx1-lx0,ly1-ly0
	
	
	-- x
	if ldx==0 then
		if (lx0<bx0 or lx0>bx1) return
	else
 	local tx0=(bx0-lx0)/ldx
 	local tx1=(bx1-lx0)/ldx
 	if (tx0 > tx1) tx0,tx1=tx1,tx0
 	if (tmin < tx0) tmin=tx0
 	if (tmax > tx1) tmax=tx1
 end
 
	if ldy==0 then
		if (ly0<by0 or ly0>by1) return
	else
 	local ty0=(by0-ly0)/ldy
 	local ty1=(by1-ly0)/ldy
 	if (ty0 > ty1) ty0,ty1=ty1,ty0
 	if (tmin < ty0) tmin=ty0
 	if (tmax > ty1) tmax=ty1
 end 
 
 if (tmax < tmin) return
 return tmin,tmax
end


-->8
function _init()
	poke(0x5f2d,1) -- enable mouse
end

function _bounce_screen(x)
 return _bounce(x*128,128)
end
function _bounce(x,mx)
	x=x%(mx * 2)
	if (x>=mx)return mx-(x-mx)
	return x
end

function _to_halfopen(x0,x1)
 -- turn two numbers into a
 -- half-open integer range
 x0=flr(x0)
 x1=flr(x1)
 local lo=min(x0,x1)
 local hi=max(x0,x1)
 if (hi==lo) return lo,hi
 return lo,hi-1
end

function _update60()
 local t=time()/16
 
	local bx0_=_bounce_screen(t*1)
	local by0_=_bounce_screen(t*2)
	local bx1_=_bounce_screen(t*3)
	local by1_=_bounce_screen(t*4)
	
	bx0,bx1=_to_halfopen(bx0_,bx1_)
	by0,by1=_to_halfopen(by0_,by1_)
	
	update_line()
	
	--[[
 local lx0_=_bounce_screen(t*1.5)
 local ly0_=_bounce_screen(t*2.5)
 local lx1_=_bounce_screen(t*3.5)
 local ly1_=_bounce_screen(t*4.5)
	
	lx0,lx1=lx0_,lx1_
	ly0,ly1=ly0_,ly1_
	]]--
end

was_down=false
last_mx,last_my=nil,nil

function update_line()
 local mx,my=stat(32),stat(33)
 local is_down=stat(34)!=0

 if is_down then
  if was_down then
   lx1,ly1=mx,my
  else
  	lx0,ly0=mx,my
  end
 end
 was_down=is_down
 last_mx,last_my=mx,my
end
-->8
function _draw()
 cls(0)
	rect(bx0,by0,bx1,by1,6)
	--quickzot(lx1,ly1,2,lx1-lx0,ly1-ly0,10,9,8)
 linefill(lx0, ly0, lx1, ly1, 2, 9)
	line(lx0,ly0,lx1,ly1,2)
	local cmin, cmax = collides()
	if cmin then
	 local dx,dy=lx1-lx0,ly1-ly0
	 line(lx0 + dx*cmin,
	      ly0 + dy*cmin,
	      lx0 + dx*cmax,
	      ly0 + dy*cmax,
	      11)
	 pset(lx0 + dx*cmin,
	      ly0 + dy*cmin,
	      12)
	end
	
	pset(last_mx,last_my,7)
end
-->8
function zot_one(x, y, r, ir, dx, dy, hot, warm)
 local x0, y0 = x-dx, y-dy
 local rx,ry,irx,iry=r*sgn(dx),r*sgn(dy),ir*sgn(dx),ir*sgn(dy)
 if warm then
  line(x0+irx,y0-ry,x+rx,y-iry,warm)
  line(x0-rx,y0+iry,x-irx,y+ry,warm)
  --line(x0-rx,y0-ry,x+rx,y+ry,warm)
 end
 line(x0,y0,x+rx,y-iry,hot)
 line(x0,y0,x-irx,y+ry,hot)
 --line(x0,y0,x+rx,y+ry,hot)
end

function zot(x,y,r,dx,dy,hot,warm,cold)
 local x0,y0,sdx,sdy=x-dx,y-dy,sgn(dx),sgn(dy)
 local rx,ry=r*sdx,r*sdy
 if cold then
  rectfill(x0-rx,y0-ry,x0+rx,y0+ry,cold)
  local sdxh,sdyh=sdx/2,sdy/2
  line(x0-rx-sdxh,y0+ry+sdyh,x-rx,y+ry,cold)
  line(x0+rx+sdxh,y0-ry-sdyh,x+rx,y-ry,cold)
 end
 for i=-r,r do
  line(x0+i*sdx,y0-ry,x+rx,y-i*sdy,warm)
  line(x0-rx,y0+i*sdy,x-i*sdx,y+ry,warm)
 end
 for i=-r,r do
  line(x0,y0,x+rx,y-i*sdy,hot)
  line(x0,y0,x-i*sdx,y+ry,hot)
 end
end

function quickzot(x,y,r,dx,dy,hot,warm,cold)
 local x0, y0, r2 = x-dx, y-dy, r/2
 rectfill(x0-0.5-r2, y0-0.5-r2, x0+r2+0.5, y0+r2+0.5, cold)
 local a = atan2(dx,dy)-0.25
 local tdx,tdy=cos(a), sin(a)
 for i=-r*0.65,r*0.65,0.65 do
  line(x0+i*tdx, y0+i*tdy, x+i*tdx, y+i*tdy, warm)
 end
 rectfill(x-r2,y-r2,x+r2,y+r2,hot)
end

-- linefill x0 y0 x1 y1 r [col]
-- draw a thicc line
-- https://www.lexaloffle.com/bbs/?tid=39016
function linefill(ax,ay,bx,by,r,c)
 if(c) color(c)
 local dx,dy=bx-ax,by-ay
 -- avoid overflow
 -- credits: https://www.lexaloffle.com/bbs/?tid=28999
 local d,n = abs(dx),abs(dy)
 if (d<n) d,n=n,d
 n/=d
 d*=(n*n+1)^0.5
 if(d<0.001) return
 local ca,sa=dx/d,-dy/d

 -- polygon points
 local s={
  {0,-r},{d,-r},{d,r},{0,r}
 }
 local u,v,spans=s[4][1],s[4][2],{}
 local x0,y0=ax+u*ca+v*sa,ay-u*sa+v*ca
 for i=1,4 do
  local u,v=s[i][1],s[i][2]
  local x1,y1=ax+u*ca+v*sa,ay-u*sa+v*ca
  local _x1,_y1=x1,y1
  if(y0>y1) x0,y0,x1,y1=x1,y1,x0,y0
  local dx=(x1-x0)/(y1-y0)
  if(y0<0) x0-=y0*dx y0=-1
  local cy0=y0\1+1
  -- sub-pix shift
  x0+=(cy0-y0)*dx
  for y=y0\1+1,min(y1\1,127) do
   -- open span?
   local span=spans[y]
   if span then
       rectfill(x0,y,span,y)
   else
       spans[y]=x0
   end
   x0+=dx
  end
  x0,y0=_x1,_y1
 end
end
__gfx__
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00077000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00077000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000