rrebbbbeca's stats

clamp:{y max x min z};
lerp:{1-x*y+(x*z)};
stiffness:0.3;

G:love.graphics;
SIZE:[G.getWidth(), G.getHeight()];

newball: { 
	pos: 2! map {math.random(SIZE x)};
	rad: math.random(30,75);
	col: 3! map {math.random()};
	[pos:pos,old:pos,rad:rad,col:col]
};
balls: 20! map newball;

bound:{clamp([0,0]+x.rad, x.pos, SIZE-x.rad)};
verlet: {
	accel: x; dt: y;
	new: accel*dt*dt - z.old + (2*z.pos);
	set(z,.old,z.pos);
	set(z,.pos,new);
};

set(love, .draw, callable {
	G.clear(1,1,1);
	G.setColor(0,1,0);
	f:{G.circle(y,x.pos 0,x.pos 1, x.rad)};
	balls map { 
		G.setColor(x.col); f(x,.fill);
		G.setColor(0,0,0); f(x,.line);
	};
});

hypot:{x*x sum @math.sqrt};
norm:{h:hypot x;0~h?x*0:x/h};

step: {
	balls map { set(x, .pos, lerp(stiffness, x.pos, bound x)); };
	3! map { news: balls map {
		ball: x;
		deltas: (balls flip).pos map {x-(ball.pos)}- ;
		dists: deltas map hypot; dirs: deltas map norm;
		radsums: (balls flip).rad map {ball.rad+x};
		overlaps: dists - radsums -;
		moves: overlaps > 0.001 * stiffness * dirs * overlaps;
		move: moves sum;
		x.pos + move
	}};
	[balls,news] flip map {set(x 0, .pos, x 1)};
	call(love.mouse.isDown,1)
		? set(balls 0, .pos, [love.mouse.getX(),love.mouse.getY()]) 
		: 0;
	balls map { verlet([0,1000], 1/60, x) };
};

set(love, .update, callable step);

function love.conf(t) t.window.title="cg81" end

local ok,pprint = pcall(require, 'pprint')
if not ok then pprint=print pformat=tostring  -- that's all you deserve
else pformat=pprint.pformat pprint.setup{show_all=true,use_tostring=true} end

local lpeg = require 'lpeg'
local P,V,R,C,Ct,Cc = lpeg.P,lpeg.V,lpeg.R,lpeg.C,lpeg.Ct,lpeg.Cc

local function isty(ty,x) return type(x) == 'table' and x.ty == ty end
local function enty(ty) return function(x) x.ty=ty return x end end
local function inty(ty) return function(x) return {ty=ty,x} end end
local list = enty'list'
local dict = inty'dict'
local fn = inty'fn'
local function islist(x) return isty('list',x) end
local function isdict(x) return isty('dict',x) end
local function isfn(x) return isty('fn',x) end

local function conform(f)
	local function inner(a,b)
		local la,lb = islist(a),islist(b)
		assert(la or type(a) == 'number','unconformation')
		assert(lb or type(b) == 'number','unconformation '..type(b))

		local out = list{}
		if not la and not lb then return f(a,b)
		elseif la and lb then
			assert(#a == #b, 'unconformation length: '..#a..' '..#b) -- todo
			for i = 1,#a do out[i] = inner(a[i],b[i]) end
		elseif la then
			for i,v in ipairs(a) do out[i] = inner(v,b) end
		elseif lb then
			for i,v in ipairs(b) do out[i] = inner(a,v) end
		end
		return out
	end
	return inner end
local function conform1(f)
	local function inner(a)
		if not islist(a) then assert(type(a) == 'number') return f(a) end
		local out = list{}
		for i = 1,#a do out[i] = inner(a[i]) end
		return out
	end
	return inner
end

local function eqq(a,b)
	if a == b then return true end
	if islist(a) and islist(b) and #a==#b then
		for i=1,#a do if not eqq(a[i],b[i]) then return false end end
		return true
	elseif isdict(a) and isdict(b) then
		local keys = {}
		for k in pairs(a[1]) do keys[k] = true end
		for k in pairs(b[1]) do keys[k] = true end
		for k in pairs(keys) do
			if not eqq(a[1][k],b[1][k]) then return false end
		end
		return true
	end
	return false
end
local call
local dyads = {
	['+'] = conform(function(a,b) return a+b end),
	['-'] = conform(function(a,b) return a-b end),
	['/'] = conform(function(a,b) return a/b end),
	['*'] = conform(function(a,b) return a*b end),
	['<'] = conform(function(a,b) return a<b and 1 or 0 end),
	['>'] = conform(function(a,b) return a>b and 1 or 0 end),
	['='] = conform(function(a,b) return a==b and 1 or 0 end),
	['~'] = function(a,b) return eqq(a,b) and 1 or 0 end,
	['++'] = function(a,b) -- it's PEND!!!!
		if not islist(a) then a = list{a} end
		if not islist(b) then b = list{b} end
		local out = list{}
		table.move(a,1,#a,1,out) table.move(b,1,#b,#a+1,out)
		return out
	end,
	mod = conform(function(a,b) return a%b end),
	max = conform(math.max),
	min = conform(math.min),
	-- this can all probably be generalized a bunch
	['@'] = function(a,b,c) return call(c,b,{a}) end,
	map = function(a,b,c)
		assert(islist(a),'can only map over list, was '..type(a))
		local out = list{}
		for i,v in ipairs(a) do out[i] = call(c,b,{v}) end
		return out
	end
}

local monads = {
	['-'] = conform1(function(a) return -a end),
	sum = function(a)
		assert(islist(a),'need list for sum')
		local s = 0
		if islist(a[1]) then s = list{} for i=1,#a[1] do s[i] = 0 end end
		for _,v in ipairs(a) do s = dyads['+'](s,v) end
		return s
	end,
	['!'] = function(a) local out = list{} for i=0,a-1 do out[i+1]=i end return out end,
	['>'] = function(a) return list{a} end,
	['<'] = function(a) assert(islist(a) and #a > 0,'cant unlist nonlist') return a[1] end,
	flip = function(a,c) -- this already needs rewriting
		if type(a) == 'number' then return a
		elseif islist(a) then
			if #a == 0 then return list{} end
			if type(a[1]) == 'number' then
				for i = 1,#a do assert(type(a[i]) == 'number','need list of only numbers for flip') end
				return a
			elseif islist(a[1]) then
				local len = #a[1]
				local out = list{}
				for j = 1,len do out[j] = list{} end
				for i,v in ipairs(a) do
					assert(islist(v),'need list of only lists for flip')
					assert(#v == len, 'need list of equisized lists for flip')
					for j,w in ipairs(v) do out[j][i] = w end
				end
				return out
			elseif isdict(a[1]) then
				local out = dict{}
				local keys = {} for k in pairs(a[1][1]) do table.insert(keys,k) end
				for _,k in ipairs(keys) do out[1][k] = list{} end
				for i,v in ipairs(a) do
					assert(isdict(v),'need list of only dicts for flip')
					for _,k in ipairs(keys) do out[1][k][i] = assert(v[1][k],'missing key '..k) end end
				return out
			end
		elseif isdict(a) then
			local keys = {} for k in pairs(a[1]) do table.insert(keys,k) end
			local len
			for _,k in ipairs(keys) do
				assert(islist(a[1][k]),'need dict of only lists for flip')
				len = len or #a[1][k]
				assert(#a[1][k] == len,'need dict of equisized lists for flip')
			end
			local out = list{}
			for i=1,len do out[i] = dict{} end
			for k,v in pairs(a[1]) do
				for j,w in ipairs(v) do out[j][1][k] = w end
			end
			return out
		end
	end,
}

local S = ("#" * (P(1) - '\n')^0 * ('\n' + P(-1)) + lpeg.S" \n\t")^0
local function seq(item,sep) return (item * (sep*S*item)^0 )^-1 end
local number = C(R"09"^1 * '.' * R"09"^1 + R"09"^1) / tonumber
local op = C(P"+"+"-"+"*"+"/")

local namechar = R"az"+R"AZ"+"_"
local name = C( (R"az"+R"AZ"+"_")^1 ) / function(s) return {ty='name',n=s} end
local symbol = ('.'*name) / enty'string'

local function grab_names(map)
	local keys = {}
	for k in pairs(map) do table.insert(keys,k) end
	table.sort(keys,function(a,b) return #a > #b end)
	local p = P(false)
	for _,k in ipairs(keys) do
		if not namechar:match(k) then p = p + k
		else p = p + (k * -namechar) end end
	return p end

local monad_names = grab_names(monads)
local dyad_names = grab_names(dyads)
local monad = S*C(monad_names)*S
local dyad = S*C(dyad_names)*S*V'term'
local reserved = monad_names+dyad_names
name = name - reserved

local gram = P{"body",
	call = Ct(V'noun'*('('*S*V'list_body'*')' + V'noun')^1 ) * S / enty'call',
	noun = (name + symbol + number + V'fn' + "("*V"body"*")" + V'list' + V'dict') * S,
	term = V'call' + V'noun',
	oper = (dyad + monad)
		/ function(v,n) return {ty='oper',v,n} end,
	real_expr = Ct(V'term' * V'oper'^0) / enty'expr',
	expr = V'cond' + V'real_expr',
	cond = Ct(V'real_expr' * '?' * S * V'real_expr' * ':' * S * V'expr') / enty'cond',
	body = Ct( seq(V'decl' + V'expr', ';') * (S*';'*Cc(0))^-1 * S ) / enty'body',
	list_body = Ct( seq(V'expr', ',') ) / enty'list_body',
	list = ('[' * S * V'list_body' * ']') / enty'list_lit',
	decl = Ct(name * ':' * S * V'expr') / enty'decl',
	fn = '{'*S*V'body'*'}' / fn,
	dict = Ct('['*S*':'*S*']' + '['*S*seq(V'decl',',')*']') / enty'dict_lit',
}
local patt = S * gram * S * -1

local function qprint(x,ns)
	local s = ('| '):rep(ns or 0)
	if type(x) ~= 'table' then print(s..tostring(x))
	else io.write(s..(x.ty or '???')..(x[1] and ':' or ''))
		for k,v in pairs(x) do if type(k) == 'string' and k~='ty' then
				io.write(' '..k..'='..tostring(v)..',') end end
		print()
		for i,v in ipairs(x) do qprint(v,(ns or 0)+1) end
	end
end

local evals = {}
local function eval(c,x)
	if type(x) == 'number' then return x end
	return (evals[x.ty] or error('uncomprehended type '..x.ty))(c,x)
end

call = function (c,callee,args)
	if type(callee) == 'function' then return callee(table.unpack(args))
	elseif islist(callee) then
		assert(#args == 1 and type(args[1]) == 'number', 'can only index single number for now '..pformat(args))
		local idx = math.floor(args[1])
		assert(0 <= idx and idx < #callee,'index out of bounds')
		return callee[idx + 1]
	elseif isfn(callee) then
		table.insert(c.cs,1,{a=args,f=callee})
		local res = eval(c,callee[1])
		table.remove(c.cs,1)
		return res
	elseif isdict(callee) then
		return callee[1][args[1]] or 0
	elseif type(callee) == 'table' then
		return callee[args[1]] -- ordinary table access
	else pprint(callee,args) error'unsupported call style'
	end
end

function evals.expr(c,t)
	local val = eval(c,t[1])
	for i = 2, #t do
		local oper = t[i]  assert(oper.ty == 'oper')
		local v,n = oper[1],oper[2]
		if n then val = (dyads[v] or error("no such dyad "..v))(val, eval(c,n),c)
		else val = (monads[v] or error("no such monad "..v))(val,c) end
	end
	return val
end
function evals.list_lit(c,t)
	local out = list{}
	for i,v in ipairs(t) do
		out[i] = eval(c,v)
	end
	return out
end
function evals.dict_lit(c,t)
	local out = dict{}
	for i,v in ipairs(t) do
		assert(v.ty == 'decl')
		local name,val = v[1],v[2]
		assert(name.ty == 'name')
		out[1][name.n] = eval(c,v[2])
	end
	return out
end
function evals.fn(c,t) return t end
function evals.string(c,t) return t.n end
function evals.body(c,t)
	if #t < 1 then return 0 end
	local v
	for i=1,#t do v = eval(c,t[i]) end
	return v
end
function evals.decl(c,t)
	local name=t[1] assert(name.ty=='name')
	local val = eval(c,t[2])
	c.g[name.n] = val
	if isfn(val) then val.name = name.n end
	return 0
end
function evals.name(c,t)
	-- currently only magical names (x y z xx yy zz) and globals
	-- todo: proper lexical scoping
	local name,args,args2 = t.n, c.cs[1].a, c.cs[2].a
	    if name == 'x' then return args[1] or 0
    elseif name == 'y' then return args[2] or 0
    elseif name == 'z' then return args[3] or 0
	elseif name == 'xx' then return args2[1] or 0
    elseif name == 'yy' then return args2[2] or 0
    elseif name == 'zz' then return args2[3] or 0
    else return c.g[name] or _G[name] or 0 end end

function evals.call(c,t)
	local callee = eval(c,t[1])
	assert(#t >= 2)
	local function call1(callee,t)
		local args
		if isty('list_body',t) then
			args = {}
			for i,v in ipairs(t) do args[i] = eval(c,v) end
		else args = {eval(c,t)} end
		return call(c,callee,args)
	end
	for i=2,#t do
		callee = call1(callee, t[i])
	end
	return callee
end
function evals.cond(c,t)
	local cond = eval(c,t[1])
	assert(type(cond) == 'number' and (cond == 1 or cond == 0), 'need 0 or 1 for cond')
	return eval(c, t[3-cond])
end

local protect
local function init()
	local c
	c = {
		g={
			set = function(t,k,v)
				if isdict(t) then t = t[1] end
				t[k] = v
				return t
			end,
			-- a LITTLE clunky but i'm running out of time
			callable = function(x)
				return function(...) return protect(c, call, c, x, {...}) end
			end,
			call = function(f,...)
				local r = table.pack(f(...))
				for i=1,r.n do
					if not r[i] then r[i] = 0
					elseif r[i] == true then r[i] = 1
					end
				end
				if r.n == 1 then return r[1] else r.n=nil return list(r) end
			end,
			pprint = function(...) pprint(...) end,
			print=print,
		},
		cs={{a={},fake=true},{a={},fake=true}}}
	return c
end

protect = function(c,...)
	local ok, err = pcall(...)
	if not ok then
		for i,x in ipairs(c.cs) do if not x.fake then
			print('-->',x.f and x.f.name or '??')
		end end
		error(err, 0)
	else return err end
end

local function run(s,c,debug)
	c = c or init()
	local prog = patt:match(s)
	if prog == nil then error'nil prog' end
	if debug then qprint(prog) end
	return protect(c, eval, c, prog)
end

local n = 1
local function c(i,o)
	io.write(n,'\t',i,'\t') n=n+1
	io.flush()
	local oo = run(i)
	assert(eqq(o,oo), "expected to get "..pformat(o).." but i got "..pformat(oo))
	print('ok')
end

c("2+2",4)
c("6*6-",-36)
c("2-20/6-",3)
c("6*6+3",39)
c("6*(6+3)",54)
c("6+8/2",7)
c('10+[1,2,3]',list{11,12,13})
c('[10,20,30]/10',list{1,2,3})
c('[2,3]*[4,5]',list{8,15})
c('   (2+2;4*8;24)-4',20)
c('  2+2; 5*5',25)
c('a:6; b:7; a*b',42)
c('math.sqrt(9)',3)
c('math.sqrt 9',3)
c('math.sqrt(7;8;9)',3)
c('math.sqrt(9,8,7)',3)
c('13 + math.sqrt 36',19)
c('math.sqrt 36 + 13',19)
c('math.sqrt (36 + 13)',7)
c('math.sqrt 36 + (13-)',-7)
c('math.sqrt 36 + 13-',-19)
c('[10,20,30](0)',10)
c('{x+5}20',25)
c('{x+5}[10,20,30]',list{15,25,35})
c('0.5+1',1.5)
c('lerp:{1-x*y+(x*z)}; lerp(0.25,12,24)',15)
c('lerp:{1-x*y+(x*z)}; lerp(0.25,[12,0],24)',list{15,6})
c('lerp:{1-x*y+(x*z)}; lerp(1/4,[10,20],[18,16])',list{12,19})
c('lerp:{1-x*y+(x*z)}; lerp([1/4,1/2],[10,20],[18,16])',list{12,18})
c('lerp:{1-x*y+(x*z)}; mid:{lerp(1/2,x,y)}; mid([10,20,30],[90,80,70])',list{50,50,50})
c('{36}()',36)
c('[7-,6-,5-,4-,3-,2-,1-,0,1,2,3,4,5,6,7]mod3',list{2,0,1,2,0,1,2,0,1,2,0,1,2,0,1})
c('modern:69;modern',69)
c('dbl:{2*x}; 10 @ dbl',20)
c('dbl:{2*x}; [10,20,30] @ dbl',list{20,40,60})
c('dbl:{2*x}; [10,20,30] map dbl',list{20,40,60})
c('[36,81] map math.sqrt',list{6,9})
c('36 max 81 + 9',90)
c('([{x+2},{x+10}]1) 5',15)
c('[{x+2},{x+10}] 1 5',15)
c('[{x+2},{x+10}] map {x 5}',list{7,15})
c('.hi','hi')
c('[1]++2',list{1,2})
c('1++[2]',list{1,2})
c('[1]++[2]',list{1,2})
c('1++2',list{1,2})
c('[1,2,3]++[4,5]',list{1,2,3,4,5})
c('[1,2,3]++[[4,5]]',list{1,2,3,list{4,5}})
c('[]++[1,2,3]',list{1,2,3})
c('[1,2,3]++[]',list{1,2,3})
c('[aaa:100, bbb:200, ccc:300].bbb',200)
c('[ [aaa:100], [aaa:200], [aaa:300] ] map {x.aaa}',list{100,200,300})
c('[aaa:[bbb:100]].aaa.bbb',100)
c('[[1,2,3],[10,20,30],[100,200,300]] flip', list{list{1,10,100},list{2,20,200},list{3,30,300}})
c('[1,2,3] flip',list{1,2,3})
c('[] flip',list{})
c('12 flip',12)
c('[[a:1,b:2],[a:10,b:20],[a:100,b:200]] flip',dict{a=list{1,10,100},b=list{2,20,200}})
c('[a:[1,10,100],b:[2,20,200]] flip',list{dict{a=1,b=2},dict{a=10,b=20},dict{a=100,b=200}})
c('math.exp 1',math.exp(1))
c('[:]',dict{})
-- c('[:] flip',99999) -- i don't know what this should do
_G.test = {a=100,b=200}
c('test.a',100)
c('set(test,.b,500); test.b',500) assert(_G.test.b == 500)
c('2+2 # thats easy',4)
c('5+5; #yeah\n2+2',4)
c('10!sum',45)
c('hypot:{x*x sum @math.sqrt}; hypot [3,4]',5)
c('[10,20-]-',list{-10,20})
c('0 ? 5 : 10',10)
c('1 ? 5 : 10',5)
c('2<3 ? 20 : 30',20)
c('3<2 ? 20 : 10<20 ? 100 : 200',100)
c('3<2 ? 20 : 20<10 ? 100 : 200',200)
c('2<3 ? 20 : 20<10 ? 100 : 200',20)
_G.test = {c=0,d=0}
c('0 ? set(test,.c,123) : set(test,.d,456); 0',0) assert(_G.test.c == 0 and _G.test.d == 456)
_G.test = {c=0,d=0}
c('1 ? set(test,.c,123) : set(test,.d,456);',0) assert(_G.test.c == 123 and _G.test.d == 0)
c('[10,20,30]<[18,19,20]',list{1,0,0})
c('5!=3',list{0,0,0,1,0})
c('[1,0,1,0]=[1,1,0,0]',list{1,0,0,1})
c('[1,0,1,0]~[1,1,0,0]',0)
c('[1,0,1,0]~[1,0,1,0]',1)
c('[a:100,b:200]~[a:100]',0)
c('[a:100,b:200]~[a:100,b:300]',0)
c('[a:100,b:200]~[b:200,a:100]',1)
c('2+2; 4+4',8)
c('2+2; 4+4;',0)
c('2>',list{2})
c('[2,3]>',list{list{2,3}})
c('[2,3]<',2)
c('[2,3]><',list{2,3})
c('{x}(1,2,3)',1)
c('{y}(1,2,3)',2)
c('{z}(1,2,3)',3)
-- c('a:100; {a:200}(); a',100) -- todo
-- c('a:100; {a:200; a}()+a',300) -- todo
c('([ [a:10,b:20], [a:100,b:200] ] flip).a',list{10,100}) --egh
-- c('[ [a:10,b:20], [a:100,b:200] ] flip.a',list{10,100}) --egh

return {
	run=run,
}

require'lucia'.run(io.open'collision.lucia':read'*a')

! Copyright (C) 2025 Aleksander "olus2000" Sabak.
! See https://factorcode.org/license.txt for BSD license.

USING: accessors arrays assocs calendar concurrency.futures entry.pathing 
formatting hashtables http http.client io io.encodings.string io.encodings.utf8 
json json.http kernel math math.parser namespaces prettyprint sequences 
sequences.repeating threads ;
IN: entry

CONSTANT: session
"SESSION COOKIE HERE" 

: session-cookie ( -- cookie ) 
  session "session" <cookie> ;

: request ( method -- request )
  "https://codeguessing.gay/extra/game70" swap <client-request>
  session-cookie put-cookie ;  

: step-body ( direction -- post-data )
  "dir" associate <json-post-data> ;

: step-request ( direction -- request ) 
  "POST" request
  swap step-body >>post-data ;

SYMBOL: score

: print-score ( -- ) score get "score: %d\n" printf ; 

: request! ( request -- response )
  http-request nip utf8 decode json> ;

: respect ( response -- ) 
  [ "grid" of str>>grid ]
  [ "score" of score set ] bi ;

: init ( -- ) "GET" request request! respect ;

: travel ( path -- ) 
  [ [ step-request request! ] curry future 
    100 milliseconds sleep
  ] map
  [ ?future ] map 
  [ "s" of ] maximum-by respect ;
  
: print-state ( -- ) print-score print-grid ;

: perform-iteration ( -- ) path travel print-state ;

: entry ( -- )
  init print-state
  [ score get 2025 <  ]
  [ perform-iteration ] while ;

MAIN: entry