main-en.strand

::start
// some info for if you want to mod it:
//
// basic syntax examples:
// 	::passage title
// 	[[basic link]]
// 	[[link with different label>passage title]]
// 	[[link with different action|this.something=true;this.goto('passage title');]]
// 	<<if this.something>><<elseif this.somethingElse>><<endif>>
// 	<<do this.something=true;>>
// 	<<print this.something>>
// 	>passage break
//
// js examples:
// 	this.goto('passage')
// 	this.show('texture', { duration, x, y, scale, animate, freq })
// 	this.scrim(amount, duration)
// 	this.tween(object, 'property', to, duration, from, ease)
// 	this.gameObject - npc/interrupt that triggered the dialog
// 	this.scene      - game scene
// 	this.voice      - audio to play as letters tick in
// 	this.ease       - easing functions
//
// game object stuff:
// 	this.Area(name, [objects])
// 	this.Npc({ passage, x, y )
// 	this.Goto({ area, x, y }, { x, y, width, height })
// 	this.Prop({ texture, x, y, alpha, scale, flip, blur, animate, offset })
// 	this.PropParallax({ texture, alpha, scale, flip, blur, mult, animate, offset }),
// 	this.Block({ x, y, width, height, type, radius })
// 	this.Poly({ x, y, width, verts })
// 	this.Interrupt({ passage, x, y, width, height })

<<if !this.started>>
<<do
	// middle mouse click to go back in debug
	if (this.debug && !window.debugBack) {
		window.debugBack = true;
		window.addEventListener('pointerdown', (event) => {
			if (event.button === 1) {
				window.scene.strand.back();
			}
		});
	}

	const PropParallaxAuto = (options) => {
		const start = Date.now();
		const gameObject = this.PropParallax(options);
		gameObject.scripts.push({
			gameObject,
			update() {
				gameObject.spr.tilePosition.x = (Date.now()-start)/1000 * options.speed;
			},
		});
		return gameObject;
	};


	// text helper
	this.texttimeouts = [];
	this.PText = (text, delay = 0, offset = 0) => {
		const timeout = setTimeout(() => {
			this.sfx('voiceDefault');
			const t = this.Text(text, { x: player.transform.x, y: player.transform.y - 20 + offset, offset: this.texttimeouts.length * 100 });
			t.scripts[1].container.children[0].anchor.x = 0.5;
			this.add(t);
		}, delay);
		this.texttimeouts.push(timeout);
	};

	this.Area('empty', []);

	// start
	this.started=true;
	this.scene.goto({ area: 'empty' });
	requestAnimationFrame(() => {
		this.scrim(1, 3000);
		this.scene.dialogue.sprBg.alpha = 0;
	});
	this.show('title');
>>
<<endif>>
[[New game]]
[[About]]

::About
Made by

Michael,
Sean,
IAN,
and Ryan

of SweetHeart Squad

for Global Game Jam 2023!
[[Back|this.back()]]

::New game
<<do
	this.music('bgm', { fade: 100 });
	this.show('').then(() => {this.goto('start2')});
>>

::start2
<<do
	this.tween(this.scene.border.display.container, 'alpha', 1, 5000);
	this.tween(this.scene.dialogue.sprBg, 'alpha', 1, 5000, 0);;
	this.goto('main');
>>

::close
this should never render

::choiceDefault
...

::interact
interact

::grab
grab

::open
open

::dump
dump


::endGood
WHAT'S THIS...

veggies: <<print this.score>>

A PERFECT SOUP!!

YOU WIN!!

[[Restart|this.restart()]]

::endBad
GAME OVER

veggies: <<print this.score>>
<<if this.score > 10>>
SO CLOSE!!
<<elseif this.score > 9>>
ALMOST PERFECT!
<<elseif this.score > 5>>
DECENT SOUP.
<<elseif this.score > 1>>
NOT GREAT...
<<elseif this.score = 1>>
BARELY A SOUP!!
<<endif>>


[[Restart|this.restart()]]

::debug menu
<<do
	this.scene.strand.passages['area warp'] = { title: 'area warp', body: Object.keys(this.scene.areas).filter(i => i !== 'root').map(i => '[['+i+'|this.scene.goto({ area: "'+i+'" }); this.goto("close")]]').concat('[[back|this.back()]]').join('\n') };
>>
[[passage select>passage select]]
[[language select]]
[[area warp]]
[[teleport|
	const canvas = window.game.app.renderer.context.gl.canvas;
	const verts = [];
	const onClick = (event) => {
		if (event.button !== 0) return;
		event.preventDefault();
		event.stopPropagation();
		this.scene.player.canMove = false;
		setTimeout(() => this.scene.player.canMove = true, 100);
		const p = this.mousePos(event);
		this.scene.player.setPosition(p.x, p.y);
	};
	const onContextMenu = (event) => {
		event.preventDefault();
		canvas.removeEventListener('pointerdown', onClick);
		canvas.parentElement.style.cursor = 'inherit';
	};
	requestAnimationFrame(() => {
		canvas.addEventListener('pointerdown', onClick);
		canvas.addEventListener('contextmenu', onContextMenu, { once: true });
	});
	canvas.parentElement.style.cursor = 'crosshair';
	this.goto('close');
]]
[[toggle debugPhysics|window.debugPhysics=!window.debugPhysics]]
[[toggle player collision|this.scene.player.bodyCollision.body.isSensor = !this.scene.player.bodyCollision.body.isSensor]]
[[drawing tools]]
[[close]]
[[back|this.back()]]

::drawing tools
[[get coords|
	const canvas = window.game.app.renderer.context.gl.canvas;
	const onClick = (event) => {
		if (event.button !== 0) return;
		event.preventDefault();
		event.stopPropagation();
		this.scene.player.canMove = false;
		setTimeout(() => this.scene.player.canMove = true, 100);
		const p = this.mousePos(event);
		navigator.clipboard.writeText(`x: ${Math.floor(p.x)}, y: ${Math.floor(p.y)}`);
		console.log(`x: ${Math.floor(p.x)}, y: ${Math.floor(p.y)}`);
	};
	const onContextMenu = (event) => {
		event.preventDefault();
		canvas.removeEventListener('pointerdown', onClick);
		canvas.parentElement.style.cursor = 'inherit';
	};
	requestAnimationFrame(() => {
		canvas.addEventListener('pointerdown', onClick);
		canvas.addEventListener('contextmenu', onContextMenu, { once: true });
	});
	canvas.parentElement.style.cursor = 'crosshair';
	this.goto('close');
]]
[[place props|
	const canvas = window.game.app.renderer.context.gl.canvas;

	const textures = () => Array.from(resources._cache.entries()).filter(([k,r]) => !k.match(/\.[2-9]\d*?$/) && !k.match(/^https?:/) && r?.baseTexture);

	let tex = 0;
	const spr = new this.PIXI.Sprite();
	spr.anchor.x = 0.5;
	spr.anchor.y = 1.0;
	this.scene.container.addChild(spr);
	const onWheel = (event) => {
		if (!event.deltaY) return;
		const d = Math.sign(event.deltaY);
		tex += d;
		const ts = textures();
		if (tex < 0) tex = ts.length - 1;
		tex %= ts.length;
		console.log(ts[tex][0]);
		spr.texture = ts[tex][1];
	};
	const onMove = (event) => {
		const p = this.mousePos(event);
		spr.x = Math.floor(p.x);
		spr.y = Math.floor(p.y);
	};
	const placed = [];
	let flip = false;
	const onClick = (event) => {
		if (event.button !== 0) return;
		event.preventDefault();
		event.stopPropagation();
		this.scene.player.canMove = false;
		setTimeout(() => this.scene.player.canMove = true, 100);
		if (event.ctrlKey) {
			if (placed.length) {
				const p = placed.pop();
				this.remove(p);
			}
			return;
		}
		if (event.shiftKey) {
			flip = !flip;
			spr.scale.x = flip ? -1 : 1;
			return;
		}
		const p = this.mousePos(event);
		const prop = this.Prop({ texture: textures()[tex][0], x: Math.floor(p.x), y: Math.floor(p.y), flip });
		placed.push(prop);
		this.add(prop);
	};
	const onContextMenu = (event) => {
		event.preventDefault();
		canvas.removeEventListener('wheel', onWheel);
		canvas.removeEventListener('pointerdown', onClick);
		canvas.removeEventListener('pointermove', onMove);
		canvas.parentElement.style.cursor = 'inherit';
		spr.destroy();
		const str = placed.map(p => `this.Prop({ texture: '${p.spr.texture.textureCacheIds[1]}', x: ${Math.floor(p.transform.x)}, y: ${Math.floor(p.transform.y)}${p.spr.scale.x < 0 ? ', flip: true' : ''} }),`).join('\n');
		navigator.clipboard.writeText(str);
		console.log(str);
	};
	requestAnimationFrame(() => {
		canvas.addEventListener('wheel', onWheel);
		canvas.addEventListener('pointerdown', onClick);
		canvas.addEventListener('pointermove', onMove);
		canvas.addEventListener('contextmenu', onContextMenu, { once: true });
	});
	canvas.parentElement.style.cursor = 'crosshair';
	this.goto('close');
]]
[[draw walls|
	if (!window.debugPhysics) window.debugPhysics=true;
	const canvas = window.game.app.renderer.context.gl.canvas;
	const verts = [];
	let poly;

	const getPos = (event) => {
		const p = this.mousePos(event);
		return [Math.round(p.x),Math.round(p.y)];
	};
	const makePoly = () => {
		if (poly) {
			this.destroy(poly);
		}
		if (verts.length > 0) {
			poly = this.Poly({ verts: verts.flat() }, { plugin: { interactive: true }});
			// this.add(poly);
		} else {
			poly = null;
		}
	};

	const onMove = (event) => {
		if (event.ctrlKey) return;
		event.preventDefault();
		event.stopPropagation();
		verts.pop();
		verts.push(getPos(event));
		makePoly();
	};
	const onClick = (event) => {
		if (event.button !== 0) return;
		event.preventDefault();
		event.stopPropagation();
		this.scene.player.canMove = false;
		setTimeout(() => this.scene.player.canMove = true, 100);
		if (event.ctrlKey) {
			verts.pop();
		} else {
			verts.push(getPos(event));
		}
		makePoly();
		canvas.addEventListener('pointermove', onMove);
		canvas.addEventListener('pointerup', () => {
			canvas.removeEventListener('pointermove', onMove);
		}, { once: true });
	};
	const onContextMenu = (event) => {
		event.preventDefault();
		canvas.removeEventListener('pointerdown', onClick);
		canvas.removeEventListener('pointermove', onMove);
		canvas.parentElement.style.cursor = 'inherit';
		if (poly) {
			navigator.clipboard.writeText(`this.Poly({ verts: [${verts.map(i => i.join(',')).join(', ')}] }),`);
			console.log(`this.Poly({ verts: [${verts.map(i => i.join(',')).join(', ')}] }),`);
			this.scene.drop(poly);
		}
	};
	requestAnimationFrame(() => {
		canvas.addEventListener('pointerdown', onClick);
		canvas.addEventListener('contextmenu', onContextMenu, { once: true });
	});
	canvas.parentElement.style.cursor = 'crosshair';
	this.goto('close');
]]
[[back|this.back()]]

::main
<<do
	this.texttimeouts.forEach((t) => clearTimeout(t));
	this.texttimeouts.length = 0;

	this.tween(this.scene.feed.display.container, 'alpha', 1, 1000);

	if (this.scene.areas.main) {
		this.scene.areas.main.forEach(i => {
			this.destroy(i);
		});
		if (this.scene.area === 'main') {
			this.scene.goto({ area: 'empty' });
		}
	}
	// setup rubble follower
	const itemFollower = this.Npc({ shadow: false, body: '', x: 50, y: 50, bodyCollision: { isSensor: true } });
	this.scene.player.follow(itemFollower);
	itemFollower.display.container.visible = false;
	itemFollower.roam.range[0] = 0;
	itemFollower.roam.range[1] = 0;
	itemFollower.roam.changeOffset = Infinity;
	itemFollower.roam.offset.y = 10;
	itemFollower.spr.pivot.y = this.scene.player.display.container.height / 2;
	itemFollower.roam.offset.x = -this.scene.player.display.container.width / 4;
	itemFollower.speed = 8;
	this.itemFollower = itemFollower;
	this.scene.player.scripts.push({
		gameObject: this.itemFollower,
		update: () => {
			itemFollower.roam.offset.x = (this.scene.player.flipped? 1 : -1) * Math.abs(itemFollower.roam.offset.x);
		},
	});

	// main game variables
	const timeMax = 120 * 1000;
	let time = timeMax;
	const spawnRate = [500, .01];
	const postRate = [300, .02];
	const guestsMaxWaiting = 10;
	this.stats = {
		cold: 50,
		hunger: 0,
		thirst: 0,
		busy: 0,
		bland: 0,
		dry: 0,
	};
	const statRates = {
		cold: 1,
		hunger: 4,
		thirst: 4,
		busy: 1,
		bland: 2,
		dry: 2,
	};
	const intervals = [];
	intervals.push(setInterval(() => {
		Object.keys(this.stats).forEach(i => {
			if (i === 'busy') return;
			this.stats[i] = this.fairmath(this.stats[i], statRates[i]);
		});
		this.stats.busy = this.fairmath(this.stats.busy, this.guestsWaiting.length || -1);
	}, 1000));

	this.poolPos = {x: 200, y: -580 };
	const pointInPool = () => {
		let {x,y} = this.randCirc(400);
		y*=0.7;
		x += this.poolPos.x;
		y += this.poolPos.y;
		return {x,y};
	};
	const spawnInPool = (p) => {
			const {x,y} = pointInPool();
			p.transform.x += x;
			p.transform.y += y;
	};

	const doorProp = this.Prop({ texture: 'door', x: 221, y: -1150, offset: -66, });

	function componentToHex(c) {
		const hex = Math.round(c).toString(16);
		return hex.length == 1 ? "0" + hex : hex;
	}

	function rgbToHex(r, g, b) {
		return parseInt(`0x${componentToHex(r)}${componentToHex(g)}${componentToHex(b)}`, 16);
	}
	const waterProp = this.Prop({ texture: 'hottubWater', x: 212, y: -204, offset: -700 });
	this.scene.player.scripts.push({
		gameObject: this.scene.player,
		update: () => {
			waterProp.spr.pivot.y = (1 - this.stats.dry/100) * 40;
			const g = this.stats.bland/100;
			waterProp.spr.tint = rgbToHex(this.lerp(31, 70, g), this.lerp(58, 113, g), this.lerp(132, 12, g));
			waterProp.spr.alpha = 1-g*0.5;
		},
	});


	const propMeat = this.Prop({ texture: 'stationHungerIdle', x: 540, y: -1018, offset: 80 });
	this.scene.player.scripts.push({
		gameObject: this.scene.player,
		update: () => {
			propMeat.display.container.visible = this.stats.hunger < 50;
		},
	});
	const propDrink = this.Prop({ texture: 'stationThirstIdle', x: 702, y: -934, offset: 40 });
	this.scene.player.scripts.push({
		gameObject: this.scene.player,
		update: () => {
			propDrink.display.container.visible = this.stats.thirst < 50;
		},
	});
	this.propLid = this.Prop({ texture: 'hottubLid', x: 212, y: -204, offset: 20000 });
	this.propLid.display.container.alpha = 0;

	const sweat = this.Emitter({ rate: () => !this.scene.player.running ? 5000 : this.lerp(40, 250, this.ease.circIn(time / timeMax)), offset: this.scene.player.display.container.height, texture: 'sweatDrip', time: 1000, spawn: (p) => {
		p.spr.scale.x = this.scene.player.flipped ? -1 : 1;
		p.transform.x += this.scene.player.display.container.width/6 * p.spr.scale.x;
		let pp = this.randCirc(25);
		p.transform.x += pp.x;
		p.transform.y += pp.y;
		pp = this.randCirc(50);
		this.tween(p.display.container, 'alpha', 0, 200);
		this.tween(p.transform, 'x', p.transform.x + Math.abs(pp.x) * Math.sign(p.spr.scale.x), 200);
		this.tween(p.transform, 'y', p.transform.y - Math.abs(pp.y), 200);
	}, });
	this.scene.player.scripts.push({
		gameObject: sweat,
		update: () => {
			sweat.transform.x = this.scene.player.transform.x;
			sweat.transform.y = this.scene.player.transform.y - this.scene.player.display.container.height * 0.8;
		},
	});

	const walla = this.Audio({
		sfx: 'walla',
		x: this.poolPos.x,
		y: this.poolPos.y,
		volume: 1,
		refDistance: 1,
		maxDistance: Math.max(this.size.x, this.size.y),
		rolloffFactor: 1,
	});
	this.scene.player.scripts.push({
		gameObject: walla,
		update: () => {
			walla.volume = this.gameover ? 0 : this.ease.cubicIn(this.clamp(0, this.guests.length / 12, 1));
		},
	});

	this.Area('main', [
		this.Prop({ texture: 'groundGrass', x: 300, y: 200, offset: -100000 }),
		// walls
		this.PropParallax({ texture: 'pastEdge', offset: -1000000, mult: 1 }),
		this.Prop({ texture: 'edges', x: 300, y: 200, offset: 10000 }),
		this.Poly({ verts: [384,-1204, 604,-1175, 749,-1217, 861,-1191, 1017,-1253, 1201,-1377, 1467,-1361, 1663,-1179, 1662,-1090, 1750,-949, 1762,-777, 1718,-680, 1722,-637, 1794,-520, 1786,-450, 1746,-378, 1766,-317, 1786,-241, 1758,-129, 1754,32, 1571,181, 1271,152, 963,183, 543,184, 247,176, 19,184, -261,178, -549,193, -745,141, -1013,109, -1228,-29, -1243,-210, -1243,-521, -1246,-688, -1208,-825, -1240,-970, -1196,-1033, -1232,-1121, -1119,-1223, -978,-1271, -842,-1214, -724,-1133, -415,-1152, -227,-1176, -60,-1207] }),

		this.Prop({ texture: 'bushAndPump', x: 245, y: -93, offset: -50 }),
		this.Poly({ verts: [-32,-87, -142,-119, -234,-180, -173,-252, 200,-206, 544,-281, 637,-323, 732,-210, 662,-129, 456,-117, 333,-127, 225,-104, 112,-98, 54,-94, -30,-86] }),

		walla,
		this.Prop({ texture: 'poolSkimmer', x: -159, y: -173 }),
		this.Prop({ texture: 'poolCover', x: 797, y: -231, offset: -125 }),
		this.Poly({ verts: [599,-292, 784,-232, 1013,-375, 777,-409, 598,-291] }),

		doorProp,
		this.Poly({ verts: [-200,-1237, 669,-1231] }),
		this.Npc({ x: doorProp.transform.x, y: doorProp.transform.y, passage: 'door', bodyCollision: { isSensor: true }, bodySensor: { plugin: { label: 'open' } } }),
		this.Prop({ texture: 'hottub', x: 212, y: -204, offset: -700 }),
		waterProp,
		this.Prop({ texture: 'hottubWall', x: 212, y: -204, offset: -650 }),
		this.Poly({ verts: [240,-885, -199,-862, -291,-823, -337,-710, -343,-555, -335,-395, -236,-295, -172,-251] }),
		this.Poly({ verts: [240,-885, 477,-879, 631,-850, 721,-795, 772,-678, 791,-524, 780,-406] }),
		this.propLid,
		
		// wood and fire related
		this.Prop({ texture: 'furnaceBackBlack', x: -229, y: -282, offset: -1 }),
		this.Prop({ texture: 'fire', x: -229, y: -282 }),

		this.Emitter({ y: -70, rate: () => this.stats.cold < 70 ? 30 : this.lerp(30, 500, (this.stats.cold-70)/30), texture: 'smallBubble1', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ y: -70, rate: () => this.stats.cold < 70 ? 40 : this.lerp(40, 600, (this.stats.cold-70)/30), texture: 'smallBubble2', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ y: -70, rate: () => this.stats.cold < 70 ? 50 : this.lerp(50, 700, (this.stats.cold-70)/30), texture: 'smallBubble3', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ y: -70, rate: () => this.stats.cold > 70 ? 5000 : this.lerp(15, 5000, this.ease.circIn(this.stats.cold/70)), texture: 'bubbles1', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ y: -70, rate: () => this.stats.cold > 70 ? 6000 : this.lerp(15, 6000, this.ease.circIn(this.stats.cold/70)), texture: 'bubbles2', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ y: -70, rate: () => this.stats.cold > 70 ? 7000 : this.lerp(15, 7000, this.ease.circIn(this.stats.cold/70)), texture: 'bubbles3', freq: 1/100, spawn: spawnInPool, }),
		this.Emitter({ rate: () => this.gameover ? Infinity : this.lerp(20, 500, this.ease.circIn(this.stats.cold/100)), x: -185, y: -710, offset: 1000, texture: 'smoke', time: 3000, spawn: (p) => {
			const {x,y} = this.randCirc(25);
			p.transform.y += y*0.5;
			p.transform.x += x*0.5;
			this.tween(p.display.container.scale, 'x', 2, 500);
			this.tween(p.display.container.scale, 'y', 1.25, 500);
			this.tween(p.display.container, 'alpha', 0, 500);
			this.tween(p.transform, 'y', p.transform.y + y, 500);
			this.tween(p.transform, 'x', p.transform.x + x, 500);
		}, }),
		sweat,

		propMeat,
		propDrink,


		...this.Station({ type: 'Cold', out: { x: -953, y: -1039 }, in: { x: -229, y: -282, colliderSize: 1.5 }, inPos: { x: -20, y: -50 } }),
		this.Prop({ texture: 'woodPile', x: -1015, y: -1080, offset: -50 }),
		this.Poly({ verts: [-1054,-1139, -934,-1141] }),
		...this.Station({ type: 'Thirst', out: { x: 1282, y: -34, colliderSize: 2 }, in: { x: 709, y: -820, offset: -90 }, outPos: { y: -50 }, inPos: { y: -50 } }),
		this.Poly({ verts: [1308,-41, 1156,-80, 1242,-150, 1392,-70, 1307,-43] }),
		...this.Station({ type: 'Hunger', out: { x: -853, y: -32, colliderSize: 3 }, in: { x: 520, y: -890, offset: -50 }, outPos: { y: -50, x: -20 }, inPos: { y: -50 } }),
		this.Poly({ verts: [-699,-83, -888,-17, -1040,-133, -916,-163, -702,-82] }),
		...this.Station({ type: 'Dry', out: { x: 1303, y: -1220 }, in: { x: -125, y: -920 } }),
		this.Poly({ verts: [1239,-1239, 1381,-1240] }),
		...this.Station({ type: 'Bland', out: { x: -1159, y: -256, colliderSize: 1.5 }, in: { offset: -100, x: -280, y: -826 } }),
		itemFollower,
	]);


	// spawn npcs
	const guestsGap = 40;
	this.guestsWaiting = [];
	this.guests = [];
	const guestTypes = Array.from(window.resources._cache.keys()).filter(i => i.startsWith('guest') && i.endsWith('Idle')).map(i => i.replace('Idle', ''));
	const postTypes = Object.keys(this.stats).filter(i => i !== 'busy').concat('random');
	let lastPost = Date.now();
	let allowMoreGuests = Date.now() + 5000;
	intervals.push(setInterval(() => {
		if (this.gameover) return;
		if (this.guestsWaiting.length > guestsMaxWaiting) return;
		if (this.guests.length && (Date.now() < allowMoreGuests || Math.random() * Object.values(this.stats).reduce((a,i) => a + i, 0)/(100 * Object.keys(this.stats).length) > spawnRate[1])) return;
		const npcType = this.randItem(guestTypes);
		this.guests.push(npcType);
		const npc = this.scene.addGuestToPool(npcType);
		this.guestsWaiting.push(npc);

		const p = pointInPool();
		npc.roam.target.x = doorProp.transform.x;
		npc.roam.target.y = doorProp.transform.y - 100 - this.guestsWaiting.length * guestsGap;
		npc.setPosition(doorProp.transform.x, Math.min(npc.roam.target.y, doorProp.transform.y) - 200);
		npc.display.container.alpha = 0;
		this.tween(npc.display.container, 'alpha', 1, 200);
		npc.roam.range[0] = guestsGap/2;
		npc.roam.range[1] = 1;
		npc.roam.freq = {
			value: 500,
			range: 400,
		};
		npc.waiting = true;
		npc.bodyCollision.body.isSensor = true;
		npc.speed = 0.5;

		// send posts
		setTimeout(() => {
			if (this.gameover) return;
			intervals.push(setInterval(() => {
				if (this.gameover) return;
				if (Date.now() - lastPost < 4000 && Math.random() > postRate[1]) return;
				let category = npc.waiting ? 'waiting' : this.randItem(postTypes);
				if (this.stats[category] !== undefined && this.stats[category] < 35) category = `not-${category}`;
				const post = this.execute(this.getPassageWithTitle(`guest-${category}`).program)[0].value;
				this.scene.feed.say(post, `${npcType}Idle`);
				lastPost = Date.now();
			}, postRate[0]));
		}, this.randRange(0, postRate[0]));
		if (this.guests.length === 1) {
			this.scene.feed.say(this.execute(this.getPassageWithTitle(`first-post`).program)[0].value, `${npcType}Idle`);
		}
	}, spawnRate[0]));

	let doorTimeout = null;
	this.letGuestIn = async () => {
		this.sfx('door open', { rate: this.randRange(0.9, 1.1) });
		doorProp.set('doorOpen');
		clearTimeout(doorTimeout);
		doorTimeout = setTimeout(() => {
			if (this.gameover) return;
			doorProp.set('door');
			this.sfx('door close', { rate: this.randRange(0.9, 1.1) });
			doorTimeout = null;
		}, 500);
		if (this.gameover) return;
		if (!this.guestsWaiting.length) return;
		const guest = this.guestsWaiting.shift();
		this.guestsWaiting.forEach((i, idx) => {
			i.roam.target.y = doorProp.transform.y - 100 - idx * guestsGap;
		});
		guest.waiting = false;
		this.stats.busy = this.fairmath(this.stats.busy, -20);

		guest.speed = 2.5;
		await guest.walkTo(238, -900);
		this.Poof({ texture: 'bubbles3', scale: 3, x: guest.transform.x, y: guest.transform.y, offset: 1000, freq: 1/50 });
		this.sfx('splash', { rate: this.randRange(0.9, 1.1) });
		guest.speed = 1;
		guest.roam.target = this.poolPos;
		guest.spr.mask = guest.mask;
		guest.mask.visible = guest.skirt.visible = true;
		await guest.walkTo(238, this.poolPos.y);
		guest.roam.range[0] = 400;
		guest.roam.range[1] = 0.7;
		guest.roam.freq = {
			value: 4000,
			range: 3000,
		};
		await this.delay(500);
		guest.bodyCollision.body.isSensor = false;
	};

	// timer
	this.scene.player.scripts.push({
		gameObject: this.scene.player,
		update: async () => {
			if (this.gameover) {
				return;
			}
			time -= window.game.app.ticker.deltaMS;
			let s = time / 1000;
			const m = Math.floor(s/60);
			s -= m * 60;
			this.scene.timer.text = `${m.toFixed(0).padStart(2, '0')}:${s.toFixed(2).padStart(5, '0')}`;
			if (m <= 0 && s < 30) {
				this.scene.timer.scale.x = this.scene.timer.scale.y = this.lerp(2, 1, this.ease.cubicOut(s/30)) + Math.sin(time/100)*0.1*(1-(s/30));
			}
			if (time < 0) {
				this.score = this.guests.length - this.guestsWaiting.length;
				const won = this.score >= 12;
				this.music('', { fade: 100 });
				this.sfx('time up');
				this.scene.timer.text = 'TIME!';
				this.scene.player.canMove = false;
				this.gameover = true;
				intervals.forEach(i => clearInterval(i));
				intervals.length = 0;
				this.scene.focusAmt = 1;
				await this.delay(1000);
				this.tween(this.propLid.display.container, 'alpha', 1, 500, 0, this.ease.cubicOut);
				this.tween(this.propLid.transform, 'y', this.propLid.transform.y, 2000, this.propLid.transform.y - 1000, this.ease.bounceOut);
				await this.delay(750);
				this.sfx('pot lid');
				this.tween(this.scene.camera, 'shake', 0, 300, 40, this.ease.circOut);
				await this.delay(750);
				this.guests.slice(0, this.guests.length - this.guestsWaiting.length).forEach((i, idx) => {
					setTimeout(() => {
						const post = this.execute(this.getPassageWithTitle(`guest-cook`).program)[0].value;
						this.scene.feed.say(post, `${i}Idle`);
					}, idx * 100);
				});
				this.sfx('pot lid', { volume: 0.8, rate: 0.95 });
				this.tween(this.scene.camera, 'shake', 0, 200, 20, this.ease.circOut);
				await this.delay(400);
				this.sfx('pot lid', { volume: 0.6, rate: 0.925 });
				this.tween(this.scene.camera, 'shake', 0, 50, 10, this.ease.circOut);
				await this.delay(100);
				this.sfx('pot lid', { volume: 0.3, rate: 0.9 });
				this.tween(this.scene.camera, 'shake', 0, 25, 4, this.ease.circOut);
				await this.delay(50);
				this.sfx('pot lid', { volume: 0.1, rate: 0.875 });
				this.tween(this.scene.camera, 'shake', 0, 25, 2, this.ease.circOut);

				await this.delay(1000);
				this.sfx('bubble sizzle');
				this.tween(this.scene.screenFilter.uniforms, 'whiteout', 1, 1500, 0, this.ease.cubicIn);
				for (let i = 0; i < 250; ++i) {
					const p = this.randRange(0, Math.PI*2);
					setTimeout(() => {
						const poof = this.Poof({ texture: `bubbles${i%3+1}`, offset: 1000, x: this.poolPos.x + Math.cos(p)*500, y: this.poolPos.y + Math.sin(p)*400*0.75 - 50, freq: 1/100 });
					}, i * 10);
				}
				await this.delay(2500);
				this.scene.feed.display.container.visible = false;
				this.scene.timer.visible = false;
				const end = this.Prop({ texture: won ? 'endGood' : 'endBad', x: 298, y: -123, offset: 9000 });
				this.add(end);
				this.scene.drop(end);
				if (won) {
					const steam = this.Emitter({ offset: 9900, x: 206, y: -600, rate: 30, texture: 'steam', time: 2000, spawn: (p) => {
						const pp = this.randCirc(330);
						p.transform.x += pp.x;
						p.transform.y += pp.y * 0.6;
						this.tween(p.display.container, 'alpha', 0, 600, 0.25, (t) => t > 0.25 ? this.ease.cubicIn((t-0.25)/0.9) : this.ease.cubicIn(1 - t/.25));
						this.tween(p.transform, 'y', p.transform.y - 50, 600, undefined, this.ease.cubicOut);
						this.tween(p.transform, 'x', p.transform.x - 50, 600, undefined, (t) => Math.sin(Date.now()/1000 + pp.x/100));
					}, });
					this.add(steam);
					this.scene.drop(steam);
				}

				this.tween(this.scene.screenFilter.uniforms, 'whiteout', 0, 2000, 1, this.ease.cubicIn);
				this.propLid.spr.scale.x = this.propLid.spr.scale.y = 0.8;
				this.tween(this.propLid.transform, 'y', this.propLid.transform.y - this.size.y, 2500, this.propLid.transform.y - this.size.y/8, this.ease.quartIn);
				await this.delay(1000);
				this.tween(this.propLid.display.container, 'alpha', 0, 1000, 1, this.ease.cubicIn);
				await this.delay(3000);
				this.sfx(won ? 'win' : 'loss');
				this.goto(won ? 'endGood' : 'endBad');
			}
		},
	});

	this.scene.goto({ area: 'main' });
	this.goto('close');
>>

::stationOut
<<do
	this.sfx('pick up', { rate: this.randRange(0.9, 1.1) });
	if (this.itemFollower.body) {
		const p = this.Poof({ texture: `${this.itemFollower.body}Idle`, x: this.itemFollower.transform.x, y: this.itemFollower.transform.y, time: 1000 });
		p.spr.pivot.y = this.itemFollower.spr.pivot.y;
		this.tween(p.spr, 'rotation', 1, 200);
		this.tween(p.display.container, 'alpha', 0, 200);
	}
	this.itemFollower.body = `station${this.gameObject.bodySensor.body.plugin.type}`;
	this.itemFollower.animatorBody.setAnimation(`${this.itemFollower.body}Idle`);
	this.itemFollower.display.container.visible = true;
	this.goto('close');
>>

::stationIn
<<do
	if (this.itemFollower.body) {
		this.sfx('place good', { rate: this.randRange(0.9, 1.1) });
		const p = this.Poof({ texture: `${this.itemFollower.body}Idle`, x: this.itemFollower.transform.x, y: this.itemFollower.transform.y, time: 1000 });
		p.spr.pivot.y = this.itemFollower.spr.pivot.y;
		this.tween(p.spr, 'rotation', 1, 200);
		this.tween(p.display.container, 'alpha', 0, 200);
		if (this.itemFollower.body === `station${this.gameObject.bodySensor.body.plugin.type}`) {
			const stat = this.itemFollower.body.replace('station', '').toLowerCase();
			this.stats[stat] = this.fairmath(this.stats[stat], -50);
			if (stat === 'hunger' || stat === 'thirst') {
				this.stats[stat] = 0;
			}

			for (let i = 0; i < 5; ++i) {
				const p = this.randCirc(50);
				setTimeout(() => {
					const poof = this.Poof({ texture: 'fire', offset: 200, x: this.gameObject.transform.x + p.x, y: this.gameObject.transform.y + p.y, freq: 1/200 });
					this.tween(poof.transform, 'y', poof.transform.y - 100, 200);
					this.tween(poof.display.container, 'alpha', 0, 200);
				}, i * 30);
			}
		} else {
			this.sfx('place bad', { rate: this.randRange(0.9, 1.1) });
			Object.keys(this.stats).forEach(i => {
				this.stats[i] = this.fairmath(this.stats[i], 5);
			});
			this.tween(this.scene.camera, 'shake', 0, 200, 10, this.ease.circOut);
		}
		this.itemFollower.body = '';
		this.itemFollower.animatorBody.setAnimation(`error`);
		this.itemFollower.display.container.visible = false;
	}
	this.goto('close');
>>

::door
<<do
	this.letGuestIn();
	this.goto('close');
>>

//                                       dP
//                                       88
// .d8888b. dP    dP .d8888b. .d8888b. d8888P .d8888b.
// 88'  `88 88    88 88ooood8 Y8ooooo.   88   Y8ooooo.
// 88.  .88 88.  .88 88.  ...       88   88         88
// `8888P88 `88888P' `88888P' `88888P'   dP   `88888P'
//      .88
//  d8888P

::first-post
<<print this.randItem([
	`party at turnip's!!`,
	`yoo hot tub time`,
	`it's time for da tub!!!`,
	`turniiiip it's party time!`,
])>>


::guest-hunger
<<print this.randItem([
	`im starving... wheres the food at`,
	`any1 kno where the snacks are?`,
	`dying of hunger send food`,
	`rub a dub dub wheres the grub`,
	`im starvin luv xx`,
	`is the food gone?`,
	`#starving`,
	`do they have food at this party`,
])>>

::guest-not-hunger
<<print this.randItem([
	`mmm.. im stuffed`,
	`the snacks are bangin rn`,
	`im so full... x_x`,
	`luv these or derves (sp?)`,
	`the food here is ${this.randItem(['so', 'soo', 'soooo'])} good`,
	`wowww im in snack heaven`,
	`yummy!`,
	`#stuffed`,
	`ate too much lol`,
	`delicious`,
	`food pics for the yam`,
])>>

::guest-thirst
<<print this.randItem([
	`im thirsty`,
	`need a drink...`,
	`where are the bevvies smh`,
	`cant find my drink :(`,
	`wheres the DRINX`,
	`feelin parched`,
	`would kill for a drink rn`,
	`runnin dry over here`,
	`#thirsty`,
])>>

::guest-not-thirst
<<print this.randItem([
	`mm.. this drink is ${this.randItem(['so', 'soo', 'soooo'])} good`,
	`lots of yummy drinx tn`,
	`its no longer thirsty thursday lol`,
	`doing shots rn!!`,
	`#shots`,
	`feelin refreshed`,
	`ahhh... that hits`,
	`#drinking #gottapee`,
])>>

::guest-cold
<<print this.randItem([
	`wont anyone please turn up the heat`,
	`${this.randItem(['brr', 'brrrr', 'brrrrrrr'])}`,
	`im ice cold (in the bad way)`,
	`im freezing :(`,
	`feel like im the north pole`,
	`arent hot tubs supposed to be HOT`,
	`#coldfeet`,
	`didnt come for an ice bath...`,
	`more heat plz`,
	`wow it's ${this.randItem(['so', 'soo', 'soooo'])} cold`,
	`#coolin`,
])>>

::guest-not-cold
<<print this.randItem([
	`the waters fine`,
	`this hot tub rocks`,
	`perfect temp in here`,
	`cozy...`,
	`feelin toasty`,
	`hot tub is fire emoji`,
	`yessss so warm`,
	`#heat #fire`,
	`${this.randItem(['ahh', 'ahhh', 'ahhhhhhh'])} this is relaxing...`,
	`wow it's ${this.randItem(['so', 'soo', 'soooo'])} hot`,
	`dont wanna get out <3`,
	`mmmm warm`,
	`hot tub heaven...`,
])>>

::guest-dry
<<print this.randItem([
	`wheres the water!!`,
	`#dry #notwet`,
	`needs more water`,
	`pool's runnin low`,
	`#drought`,
	`water level droppin`,
	`land ho!`,
])>>

::guest-not-dry
<<print this.randItem([
	`nice n wet`,
	`#soaking`,
	`water's high!`,
	`#waterworld`,
	`#WetNWild`,
	`full body soak`,
	`#immersed`,
])>>

::guest-bland
<<print this.randItem([
	`not very salty...`,
	`the water's gross`,
	`i see scum :X`,
	`#grody #scumbum`,
	`need salt`,
	`#unseasoned`,
])>>

::guest-not-bland
<<print this.randItem([
	`#salty`,
	`feelin fresh`,
	`hot tub's nice n clean`,
	`lotsa salt in here`,
	`#seasoned`,
	`salty tubbin`,
	`love that salt smell`,
])>>

::guest-random
<<print this.randItem([
	`lol`,
	`lmao`,
	`wowww`,
	`HARDCORE! TO THE MEGA!`,
	`#party`,
	`cant find my glasses :(`,
	`who took my shirt!!`,
	`so fun`,
	`#PartyVibes`,
	`hashtag do it for the yam`,
	`date night with this one <3`,
	`what's this song?`,
	`whos drink is this...`,
	`meet me in the hot tub!`,
	`chilling...`,
	`omg as if ${this.randItem(['SHE', 'HE', 'THEY', 'ZE'])} came...`,
	`love it`,
	`this song sux`,
	`did i miss anything?`,
	`omg dead xD`,
	`this is my jam!!`,
	`bored...`,
	`i fell`,
	`${this.randItem(['woo', 'woooo', 'woooooooo'])}`,
])>>

::guest-cook
<<print this.randItem([
	`uhh rude`,
	`wow`,
	`wtf`,
	`who turned the lights out!!`,
	`eek!!`,
	`HELP`,
	`${this.randItem(['oh no', 'oh noo', 'oh noooo'])}`,
	`RIP`,
	`augh`,
])>>

::guest-waiting
<<print this.randItem([
	`Let me in.`,
	`LET ME INNNNN!!!`,
	`how long is the wait`,
	`waiting...`,
	`i wanna get in :-O`,
	`wait for me im still in line`,
	`line is too long...`,
	`been in line 4ever`,
	`${this.randItem(['so', 'soo', 'soooo'])} excited to get in`,
	`pumped 4 this!`,
	`wheres the bouncer`,
	`how much longer??!?`,
	`#waiting #bored`,
	`lemme in`,
	`im here`,
	`${this.randItem(['SHE', 'HE', 'THEY', 'ZE'])} got let in before me??`,
	`ill wait a bit longer i guess`,
])>>