@v12-engine/engine 0.1.1 → 0.4.0

package/dist/score.js

@@ -0,0 +1,709 @@
+import { defineComponent } from "./components.js";
+import { abilityCast, bounty, constructionFinished, damaged, entityDied, gameOver, healed, heroLevelUp, itemPicked, resourcesDeposited, resourcesSpent, traded, unitHired, unitTrained, xpGained } from "./engineEvents.js";
+import { snapshotField } from "./replication.js";
+import { boughtBack, heroAssisted, heroOf, heroState, killStreak } from "./hero.js";
+//#region src/score.ts
+/**
+* The world's component the score is kept in (`core.score`, on the world's own entity): what a save keeps of it
+*
+* @beta
+*/
+var scoreData = defineComponent({
+	id: "core.score",
+	default: () => ({
+		values: {},
+		types: {},
+		every: 0,
+		ticks: [],
+		line: {}
+	})
+});
+/**
+* A source of a stat, typed by its event, the engine's or the game's own: `scoreOn(entityDied, ({ entity, killer }) =>
+* killer && { player: killer.owner })`
+*
+* @beta
+*/
+function scoreOn(event, count) {
+	return {
+		event,
+		count
+	};
+}
+/**
+* A stat of the game's own, for `RuleSettings.score`: `defineStat({ id: 'towersLost', label: 'Towers lost', category: 'units',
+* from: scoreOn(entityDied, ({ entity }) => entity.def.tags?.includes('tower') ? entity.owner : undefined) })`.
+* One with no source is counted in code (`world.score.add(player, 'towersLost')`)
+*
+* @public
+*/
+function defineStat(def) {
+	return def;
+}
+var CATEGORY_LABELS = {
+	units: "Units",
+	heroes: "Heroes",
+	resources: "Resources",
+	combat: "Combat",
+	other: "Other"
+};
+/** The score's rules with their stats made of the game, checked: an id twice, or a timeline of no length, throws */
+function resolveScore(rules, game) {
+	if (!rules) return null;
+	const stats = typeof rules.stats === "function" ? rules.stats(game) : rules.stats;
+	const byId = /* @__PURE__ */ new Map();
+	for (const stat of stats) {
+		if (byId.has(stat.id)) throw new Error(`The score has the stat "${stat.id}" twice`);
+		byId.set(stat.id, stat);
+	}
+	if (rules.every !== void 0 && !(rules.every >= 0)) throw new Error(`The score's timeline is sampled every ${rules.every} seconds: 0 or more`);
+	const categories = [...rules.categories ?? []];
+	for (const stat of stats) {
+		const id = stat.category ?? "other";
+		if (!stat.hidden && !categories.some((category) => category.id === id)) categories.push({
+			id,
+			label: CATEGORY_LABELS[id] ?? id
+		});
+	}
+	return {
+		rules,
+		stats,
+		byId,
+		categories
+	};
+}
+/** What a kind makes of a number and what is told */
+function combine(kind, before, amount) {
+	switch (kind) {
+		case "count": return (before ?? 0) + 1;
+		case "max": return before === void 0 ? amount : Math.max(before, amount);
+		case "min": return before === void 0 ? amount : Math.min(before, amount);
+		case "last": return amount;
+		default: return (before ?? 0) + amount;
+	}
+}
+/** Rounded to hundredths, for the wire */
+var hundredths = (value) => Math.round(value * 100) / 100;
+/**
+* The score of a world (`world.score`): counts what its stats are told of the world's events, takes the gauges and
+* the timeline's points, and is what the game's code counts with, and reads, in the rules. What it keeps is the
+* world's state (`scoreData`); nothing of it is kept here but what is made again from the game
+*
+* @beta
+*/
+var Score = class {
+	world;
+	/** Goes up with every change of a number: what a session tells the screens again by */
+	version = 0;
+	/** Goes up with every point of the timeline */
+	lineVersion = 0;
+	offs = [];
+	constructor(world) {
+		this.world = world;
+		this.listen();
+	}
+	/** The game's score, as its rules say: none for a game that counts nothing */
+	get rules() {
+		return this.world.registry.score;
+	}
+	/** Whether the game counts anything */
+	get on() {
+		return this.world.registry.score !== null;
+	}
+	/** The stats, in order */
+	stats() {
+		return this.rules?.stats ?? [];
+	}
+	/** Hears the events the stats are counted from: again when the game takes a new version (`reloadGame`) */
+	listen() {
+		for (const off of this.offs) off();
+		this.offs = [];
+		const score = this.rules;
+		if (!score) return;
+		const byEvent = /* @__PURE__ */ new Map();
+		for (const stat of score.stats) {
+			const sources = !stat.from ? [] : Array.isArray(stat.from) ? stat.from : [stat.from];
+			for (const source of sources) {
+				let heard = byEvent.get(source.event.id);
+				if (!heard) byEvent.set(source.event.id, heard = {
+					key: source.event,
+					list: []
+				});
+				heard.list.push({
+					stat,
+					source
+				});
+			}
+		}
+		const world = this.world;
+		for (const { key, list } of byEvent.values()) this.offs.push(world.events.on(key, (payload) => {
+			for (let i = 0; i < list.length; i++) {
+				const { stat, source } = list[i];
+				if (world.disabled.size && world.disabled.has(`listener:score:${stat.id}`)) continue;
+				let counted;
+				try {
+					counted = source.count(payload, world);
+				} catch (error) {
+					world.caught(error, {
+						kind: "listener",
+						id: `score:${stat.id}`
+					});
+					continue;
+				}
+				this.take(stat, counted);
+			}
+		}));
+		this.offs.push(world.events.on(gameOver, () => this.sample(true)));
+	}
+	take(stat, counted) {
+		if (counted === void 0 || counted === null) return;
+		if (typeof counted === "number") this.put(stat, counted, 1, void 0);
+		else if (Array.isArray(counted)) for (const each of counted) this.put(stat, each.player, each.amount ?? 1, each.type);
+		else {
+			const each = counted;
+			this.put(stat, each.player, each.amount ?? 1, each.type);
+		}
+	}
+	/** Whether a player's numbers are kept: as the rules say, every player but the neutral ones and the creeps when they do not */
+	counts(player) {
+		const own = this.rules?.rules.counts;
+		if (own) return own(this.world, player);
+		const found = this.world.players.get(player);
+		return !!found && !found.neutral && !found.creeps;
+	}
+	/** Who `counts`, by player id, where the rules leave it to the engine (whether a player is neutral never changes) */
+	counted = [];
+	/** The players whose numbers are kept, by id */
+	players() {
+		const players = [];
+		for (const id of this.world.players.keys()) if (this.counts(id)) players.push(id);
+		return players.sort((a, b) => a - b);
+	}
+	put(stat, player, amount, type) {
+		if (!Number.isFinite(amount)) return;
+		if (this.rules.rules.counts ? !this.counts(player) : !(this.counted[player] ??= this.counts(player))) return;
+		const data = this.world.state(scoreData);
+		const values = data.values[stat.id] ??= {};
+		values[player] = combine(stat.kind, values[player], amount);
+		if (stat.byType && type !== void 0) {
+			const types = (data.types[stat.id] ??= {})[player] ??= {};
+			types[type] = combine(stat.kind, types[type], amount);
+		}
+		this.version++;
+	}
+	stat(id) {
+		const stat = this.rules?.byId.get(id);
+		if (!stat) throw new Error(this.rules ? `The score has no stat "${id}": give it in RuleSettings.score (defineStat)` : `The game counts no score: give RuleSettings.score (presetScore(), or stats of its own) to count "${id}"`);
+		return stat;
+	}
+	/** Counts something for a player, as the stat's kind takes it (adds it up for a sum): one when no amount is given */
+	add(player, id, amount = 1, type) {
+		this.put(this.stat(id), player, amount, type);
+	}
+	/** Sets a player's number, whatever the stat's kind */
+	set(player, id, value, type) {
+		this.put({
+			...this.stat(id),
+			kind: "last"
+		}, player, value, type);
+	}
+	/** A player's number of a stat: 0 for one never counted */
+	get(player, id) {
+		return this.world.state(scoreData).values[id]?.[player] ?? 0;
+	}
+	/** A player's numbers of a stat kept by type, by type */
+	byType(player, id) {
+		return this.world.state(scoreData).types[id]?.[player] ?? {};
+	}
+	/** A team's number of a stat: its players' added up, or the most or the least of them for `max` and `min` */
+	team(team, id) {
+		const stat = this.stat(id);
+		let total;
+		for (const player of this.players()) {
+			if (this.world.player(player).team !== team) continue;
+			const value = this.get(player, id);
+			total = stat.kind === "max" || stat.kind === "min" ? total === void 0 ? value : combine(stat.kind, total, value) : (total ?? 0) + value;
+		}
+		return total ?? 0;
+	}
+	/** The timeline of a player's number of a stat on it: its points, at `ticks` */
+	timeline(player, id) {
+		const data = this.world.state(scoreData);
+		return {
+			ticks: data.ticks,
+			values: data.line[id]?.[player] ?? []
+		};
+	}
+	/** Reads the gauges, and on a point of the timeline (or `point`) takes a point. Run once a second by the score's system */
+	sample(point = false) {
+		const score = this.rules;
+		if (!score) return;
+		const { world } = this;
+		const players = this.players();
+		for (const stat of score.stats) {
+			if (!stat.sample || world.disabled.size && world.disabled.has(`system:score:${stat.id}`)) continue;
+			const kind = stat.kind ?? "last";
+			for (const player of players) {
+				let value;
+				try {
+					value = stat.sample(world, player);
+				} catch (error) {
+					world.caught(error, {
+						kind: "system",
+						id: `score:${stat.id}`
+					});
+					continue;
+				}
+				if (value !== void 0) this.put(stat.kind ? stat : {
+					...stat,
+					kind
+				}, player, value, void 0);
+			}
+		}
+		const data = world.state(scoreData);
+		const every = Math.round((score.rules.every ?? 10) * world.tickRate);
+		if (every <= 0) return;
+		if (!data.every) data.every = every;
+		if (!(data.ticks.length === 0 || world.tick - data.ticks[data.ticks.length - 1] >= data.every) && !(point && data.ticks[data.ticks.length - 1] !== world.tick)) return;
+		data.ticks.push(world.tick);
+		for (const stat of score.stats) {
+			if (!stat.timeline) continue;
+			const line = data.line[stat.id] ??= {};
+			for (const player of players) {
+				const points = line[player] ??= [];
+				while (points.length < data.ticks.length - 1) points.push(0);
+				points.push(data.values[stat.id]?.[player] ?? 0);
+			}
+		}
+		const max = Math.max(score.rules.maxPoints ?? 360, 8);
+		if (data.ticks.length > max) {
+			const keep = (list) => list.filter((_, i) => i % 2 === 0 || i === list.length - 1);
+			data.ticks = keep(data.ticks);
+			for (const lines of Object.values(data.line)) for (const player in lines) lines[player] = keep(lines[player]);
+			data.every *= 2;
+		}
+		this.lineVersion++;
+		this.version++;
+	}
+	/** Whether `viewer` (`undefined` for an observer) is told `player`'s numbers now */
+	tells(viewer, player, final) {
+		const rules = this.rules?.rules;
+		if (!rules) return false;
+		const audience = final ? rules.end ?? "everyone" : rules.live ?? "allies";
+		if (typeof audience === "function") return audience(this.world, viewer, player);
+		if (audience === "none") return false;
+		if (viewer === void 0 || audience === "everyone") return true;
+		if (audience === "own") return viewer === player;
+		return viewer === player || this.world.player(viewer).team === this.world.player(player).team;
+	}
+	/** What `viewer` is told of the numbers (`Snapshot.score`): nothing for a game that counts none, or a viewer told of no one */
+	stateFor(viewer, final) {
+		const score = this.rules;
+		if (!score) return void 0;
+		const players = this.players().filter((player) => this.tells(viewer, player, final));
+		if (!players.length) return void 0;
+		const data = this.world.state(scoreData);
+		const values = {};
+		let types;
+		for (const stat of score.stats) {
+			const all = data.values[stat.id];
+			if (all) {
+				const told = {};
+				for (const player of players) if (player in all) told[player] = hundredths(all[player]);
+				values[stat.id] = told;
+			}
+			const byType = stat.byType ? data.types[stat.id] : void 0;
+			if (byType) {
+				const told = {};
+				for (const player of players) {
+					if (!byType[player]) continue;
+					const each = {};
+					for (const type in byType[player]) each[type] = hundredths(byType[player][type]);
+					told[player] = each;
+				}
+				(types ??= {})[stat.id] = told;
+			}
+		}
+		return {
+			tick: this.world.tick,
+			final,
+			players,
+			values,
+			...types && { types }
+		};
+	}
+	/** What `viewer` is told of the timeline (`Snapshot.scoreLine`): nothing without one */
+	lineFor(viewer, final) {
+		if (!this.rules) return void 0;
+		const data = this.world.state(scoreData);
+		if (!data.ticks.length) return void 0;
+		const players = this.players().filter((player) => this.tells(viewer, player, final));
+		if (!players.length) return void 0;
+		const values = {};
+		for (const stat in data.line) {
+			const told = {};
+			for (const player of players) if (data.line[stat][player]) told[player] = data.line[stat][player].map(hundredths);
+			values[stat] = told;
+		}
+		return {
+			every: data.every / this.world.tickRate,
+			ticks: [...data.ticks],
+			values
+		};
+	}
+};
+/** The score's system: the gauges once a second, a point of the timeline when one is due. Only in a game that counts */
+function scoreSystem(world) {
+	return {
+		name: "score",
+		phase: "cleanup",
+		every: Math.max(Math.round(world.tickRate), 1),
+		update: (world) => world.score.sample()
+	};
+}
+var enemies = (world, a, b) => world.areEnemies(a, b);
+/** Whether a death is a loss: what was cancelled, ran out, was removed, a tree felled or a mine dry is not */
+var lost = (reason) => reason !== "cancelled" && reason !== "expired" && reason !== "removed" && reason !== "depleted" && reason !== "felled";
+var killedBy = (world, entity, killer) => killer && enemies(world, killer.owner, entity.owner) ? killer.owner : void 0;
+/**
+* The stats `presetScore` has, by id, those of each resource made of the game (`gathered.gold`, `spent.gold`...)
+*
+* @beta
+*/
+function engineStats(game) {
+	const resources = game.resources ?? [];
+	const currency = game.currency ?? resources[0]?.id;
+	return [
+		defineStat({
+			id: "unitsProduced",
+			label: "Units produced",
+			category: "units",
+			byType: true,
+			from: [scoreOn(unitTrained, ({ unit }) => ({
+				player: unit.owner,
+				type: unit.def.id
+			})), scoreOn(unitHired, ({ unit, player }) => ({
+				player,
+				type: unit.def.id
+			}))]
+		}),
+		defineStat({
+			id: "unitsKilled",
+			label: "Units killed",
+			category: "units",
+			byType: true,
+			timeline: true,
+			from: scoreOn(entityDied, ({ entity, killer }, world) => {
+				if (!entity.isUnit) return void 0;
+				const by = killedBy(world, entity, killer);
+				return by === void 0 ? void 0 : {
+					player: by,
+					type: entity.def.id
+				};
+			})
+		}),
+		defineStat({
+			id: "unitsLost",
+			label: "Units lost",
+			category: "units",
+			byType: true,
+			from: scoreOn(entityDied, ({ entity, reason }) => entity.isUnit && lost(reason) ? {
+				player: entity.owner,
+				type: entity.def.id
+			} : void 0)
+		}),
+		defineStat({
+			id: "buildingsBuilt",
+			label: "Buildings built",
+			category: "units",
+			byType: true,
+			from: scoreOn(constructionFinished, (building) => ({
+				player: building.owner,
+				type: building.def.id
+			}))
+		}),
+		defineStat({
+			id: "buildingsRazed",
+			label: "Buildings razed",
+			category: "units",
+			byType: true,
+			from: scoreOn(entityDied, ({ entity, killer }, world) => {
+				if (!entity.isBuilding) return void 0;
+				const by = killedBy(world, entity, killer);
+				return by === void 0 ? void 0 : {
+					player: by,
+					type: entity.def.id
+				};
+			})
+		}),
+		defineStat({
+			id: "buildingsLost",
+			label: "Buildings lost",
+			category: "units",
+			from: scoreOn(entityDied, ({ entity, reason }) => entity.isBuilding && lost(reason) ? entity.owner : void 0)
+		}),
+		defineStat({
+			id: "army",
+			label: "Army",
+			description: "The supply used now",
+			category: "units",
+			kind: "last",
+			timeline: true,
+			sample: (world, player) => world.player(player).supplyUsed
+		}),
+		defineStat({
+			id: "largestArmy",
+			label: "Largest army",
+			description: "The most supply used at once",
+			category: "units",
+			kind: "max",
+			sample: (world, player) => world.player(player).supplyUsed
+		}),
+		defineStat({
+			id: "heroesKilled",
+			label: "Heroes killed",
+			category: "heroes",
+			byType: true,
+			from: scoreOn(entityDied, ({ entity, killer }, world) => {
+				if (!entity.has(heroState)) return void 0;
+				const by = killedBy(world, entity, killer);
+				return by === void 0 ? void 0 : {
+					player: by,
+					type: entity.def.id
+				};
+			})
+		}),
+		defineStat({
+			id: "heroesLost",
+			label: "Heroes lost",
+			category: "heroes",
+			from: scoreOn(entityDied, ({ entity, reason }) => heroOf(entity) && lost(reason) ? entity.owner : void 0)
+		}),
+		defineStat({
+			id: "heroAssists",
+			label: "Assists",
+			description: "Heroes killed with the help of its heroes: hurt by them, or their killer healed, shielded or buffed",
+			category: "heroes",
+			byType: true,
+			from: scoreOn(heroAssisted, ({ player, type }) => ({
+				player,
+				type
+			}))
+		}),
+		defineStat({
+			id: "longestKillStreak",
+			label: "Longest kill streak",
+			description: "The most heroes one of its heroes killed without dying",
+			category: "heroes",
+			kind: "max",
+			from: scoreOn(killStreak, ({ player, streak, type }) => ({
+				player,
+				amount: streak,
+				type
+			}))
+		}),
+		defineStat({
+			id: "buybacks",
+			label: "Buybacks",
+			category: "heroes",
+			from: scoreOn(boughtBack, ({ player, type }) => ({
+				player,
+				type
+			}))
+		}),
+		defineStat({
+			id: "highestHeroLevel",
+			label: "Highest hero level",
+			category: "heroes",
+			kind: "max",
+			from: scoreOn(heroLevelUp, ({ hero, level }) => ({
+				player: hero.owner,
+				amount: level,
+				type: hero.def.id
+			}))
+		}),
+		defineStat({
+			id: "experience",
+			label: "Experience gained",
+			category: "heroes",
+			byType: true,
+			from: scoreOn(xpGained, ({ hero, amount }) => ({
+				player: hero.owner,
+				amount,
+				type: hero.def.id
+			}))
+		}),
+		defineStat({
+			id: "creepsKilled",
+			label: "Creeps killed",
+			category: "heroes",
+			from: scoreOn(entityDied, ({ entity, killer }, world) => killer && world.player(entity.owner).creeps ? killer.owner : void 0)
+		}),
+		defineStat({
+			id: "itemsObtained",
+			label: "Items obtained",
+			category: "heroes",
+			byType: true,
+			from: scoreOn(itemPicked, ({ entity, item }) => ({
+				player: entity.owner,
+				type: item.item
+			}))
+		}),
+		defineStat({
+			id: "abilitiesCast",
+			label: "Abilities cast",
+			category: "heroes",
+			byType: true,
+			from: scoreOn(abilityCast, ({ caster, ability }) => ({
+				player: caster.owner,
+				type: ability.id
+			}))
+		}),
+		defineStat({
+			id: "damageDealt",
+			label: "Damage dealt",
+			category: "combat",
+			byType: true,
+			timeline: true,
+			from: scoreOn(damaged, ({ target, source, amount }, world) => source && enemies(world, source.owner, target.owner) ? {
+				player: source.owner,
+				amount,
+				type: source.def.id
+			} : void 0)
+		}),
+		defineStat({
+			id: "damageTaken",
+			label: "Damage taken",
+			category: "combat",
+			from: scoreOn(damaged, ({ target, amount }) => ({
+				player: target.owner,
+				amount
+			}))
+		}),
+		defineStat({
+			id: "healing",
+			label: "Healing done",
+			category: "combat",
+			byType: true,
+			from: scoreOn(healed, ({ target, source, amount }) => ({
+				player: (source ?? target).owner,
+				amount,
+				type: (source ?? target).def.id
+			}))
+		}),
+		...resources.flatMap((resource) => [
+			defineStat({
+				id: `gathered.${resource.id}`,
+				label: `${resource.name} gathered`,
+				category: "resources",
+				timeline: resource.id === currency,
+				from: scoreOn(resourcesDeposited, ({ player, kind, amount }) => kind === resource.id ? {
+					player,
+					amount
+				} : void 0)
+			}),
+			defineStat({
+				id: `spent.${resource.id}`,
+				label: `${resource.name} spent`,
+				category: "resources",
+				byType: true,
+				from: scoreOn(resourcesSpent, ({ player, cost, on, refund }) => cost[resource.id] ? {
+					player,
+					amount: refund ? -cost[resource.id] : cost[resource.id],
+					type: on
+				} : void 0)
+			}),
+			...resource.upkeep ? [defineStat({
+				id: `upkeep.${resource.id}`,
+				label: `${resource.name} lost to upkeep`,
+				category: "resources",
+				from: scoreOn(resourcesDeposited, ({ player, kind, upkeep }) => kind === resource.id && upkeep ? {
+					player,
+					amount: upkeep
+				} : void 0)
+			})] : []
+		]),
+		...currency ? [defineStat({
+			id: "bounty",
+			label: "Bounty",
+			description: `${resources.find((resource) => resource.id === currency)?.name ?? currency} for kills`,
+			category: "resources",
+			from: scoreOn(bounty, ({ player, amount }) => ({
+				player,
+				amount
+			}))
+		})] : [],
+		...resources.length ? [defineStat({
+			id: "tradedOut",
+			label: "Given to allies",
+			category: "resources",
+			byType: true,
+			from: scoreOn(traded, ({ from, resource, sent }) => ({
+				player: from,
+				amount: sent,
+				type: resource
+			}))
+		}), defineStat({
+			id: "tradedIn",
+			label: "Given by allies",
+			category: "resources",
+			byType: true,
+			from: scoreOn(traded, ({ to, resource, received }) => ({
+				player: to,
+				amount: received,
+				type: resource
+			}))
+		})] : []
+	];
+}
+/**
+* The engine's score, for `RuleSettings.score`: a classic RTS score screen. Units produced, killed and lost, buildings
+* built, razed and lost, the army and the largest, heroes killed and lost, the highest hero level, experience, creeps
+* killed, items obtained, abilities cast, damage dealt and taken, healing, and of each resource what was gathered,
+* spent and lost to upkeep, the bounty and what went between allies
+*
+* @public
+*/
+function presetScore(options = {}) {
+	const { only, without, stats: own = [], ...rules } = options;
+	const named = (list, id) => !!list?.some((name) => name === id || id.startsWith(`${name}.`));
+	return {
+		...rules,
+		stats: (game) => [...engineStats(game).filter((stat) => (!only || named(only, stat.id)) && !named(without, stat.id)), ...own]
+	};
+}
+var TOLD = {};
+/** What the seat is told of the score now: the same objects while nothing new is to be told */
+function scoreTold(view) {
+	const { world } = view;
+	const counted = world.score.rules;
+	if (!counted || view.forComputer) return void 0;
+	const told = view.keep(TOLD, () => ({
+		tick: -Infinity,
+		version: -1,
+		lineVersion: -1,
+		final: false
+	}));
+	const final = world.winner !== null || world.failure !== null;
+	const viewer = view.observer ? void 0 : view.player;
+	const refresh = Math.max(Math.round((counted.rules.refresh ?? 1) * world.tickRate), 1);
+	if (final !== told.final || world.tick - told.tick >= refresh && world.score.version !== told.version) {
+		told.score = world.score.stateFor(viewer, final);
+		told.tick = world.tick;
+		told.version = world.score.version;
+	}
+	if (final !== told.final || world.score.lineVersion !== told.lineVersion) {
+		told.line = world.score.lineFor(viewer, final);
+		told.lineVersion = world.score.lineVersion;
+	}
+	told.final = final;
+	return told;
+}
+/** The score the player is told (`Snapshot.score`) */
+var scorePart = snapshotField("score", (view) => scoreTold(view)?.score);
+/** The score's line over time the player is told (`Snapshot.scoreLine`) */
+var scoreLinePart = snapshotField("scoreLine", (view) => scoreTold(view)?.line);
+//#endregion
+export { Score, defineStat, engineStats, presetScore, resolveScore, scoreData, scoreLinePart, scoreOn, scorePart, scoreSystem };
+
+//# sourceMappingURL=score.js.map