stage.js

// Stage - text adventure game engine
// Copyright (C) 2025  tceo
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

const Type = {
	token:      0,
	symbol:     1,
	function:   2,
	reference:  3,
	number:     4,
	string:     5,
	boolean:    6,
	list:       7,
	pair:       8,
	any:        127 // DO NOT INCREASE WITHOUT CHANGING TYPEMODS
}

const TypeMod = {
	list:   (1 << 7),
	symbol: (1 << 8)
}

const stage_version = "20250410";
let play_chunks;

let sources = {};
let current_source;

let scene_stack = [];
let action_stack = [];
let scenes = {};
let current_scene;
let stop = false;
let play;
let action_depth = 0;
let container;
let output;
let text_output;
let action_output;

let scope_depth = 0
// [token, scope]
let variables = {}
let var_scopes = {}
let flattened_scopes = []

 // this is a bit bad.
let current_index
let subscene_change
let subscene_return = []

// DEBUGGER HOOKS START
let subscene_change_hook = (ind) => {}
let scene_process_start_hook = (ind) => {}
let scene_process_end_hook = (ind) => {}
// DEBUGGER HOOKS END

/* ------ */
/* SCENES */
/* ------ */

function process_scene(ind) {
	play = sources[current_source]
	// DEBUGGER HOOK
	scene_process_start_hook(ind)
	var sc = 0
	var si = -1
	out:
	for (var i = ind; (i <= play.length || subscene_change) && !stop; i++) {
		if (subscene_change) {
			// DEBUGGER HOOK
			subscene_change_hook(subscene_change)
			i = subscene_change.index
			current_source = subscene_change.source
			play = sources[current_source]
			subscene_change = null
		}
		var c = play[i]
		if (sc) {
			if (c == '}') sc--
			else if (c == '{') sc++
			continue
		}
		switch (c) {
			case ']': i = text(i); break
			case '>': i = action(i, si + 1); si = -1; break
			case '?': i = evaluate(i, si + 1); si = -1; break
			case ':': i = check(i, si + 1); si = -1; break
			case '[': i = input(i); break
			case '!': i = execute(i); break
			case '/': i = comment(i); break
			case '@': action_stack.push({source: current_source, index: i + 1}); break
			case '{': sc++; si = i; break
			case '}': case '.':
				if (subscene_return.length) {
					var s = subscene_return.pop();
					i = s.index - 1; // i will be incremented by the loop.
					current_source = s.source
					play = sources[current_source]
					break;
				}
				break out
		}
	}
	// DEBUGGER HOOK
	scene_process_end_hook()
	container.scrollTop = container.scrollHeight;
}

function text(i) {
	var text = ""
	while (play[++i] != '\n' && play[i]) {
		text += play[i]
	}
	insert_text(text)
	return i
}

function input(i) {
	var label = ""
	while (play[++i] != '\n' && play[i]) label += play[i]
	var input = document.createElement("input")
	input.classList.add("text-input")
	input.type = "text"
	input.placeholder = label
	input.setAttribute("onkeydown", `input_check(event, ${i}, ${action_depth}, "${current_source}")`)
	action_output.appendChild(input)
	stop = true // blocking
	return i
}

function text_format(text, parent_element) {
	var c = parent_element
	var fsc = 0
	var i = -1
	while (text[++i]) {
		if (text[i + 1] == "<") {
			var nw
			switch (text[i]) {
				case 'b': nw = document.createElement("b"); break
				case 'i': nw = document.createElement("i"); break
				case 'c': nw = document.createElement("code"); break
				case '$':
					var sym = ""
					// <
					i++
					while (text[++i] && text[i] != '>') sym += text[i]
					var ret
					for (var tok of parse_expression(sym + '\n'))
						ret = get_value(tok, Type.string)
					c.innerHTML += ret
					continue
				case '\\': default: continue
			}

			c.appendChild(nw)
			c = nw
			i++
			fsc++
			continue
		}
		if (fsc && text[i] == '>') {
			fsc--
			c = c.parentNode
			continue
		}
		c.innerHTML += text[i]
	}
}

function insert_text(text) {
	var p = document.createElement("p")
	text_format(text, p)
	text_output.appendChild(p)
}

function action(i, si) {
	var a = document.createElement("a")
	var text = ""
	while (play[++i] != '\n' && play[i]) text += play[i]	
	text_format(text, a)
	a.classList.add("action")
	if (!si) { // blocking action.
		a.href = `javascript:execute_action(${i}, ${action_depth}, "${current_source}", true)`
		stop = true
	} else {
		a.href = `javascript:execute_action(${si}, ${action_depth}, "${current_source}")`
	}
	action_output.appendChild(a)
	return i
}

function evaluate(i, si) {
	var expr = ""
	while (play[++i] && play[i] != '\n') expr += play[i]
	expr += '\n'
	current_index = i
	var node = parse_expression(expr)
	var result
	for (var n of node)
		result = resolve_token(n)
	if (si && get_value(result, Type.any)) enter_subscene(si)
	else if (!si) {
		set_var("status", result)
		if (checks.length) {
			for (var c of checks) {
				var val = c[0]
				if (!get_value(execute_function("=", [result, val]), Type.boolean))
					continue
				enter_subscene(c[1].index, c[1].source)
				break
			}
			checks = []
		}
	}
	return i
}

let checks = []

function check(i, si) {
	var t = ""
	while (play[++i] && play[i] != '\n') t += play[i]
	current_index = i
	if (t) checks.push([token(t), {source: current_source, index: si}])
	return i
}

function execute(i) {
	var expr = ""
	var pc = 0
	var str = ""
	while (play[++i]) {
		if (play[i] == str) {
			str = ""
		} else if (!str) {
			if (play[i] == '(') pc++;
			else if (play[i] == ')' && pc) pc--;
			else if (play[i] == '"') str = play[i];
			else if (play[i] == '\n' && !pc) break;
		}
		expr += play[i]
	}
	expr += '\n'
	current_index = i
	if (pc) {
		if (str) problem(PType.FAIL, "Unterminated string in expression\n'", expr, "'.")
		else problem(PType.FAIL, "Unbalanced parenthesis in expression at\n'", expr, "'.")
		return i
	}
	var node = parse_expression(expr)
	for (var n of node)
		get_value(n, Type.any)
	return i
}
function comment(i) {
	if (play[i + 1] == '*') {
		while (!(play[++i] == '*' && play[i + 1] == '/')) continue
		return i + 1
	} else {
		while (play[++i] != '\n' && play[i]) continue
		return i
	}
}

function enter_subscene(si, source) {
	subscene_return.push({source: current_source, index: current_index})
	subscene_change = {source: source ?? current_source, index: si}
}

function enter_scene(s) {
	stop = true
	setTimeout(() => {
		var si = s.index
		current_source = s.source
		stop = false
		current_scene = s
		action_stack = [{source: s.source, index: si}]
		subscene_return = []
		current_index = 0
		subscene_change = 0
		process_scene(si)
	});
}

function increment_action_depth() {
	action_depth++
	if (play_chunks.STGE["action-clear"]) {
		clear_output()
	} else {
		output.appendChild(document.createElement("hr"))
		if (play_chunks.STGE["action-separation"]) {
			output.appendChild(text_output = document.createElement("div"))
			output.appendChild(action_output = document.createElement("div"))
		}
	}
}

function execute_action(si, depth, source, blocking = false) {
	if (depth != action_depth)
		return
	increment_action_depth()
	stop = false
	current_source = source
	if (!blocking) action_stack.push({source: source, index: si})
	process_scene(si)
}

function input_check(e, si, depth, source) {
	if (depth != action_depth) {
		e.preventDefault()
		return
	}
	if (e.key == "Enter") {
		e.preventDefault()
		current_source = source
		set_var("status", [Type.string, e.target.value])
		increment_action_depth()
		output.appendChild(document.createElement("hr"))
		stop = false
		process_scene(si)
	}
}

/* ----------- */
/* EXPRESSIONS */
/* ----------- */

const NIL = [Type.number, 0]

// Used in STGE chunk parsing.
const bool_re = /^(yes|no|true|false|t|f)$/
function token(tok) {
	const string_re = /(^".*"$)/
	const pair_re = /^.+:.+$/
	if (Array.isArray(tok))
		return [Type.list, tok]
	if (string_re.exec(tok))
		return [Type.string, tok.slice(1, -1)]
	if (pair_re.exec(tok))
		return [Type.pair, tok.split(":").map(token)]
	if (!isNaN(tok) && !isNaN(parseFloat(tok)))
		return [Type.number, Number(tok)]
	if (bool_re.exec(tok)) {
		if (typeof tok == "boolean")
			return [Type.boolean, tok]
		return [Type.boolean, tok.startsWith("t") || tok.startsWith("y")]
	}
	return [Type.symbol, tok]
}

const coercion_functions = {
	[Type.list]: {
		[Type.boolean]: (list) => { return [Type.boolean, !!list.length] },
		[Type.number]: (list) => { return [Type.number, list.length] },
		[Type.pair]: (list) => { return [Type.pair, list.slice(0, 2)] },
	},
	[Type.number]: {
		[Type.string]: (num) => { return [Type.string, num.toString()] },
		[Type.boolean]: (num) => { return [Type.boolean, num != 0] }
	},
	[Type.string]: {
		[Type.number]: (str) => { return !isNaN(str) && !isNaN(parseFloat(str)) ? [Type.string, Number(str)] : null },
		[Type.symbol]: (str) => { return [Type.symbol, str] }
	},
	[Type.boolean]: {
		[Type.number]: (bool) => { return [Type.number, +bool] }
	},
	[Type.pair]: {
		[Type.list]: (pair) => { return [Type.list, pair]}
	}
}

function coerce_token(v, type) {
	if (v[0] == type) // v already type
		return v
	if (type == Type.symbol && v[0] == Type.reference)
		return v
	if (v[0] == Type.reference)
		v = resolve_token(v)
	var coerce = v
	if (coercion_functions[v[0]] && coercion_functions[v[0]][type]) {
		coerce = coercion_functions[v[0]][type](v[1])
		coerce = coerce ? coerce : v
	}
	if (coerce[0] != type)
		problem(PType.WARN, "Unable to coerce", coerce[0], "to type", type, ".")
	return coerce
}

function get_token_type(v, type) {
	if (!v)
		return null
	if (type == Type.token)
		return v
	if (type != Type.symbol || v[0] == Type.function) {
		v = resolve_token(v)
		// this is some abyssmal dogshit garbage right here.
		// the entire function is fucking r******* and the person who made it should suffer
		// oh wait that person is me, and I sure am suffering.
		// WHAT THE FUCK WAS THE POINT WITH MAKING ALL THESE FUCKING DUMB FUNCTIONS
		// What I am trying to say is that these functions are all dumb and should be thrown out
		// and replaced with hopefully something better :)
		if ((v[0] == Type.reference || v[0] == Type.symbol) && (type != Type.reference && type != Type.symbol))
			v = resolve_token(v)
	}
	if (v[0] != type && type != Type.any)
		v = coerce_token(v, type)
	return v
}

function get_value(v, type) {
	if (type == Type.token)
		return v
	v = get_token_type(v, type)
	return v && v[1]
}

function get_token(v) {
	if (!v)
		return null
	if (v[0] == Type.function)
		v = execute_function(v[1][0], v[1][1])
	return v
}

function resolve_token(v) {
	if (!v)
		return null
	if (v[0] == Type.reference)
		v = resolve_token(v[1][0])[1][v[1][1]]
	if (v[0] == Type.symbol)
		v = get_var(v[1], true)
	if (v[0] == Type.function)
		v = execute_function(v[1][0], v[1][1])
	return v
}

function humanify_token(v) {
	switch (v[0]) {
		case Type.reference:
			return `ref ${humanify_token(v[1][0])}[${v[1][1]}]`
		case Type.symbol:
			return `sym ${v[1]}`
		case Type.function:
			return `(${v[1][0]} ${v[1][1].map(x => humanify_token(x)).join(" ")})`
		case Type.list:
			return `#(${v[1].map(x => humanify_token(x)).join(" ")})`
		case Type.pair:
			return `${humanify_token(v[1][0])}:${humanify_token(v[1][1])}`
		case Type.boolean:
 		case Type.string:
		case Type.number:
			return v[1]
	}
}

function enter_scope() {
	scope_depth++
}

function exit_scope(clear) {
	// bit hacky but whatever.
	if (clear) {
		while (scope_depth) exit_scope(false)
		return
	}

	var scope = var_scopes[''+scope_depth]
	if (scope) {
		for (var k of Object.keys(scope)) {
			if (variables[k][1] < scope_depth) continue
			if (scope[k][0] == null)
				delete variables[k]
			else variables[k] = scope[k]
		}
		var_scopes[''+scope_depth] = []
	}
	scope_depth--
}

function get_var(variable, local) {
	var v = variables[variable]
	if (!v) return NIL
	var sdv = v[1]
	if (local || !sdv) return v[0]
	while (sdv) {
		var sd = ''+sdv
		sdv = var_scopes[sd][variable][1]
		if (!sdv) return var_scopes[sd][variable][0] ?? NIL
	}
	return NIL // whuh?
}

function set_var(variable, value, local) {
	var v = variables[variable]
	if (local) {
		var sd = ''+scope_depth
		if (v) {
			if (v[1] != scope_depth) {
				if (!var_scopes[sd]) var_scopes[sd] = {}
				var_scopes[sd][variable] = v
				variables[variable] = [value, scope_depth]
			} else {
				variables[variable][0] = value
			}
		} else {
			if (var_scopes[sd]) var_scopes[sd][variable] = [null, 0]
			else var_scopes[sd] = {[variable]: [null, 0]}
			variables[variable] = [value, scope_depth]
		}
		return value
	} else {
		if (!v) {
			variables[variable] = [value, 0]
			return value
		}
		var sdv = v[1]
		if (!sdv) return variables[variable][0] = value
		var sd
		while (sdv) {
			sd = ''+sdv
			sdv = var_scopes[sd][variable][1]
		}
		var_scopes[sd][variable][0] = value
		return value
	}
}

function set_ref(ref, value) {
	return resolve_token(ref[1][0])[1][ref[1][1]] = value
}

const funcs = {
	"+": [[["first", Type.number], ["rest", Type.number|TypeMod.list]], (args, first, rest) => {
		for (var num of rest) first += num
		return [Type.number, first]
	}],
	"-": [[["first", Type.number], ["rest", Type.number|TypeMod.list]], (args, first, rest) => {
		for (var num of rest) first -= num
		return [Type.number, first]
	}],
	"*": [[["first", Type.number], ["rest", Type.number|TypeMod.list]], (args, first, rest) => {
		for (var num of rest) first *= num
		return [Type.number, first]
	}],
	"/": [[["dividend", Type.number], ["divisor", Type.number|TypeMod.list]], (args, dividend, divisor) => {
		for (var num of divisor) dividend /= num
		return [Type.number, dividend]
	}],
	"%": [[["dividend", Type.number], ["divisor", Type.number]], (args, dividend, divisor) => {
		return [Type.number, ((dividend % divisor) + divisor) % divisor]
	}],
	">": [[["first", Type.number], ["rest", Type.number|TypeMod.list]], (args, first, rest) => {
		for (var n of rest) {
			if (first <= n) return [Type.boolean, false]
			first = n
		}
		return [Type.boolean, true]
	}],
	"<": [[["first", Type.number], ["rest", Type.number|TypeMod.list]], (args, first, rest) => {
		for (var n of rest) {
			if (first >= n) return [Type.boolean, false]
			first = n
		}
		return [Type.boolean, true]
	}],
	"=": [[["first", Type.token], ["rest", Type.token|TypeMod.list]], (args, first, rest) => {
		// HACK, due to how internal functions work this uses Type.token to get tokens.
		first = resolve_token(first)
		for (var n of rest) {
			n = coerce_token(resolve_token(n), first[0])
			if (first[1] != n[1]) return [Type.boolean, false]
		}
		return [Type.boolean, true]
	}],
	"==": [[["first", Type.any], ["rest", Type.any|TypeMod.list]], (args, first, rest) => {
		for (var n of rest) {
			if (first !== n) return [Type.boolean, false]
		}
		return [Type.boolean, true]
	}],
	"rem": [[["dividend", Type.number], ["divisor", Type.number]], (args, dividend, divisor) => {
		return [Type.number, dividend % divisor]
	}],
	"get": [[], (args) => {
		var res = NIL
		for (var a of args)
			res = resolve_token(get_token(a))
		return res
	}],
	"getg": [[["syms", Type.symbol|TypeMod.list]], (args, syms) => {
		var res = NIL
		for (var s of syms)
			res = get_var(s, false)
		return res
	}],
	"do": [[], (args) => {
		for (var a of args) {
			val = get_value(a, Type.any)
			if (Array.isArray(val)) execute_function("do", val)
		}
		return [Type.boolean, true]
	}],
	"abs": [[["num", Type.number]], (args, num) => {
		return [Type.number, Math.abs(num)]
	}],
	"floor": [[["num", Type.number]], (args, num) => {
		return [Type.number, Math.floor(num)]
	}],
	"set": [[["sym", Type.token], ["val", Type.token]], (args, sym, val) => {
		sym = get_token(sym)
		val = resolve_token(val)
		if (sym[0] == Type.reference)
			return set_ref(sym, val)
		var v = variables[sym[1]]
		if (v) v[0] = val
		else set_var(sym[1], val, false)
		return val
	}],
	"setl": [[["sym", Type.symbol], ["val", Type.token]], (args, sym, val) => {
		val = resolve_token(val)
		return set_var(sym, val, true)
	}],
	"setg": [[["sym", Type.symbol], ["val", Type.token]], (args, sym, val) => {
		val = resolve_token(val)
		return set_var(sym, val, false)
	}],
	"sym": [[["token", Type.token]], (args, token) => {
		return token
	}],
	"reset": [[], (args) => {
		reset()
		enter_scene(scenes["start"])
		return [Type.boolean, true]
	}],
	"return": [[], (args) => {
		enter_scene(current_scene)
		return [Type.boolean, true]
	}],
	"back": [[["count", Type.number]], (args, count) => {
		for (var i = 0; i < (count ? count : 1); i++)
			action_stack.pop()
		subscene_change = action_stack[action_stack.length - 1]
		return [Type.boolean, true]
	}],
	"not": [[["value", Type.boolean]], (args, value) => {
		return [Type.boolean, !value]
	}],
	"and": [[], (args) => {
		for (var n of args)
			if (!(1 && get_value(n, Type.boolean))) return [Type.boolean, false]
		return [Type.boolean, true]
	}],
	"or": [[], (args) => {
		for (var n of args)
			if (0 || get_value(n, Type.boolean)) return [Type.boolean, true]
		return [Type.boolean, false]
	}],
	"print": [[["values", Type.any|TypeMod.list]], (args, values) => {
		var out = ""
		for (var v of values) out += String(v)
		insert_text(out)
		return [Type.boolean, true]
	}],
	"concat": [[["strings", Type.string|TypeMod.list]], (args, strings) => {
		var out = ""
		for (var s of strings) out += s
		return [Type.string, out]
	}],
	"if": [[["expr", Type.any],["t", Type.token],["f", Type.token]], (args, expr, t, f) => {
		return expr ? resolve_token(t) : resolve_token(f)
	}],
	"list": [[], (args) => {
		return [Type.list, args.map(x => resolve_token(x))]
	}],
	"def-fun": [[["name", Type.symbol], ["args", Type.list], ["func", Type.token|TypeMod.list]], (_, name, args, func) => {
		define_function(name, args, func)
		return [Type.boolean, true]
	}],
	"push": [[["list", Type.list],["values", Type.token|TypeMod.list]], (args, list, values) => {
		for (var v of values) list.push(resolve_token(v))
		return [Type.list, list]
	}],
	"pop": [[["list", Type.list]], (args, list) => {
		var ret = list.pop()
		return ret ? ret : [Type.boolean, false]
	}],
	"first": [[["list", Type.list|TypeMod.symbol]], (args, list) => {
		return [Type.reference, [get_token(args[0]), 0]]
	}],
	"last": [[["list", Type.list|TypeMod.symbol]], (args, list) => {
		if (!list.length) return [Type.boolean, false]
		return [Type.reference, [get_token(args[0]), list.length - 1]]
	}],
	"rest": [[["list", Type.list]], (args, list) => {
		return [Type.list, list.slice(1)]
	}],
	"index": [[["list", Type.list|TypeMod.symbol], ["index", Type.number]], (args, list, index) => {
		var i = Math.min(Math.max(index, 0), list.length - 1)
		return [Type.reference, [get_token(args[0]), i]]
	}],
	"stop": [[], (args) => {
		subscene_change = 0
		subscene_return = []
		stop = true
		return [Type.boolean, true]
	}],
	"clear": [[], (args) => {
		clear_output()
		return [Type.boolean, true]
	}],
	"scene-pop": [[], (args) => {
		var scene = scene_stack.pop()
		if (scene != undefined) enter_scene(scene)
		else return [Type.boolean, false]
		return [Type.boolean, true]
	}],
	"scene-push": [[["scene-name", Type.string]], (args, scene_name) => {
		scene_stack.push(current_scene)
		var scene = scenes[scene_name]
		if (!scene) return [Type.boolean, false]
		enter_scene(scene)
		return [Type.boolean, true]
	}],
	"scene-jump": [[["scene-name", Type.string]], (args, scene_name) => {
		var scene = scenes[scene_name]
		if (!scene) return [Type.boolean, false]
		if (subscene_change) {
			// scene change already in same expression
			subscene_return.push(scene)
		} else {
			// bit of a hack.
			var ss = subscene_return[subscene_return.length - 1]
			if (!ss || ss.index != current_index)
				subscene_return.push({source: current_source, index: current_index})
			subscene_change = scene
		}
		return [Type.boolean, true]
	}],
	"scene-change": [[["scene-name", Type.string]], (args, scene_name) => {
		var scene = scenes[scene_name]
		if (!scene) return [Type.boolean, false]
		scene_stack = []
		enter_scene(scene)
		return [Type.boolean, true]
	}],
	"rand": [[], (args) => {
		var a = resolve_token(args[0])
		if (a[0] == Type.list) {
			var l = get_value(args[0], Type.list)
			return [Type.reference, [get_token(args[0]), Math.floor(Math.random() * l.length)]]
		}
		var min = get_value(a, Type.number)
		var max = get_value(args[1], Type.number)
		return [Type.number, Math.floor(Math.random() * (max - min + 1) + min)]
	}],
	"length": [[["value", Type.any]], (args, value) => {
		if (value.length != undefined) return [Type.number, value.length]
		return [Type.boolean, false]
	}],
	"del": [[], (args) => {
		var tok = get_token(args[0])
		if (tok[0] == Type.reference) {
			var lst = resolve_token(tok[1][0])[1]
			lst.splice(tok[1][1], 1)
			return [Type.boolean, true]
		} else if (tok[0] == Type.symbol) {
			var reslv = resolve_token(tok)
			if (reslv[0] == Type.reference) {
				var lst = resolve_token(reslv[1][0])[1]
				lst.splice(reslv[1][1], 1)
				return token(true)
			} else if (reslv[0] == Type.symbol) {
				tok = reslv
			}
			delete variables[tok[1]]
			return [Type.boolean, true]
		}
		return [Type.boolean, false]
	}],
	"call": [[["name", Type.string], ["args", Type.token|TypeMod.list]], (args, name, in_args) => {
		return execute_function(name, in_args)
	}],
}

define_function("+1", "var:symbol", parse_expression("(set (get var) (+ (get var) 1))"))
define_function("-1", "var:symbol", parse_expression("(set (get var) (- (get var) 1))"))

function define_function(name, args, func) {
	var args = args instanceof Array ? args : parse_expression(args + '\n')
	var definition_args = []
	for (var p of args) {
		var to = 0
		var t = p[1][1][1]
		switch (t[0]) {
			// unfortunately due to this being a pair, ' would get converted to sym().
			// need to think about this, but for now poip.
			case "|": to = TypeMod.symbol; break
			case "#": to = TypeMod.list; break
		}
		if (to) t = t.substring(1)
		to |= Type[t]
		definition_args.push([p[1][0][1], to])
	}
	funcs[name] = [definition_args, func]
}

function execute_function(name, args) {
	var func = funcs[name]
	if (!func) {
		problem(PType.WARN, "Tried to call invalid function", name)
		return NIL
	}
	// internal
	if (func[1] instanceof Function) {
		var ia = []
		for (var i = 0; i < func[0].length; i++) {
			if (func[0][i][1] & TypeMod.list) {
				var il = []
				var lt = func[0][i][1] ^ TypeMod.list
				if (i == func[0].length - 1) {
					if (args.length == func[0].length && lt != Type.token) {
						var l = resolve_token(args[i])
						if (l[0] == Type.list) {
							var el = []
							for (var e of l[1])
								el.push(get_value(e, lt))
							ia.push(el)
							continue
						}
						il.push(get_value(args[i], lt))
						i++
					}
					for (var j = i; j < args.length; j++)
						il.push(get_value(args[j], lt))
				} else {
					var l = get_value(args[i], Type.list)
					for (var e of l[1]) il.push(get_value(e, lt))
				}
				ia.push(il)
				continue
			} else if (func[0][i][1] & TypeMod.symbol) {
				var tk = get_token(args[i])
				if (tk[0] != Type.symbol) console.log("WARN: Invalid variable argument for function", name)
				var tt = func[0][i][1] ^ TypeMod.symbol
				ia.push(get_value(tk, tt))
				continue
			}
			ia.push(get_value(args[i], func[0][i][1]))
		}
		return func[1](args, ...ia)
	} else {
		var ia = {}
		for (var i = 0; i < func[0].length; i++) {
			if (func[0][i][1] & TypeMod.list) {
				var il = []
				var lt = func[0][i][1] ^ TypeMod.list
				if (i == func[0].length - 1) {
					if (args.length == func[0].length && lt != Type.token) {
						var l = resolve_token(args[i])
						if (l[0] == Type.list) {
							ia[func[0][i][0]] = l
							continue
						}
						il.push(get_token_type(l, lt))
						i++
					}
					for (var j = i; j < args.length; j++)
						il.push(get_token_type(args[j], lt))
				} else {
					var l = get_value(args[i], Type.list)
					for (var e of l) il.push(get_token_type(e, lt))
				}
				ia[func[0][i][0]] = [Type.list, il]
				continue
			} else if (func[0][i][1] & TypeMod.symbol) {
				var tk = get_token(args[i])
				if (tk[0] != Type.symbol) console.log("WARN: Invalid variable argument for function", name)
				var tt = func[0][i][1] ^ TypeMod.symbol
				if (resolve_token(tk)[0] != tt) console.log("WARN: Invalid variable argument for function", name)
				ia[func[0][i][0]] = tk
				continue
			}
			ia[func[0][i][0]] = get_token_type(args[i], func[0][i][1])
		}
		enter_scope()
		for (var e in ia)
			set_var(e, ia[e], true)
		var res
		for (var n of func[1])
			res = resolve_token(n)
		exit_scope()
		return res
	}
}

function flatten_expression_tree(tree) {
	switch (tree[0]) {
		case Type.function:
			console.log(Type.function + ":" +tree[1][0])
			console.log(Type.list + ":" + tree[1][1].length)
			tree[1][1].forEach((x) => flatten_expression_tree(x))
			break
		case Type.symbol:
			console.log(Type.symbol + ":" + tree[1])
			break
		case Type.number:
			console.log(Type.number + ":" + tree[1])
			break
		default: console.log("Unknown type: " + tree[0])
	}
}

function parse_expression(expr) {
	var parents = []
	var parent_stack = []
	var current_node
	var string
	var sym
	var lst
	var buffer = ""
	for (var c of expr) {
		if (string) {
			if (c == string) string = null
			buffer += c
			continue
		}
		switch (c) {
			case '(':
				var n
				if (lst)
					n = [Type.list, []]
				else
					n = [Type.function, [funcs[buffer] ? buffer : "", []]]
				lst = false
				if (current_node) {
					parent_stack.push(current_node)
					switch (current_node[0]) {
						case Type.function: current_node[1][1].push(sym ? [Type.function, ['sym', [n]]] : n); break
						case Type.list: current_node[1].push(sym ? [Type.function, ['sym', [n]]] : n); break
						default: console.log("WARN: Invalid parent type", current_node[0])
					}
				} else {
					parents.push(n)
				}
				current_node = n
				buffer = ""
				break
			case ')':
				if (!current_node) {
					problem(PType.FAIL, "Unbalanced ) in expression '", expr, "'.")
					return [] // empty
				}
				if (buffer) {
					if (current_node[0] == Type.function && !current_node[1][0]) {
						current_node[1][0] = buffer
						if (!funcs[buffer])
							problem(PType.WARN, "Invalid function:", buffer)
					} else {
						var tk = token(buffer)
						if (sym) {
							tk = [Type.function, ['sym', [tk]]]
							sym = false
						}
						switch (current_node[0]) {
							case Type.function: current_node[1][1].push(tk); break
							case Type.list: current_node[1].push(tk); break
						}
					}
				}
				current_node = parent_stack.pop()
				buffer = ""
				break
			case ' ': case '\t': case '\n':
				if (!buffer) break
				var tk = token(buffer)
				if (sym) {
					tk = [Type.function, ['sym', [tk]]]
					sym = false
				}

				if (!current_node) {
					parents.push(tk)
				} else {
					switch (current_node[0]) {
						case Type.function:
							if (!current_node[1][0]) {
								current_node[1][0] = buffer
								if (!funcs[buffer])
									problem(PType.WARN, "Invalid function:", buffer)
							} else {
								current_node[1][1].push(tk)
							}
							break
						case Type.list:
							current_node[1].push(tk)
							break
					}
				}
				buffer = ""
				break
			case "'": sym = true; break
			case "#": lst = true; break
			case '"': string = c
			default: if (lst) { buffer += '#'; lst = false }
				buffer += c
		}
	}
	if (current_node) {
		if (string) problem(PType.FAIL, "Unterminated string in expression\n'", expr, "'.")
		else problem(PType.FAIL, "Unbalanced parenthesis in expression at\n'", expr, "'.")
		return [] // empty
	}
	return parents
}

const PType = {
	INFO: 0,
	WARN: 1,
	FAIL: 2,
}

function problem(problem_type, ...message) {
	message = message.join(" ")
	var prefix = ""
	var output = play_chunks.STGE["report-problems"]
	switch (problem_type) {
		case PType.FAIL:
			output = stop = true
			prefix = "[FAILURE]"
			break;
		case PType.WARN:
			prefix = "[WARNING]"
			break;
		case PType.INFO:
			prefix = "[INFO]"
			break;
		default:
			console.log("Invalid problem type: ", problem_type)
			break;
	}
	console.log(prefix, message)
	if (output) insert_text(`b<${prefix}> ${message}`)
}

function reset() {
	variables = {}
	var_scopes = {}
	action_depth = 0
	scope_depth = 0
	clear_output()
	scene_stack = []
}

/* -------------- */
/* FRONT HANDLING */
/* -------------- */

function clear_output() {
	output.replaceChildren()
	if (play_chunks.STGE["action-separation"]) {
		output.appendChild(text_output = document.createElement("div"))
		output.appendChild(action_output = document.createElement("div"))
	} else {
		text_output = output
		action_output = output
	}
}

function file_drop(e) {
	e.preventDefault();
	if (e.dataTransfer.files[0])
		play_file(e.dataTransfer.files[0])
}

function drag_over(e) {
	e.preventDefault()
}

function submit_file(e) {
	play_file(e.target.files[0])
}

function parse_play(play_in) {
	play_chunks = {}
	var length = play_in.length
	var sind = 0
	var eind = play_in.indexOf("\n")
	var line = play_in.substring(sind, eind)
	sind = eind + 1
	if (line != "STAGE PLAY") {
		problem(PType.FAIL, "'STAGE PLAY' is not 'STAGE PLAY'")
		return
	}
	var chunk = ""
	var chunk_end = ""
	while (line != "END" && sind != 0) {
		eind = play_in.indexOf("\n", sind)
		line = play_in.substring(sind, eind).trim()
		sind = eind + 1
		if (chunk) {
			if (line == chunk_end) {
				chunk = ""
				continue
			} else if (!line.trim()) {
				continue
			}
			line = line.split(":")
			var f = line[0]
			var v = line[1]
			play_chunks[chunk][f] = v.trim()
		} else {
			if (!play_chunks[line]) {
				play_chunks[line] = {}
				chunk = line
				chunk_end = line.split("").reverse().join("") // replace with something better.
			} else {
				problem(PType.WARN, "Duplicate chunk in PLAY, will be ignored.")
			}
		}
	}
	
	for (var k of Object.keys(play_chunks.STGE)) {
		var val = play_chunks.STGE[k]
		if (bool_re.exec(val))
			play_chunks.STGE[k] = val.startsWith("t") || val.startsWith("y")
	}

	if (play_chunks.STGE?.version) {
		// version check
	}

	play_chunks.STGE["action-clear"] = play_chunks.STGE["action-clear"] ?? false
	play_chunks.STGE["action-separation"] = play_chunks.STGE["action-separation"] ?? false
	play_chunks.STGE["report-problems"] = play_chunks.STGE["report-problems"] ?? false

	return sind
}

function parse_legacy_play(play_in) {
	console.log("WARN: Legacy play format is deprecated and may be removed in a future version.")
	var index = -1

	play_chunks = {"STGE": {
		"action-clear": false,
		"action-separation": false,
		"report-problems": false
	}}

	variables = {}
	action_depth = 0
	clear_output()
	scene_stack = []
	scenes = []
	sources["play"] = play_in
	while ((index = play_in.indexOf("START ", index + 1)) != -1) {
		var buffer = ""
		index += 5
		while (play_in[++index] != '\n') buffer += play_in[index]
		scenes[buffer] = {source: "play", index: index};
	}

	if (!scenes["start"]) {
		scenes["start"] = {source: "play", index: 0}
		return true
	}
	return false
}

function play_determine(play_in) {
	var magic = play_in.substring(0, 10)
	if (magic == "STAGE PLAY") {
		let end_index = parse_play(play_in)
		sources[".play"] = play_in
		if (!play_chunks.SCNE || Object.keys(play_chunks.SCNE).length <= 0) {
			problem(PType.WARN, "SCNE chunk missing or empty, starting from zero index.")
			scenes["start"] = {source: ".play", index: end_index}
		} else {
			for (var k of Object.keys(play_chunks.SCNE)) {
				var i = parseInt(play_chunks.SCNE[k]) + end_index
				scenes[k] = {source: ".play", index: i}
			}
		}
	} else {
		parse_legacy_play(play_in)
	}

	document.getElementById("load")?.remove()
	reset()
	enter_scene(scenes["start"])
}


async function plz_decompress(manif, blob) {
	let cc = await blob.slice(manif.start, manif.start + manif.size)
	if (manif.compression_method == 0) return cc.stream()
	const deflate_decompression = new DecompressionStream("deflate-raw")
	let content = cc.stream().pipeThrough(deflate_decompression)
	return content
}

const plz_preprocess = [
	async (manif, blob) => {
		if (manif.ext != "play") return true
		let content_stream = await plz_decompress(manif, blob)
		for await (const chunk of content_stream) {
			let play_in = new TextDecoder().decode(chunk)
			let eind = parse_play(play_in)
			if (play_chunks.SCNE) sources[".play"] = play_in.slice(eind)
			break
		}
		return false
	},
	(manif, blob) => (manif.size > 0)
]

const plz_consumers = {
	sceneconsumer: {
		accept(manif) {
			return manif.ext == "scene"		
		},
		async consume(manif, blob) {
			let content_stream = await plz_decompress(manif, blob)
			for await (const chunk of content_stream) {
				sources[manif.extless] = new TextDecoder().decode(chunk)
				break
			}
		}
	}
}

const plz_post = [
	() => {
		if (play_chunks.SRCS) {
			if (!play_chunks.SCNE) {
				problem(PType.WARN, "To use SRCS chunk you MUST include a SCNE chunk.")
			} else {
				Object.entries(play_chunks.SCNE).forEach(([k,v]) => {
					var i = parseInt(v)
					if (play_chunks.SRCS[k]) {
						scenes[k] = {source: play_chunks.SRCS[k], index: i}
					} else {
						scenes[k] = {source: ".play", index: i}
					}
				})
			}
		} else {
			if (play_chunks.SCNE) {
				for (var k of Object.keys(play_chunks.SCNE)) {
					var i = parseInt(play_chunks.SCNE[k])
					scenes[k] = {source: ".play", index: i}
				}
			}
			Object.keys(sources).forEach(k => (k != ".play" && (scenes[k] = {source: k, index: 0})))
		}
	}
]

async function plz_parse(blorb) {
	const buffer = await blorb.arrayBuffer()
	const view = new DataView(buffer)
	let position = 0
	const read = {
		"u32": () => (position+=4,view.getUint32(position - 4, true)),
		"u16": () => (position+=2,view.getUint16(position - 2, true)),
		"u8": () => (position++,view.getUint8(position - 1, true)),
		"ascii": (l) => (String.fromCharCode.apply(null, new Uint8Array(buffer.slice(position, position += l)))),
		"utf8": (l) => (position++,view.getUint8(position - 1, true))
	}
	let manifests = []
	let play_files = []
	let signature = read.u32()
	while (signature == 0x04034b50) {
		if (read.u16() > 20) console.log("ZIP version > 20, might be a problem.")
		if (read.u16() != 0) console.log("general purpose flag != 0, might be a problem.")
		let compression_method = read.u16()
		read.u16() // modification time, ignore
		read.u16() // modification date, ignore
		read.u32() // CRC, ignore
		let compressed_size = read.u32()
		let uncompressed_size = read.u32()
		let filename_l = read.u16()
		let extrafield_l = read.u16()
		let filename = read.ascii(filename_l)
		let dot = filename.lastIndexOf(".") + 1
		let extension = dot > 0 ? filename.slice(dot).toLowerCase() : ""
		position += extrafield_l // skip extra field
		let manif = {
			"name": filename,
			"extless": filename.slice(0, dot - 1),
			"ext": extension,
			"start": position,
			"size": compressed_size,
			"file_size": uncompressed_size,
			"compression_method": compression_method
		}

		let cont = true
		for (p of plz_preprocess) cont &&= await p(manif,blorb)
		cont && manifests.push(manif)
		position += compressed_size // skip file for now

		signature = read.u32()
	}
	// Central Directory
	while (signature == 0x02014b50) {
		read.u16()//console.log("version made by", read.u16())
		read.u16()//console.log("version needed", read.u16())
		read.u16()//console.log("gpf", read.u16())
		read.u16()//console.log("cm", read.u16())
		read.u16()//console.log("mt", read.u16())
		read.u16()//console.log("md", read.u16())
		read.u32()//console.log("crc", read.u32())
		read.u32()//console.log("cs", read.u32())
		read.u32()//console.log("us", read.u32())
		let filename_l = read.u16()
		let extrafield_l = read.u16()
		let comment_l = read.u16()
		read.u16()//console.log("dn", read.u16())
		read.u16()//console.log("fa", read.u16())
		read.u32()//console.log("efa", read.u32())
		read.u32()//console.log("ro", read.u32())
		read.ascii(filename_l)//console.log("fn", read.ascii(filename_l))
		position += extrafield_l
		read.ascii(comment_l)//console.log("fc", read.ascii(comment_l))

		signature = read.u32()
	}
	// End of CD
	if (signature == 0x06054b50) {
		// read this.
	}

	let consumers = Object.values(plz_consumers) 
	for (manif of manifests) {
		for (c of consumers) {
			if (c.accept(manif)) await c.consume(manif, blorb)
		}
	}
	plz_post.forEach(p => p())

	document.getElementById("load")?.remove()
	reset()
	enter_scene(scenes["start"])
}

function play_file(file) {
	// HACK HACK HACK
	if (!file.name) {
		file.text().then(t => (play_determine(t)))
		return
	}
	// END OF HACK HACK HACK
	var d = file.name.lastIndexOf(".") + 1
	var ext = d >= 0 ? file.name.slice(d).toLowerCase() : null
	switch (ext ?? file.type) {
		case "plz": case "zip": case "application/zip":
			plz_parse(file)
			break;
		case "play": case "txt": case "scene": case "text/plain": 
			file.text().then(t => (play_determine(t)))
			break;
		default:
			alert("Unrecognised or unsupported file type.")
	}
}

window.onload = e => {
	container = document.getElementById("container")
	output = document.getElementById("output")
	var params = new URLSearchParams(window.location.search);
	var l = params.get('gist')
	if (l) {
		fetch(`https://api.github.com/gists/${l}`, {cache: "no-cache"})
			.then(response => response.json())
			.then(json => play_determine(Object.values(json.files)[0].content))
		return
	}

	l = params.get('load')
	if (l) {
		fetch(l, {cache: "no-cache"})
			.then(response => response.blob())
			.then(play_file)
		return
	}
}