HackMUD aperture.syskit

syskit.js

function(context, args)
{
	const HEADER = `\n\`HAPERTURE SCIENCE :: SYS KIT\`\n\n`;
	const COLUMNS = ['name','ready','cooldown','loaded'];

	const availableScripts = "sys.expose_balance,sys.expose_access_log,sys.expose_upgrade_log,sys.expose_upgrades,sys.xfer_upgrade_from,sys.xfer_gc_from,sys.write_log".split(",")//#hs.scripts.sys()
	const availableUpgrades = #hs.sys.upgrades({full:true})

	const reload = (args && args.reload == true);

	let sysArray = []
	let debug = ""

	availableScripts.forEach((name) => {

		let equivalent = ""
		switch (name) {
			case '': equivalent = ''; break;
			case 'sys.expose_balance': equivalent = 'balance_v'; break;
			case 'sys.expose_access_log': equivalent = 'expose_access_log_v'; break;
			case 'sys.expose_upgrade_log': equivalent = 'expose_upgrade_log_v'; break;
			case 'sys.expose_upgrades': equivalent = 'expose_upgrades_v'; break;
			case 'sys.xfer_upgrade_from': equivalent = 'transfer_upgrade_v'; break;
			case 'sys.xfer_gc_from': equivalent = 'transfer_v2'; break;
			case 'sys.write_log': equivalent = 'log_writer_v'; break;
		}

		let scrArray = availableUpgrades.filter((u) => (u.name.includes(equivalent)) )
		scrArray.sort((a,b) => b.tier - a.tier);
		
		if (reload) {

			let loadedUpgrade = scrArray.find((u) => u.loaded)
			if (loadedUpgrade) {

				#ms.sys.manage({unload:loadedUpgrade.i})
			}
			let availableUpgrade = scrArray.find((u) => (_START - u.last_time) > (u.cooldown * 1000) || !u.last_time)
			if (availableUpgrade) #ms.sys.manage({load:availableUpgrade.i})
			
			debug += `Reloaded ${name}\n`
		}

		let loaded = scrArray.filter((u) => u.loaded)
		let loadedString = "---"
		if (loaded && loaded.length > 0)
			loadedString = `${loaded[0].i}`.padStart(3,'0')
		
		let ready = String(scrArray.filter((u) => (_START - u.last_time) > (u.cooldown * 1000) || !u.last_time).length).padStart(5," ")
		let cooldown = String(scrArray.length - ready).padStart(8," ")

		sysArray.push({
				name,
				ready,
				cooldown,
				loaded: loadedString.padStart(6," ")
		})

		loaded = null;
	});

	if (args && args.quiet) {
		return `\n` + createTable(sysArray,COLUMNS) + `\n`;
	}

	return HEADER + 
		createTable(sysArray,COLUMNS) + "\n\n" + 
		"Use {reload:true} to automatically load ready upgrades\n"

	// BEGIN UTILITY FUNCTIONS

	function loadScriptOnCooldown(s) {

	}

	function expand_stats(upg) {
		switch (upg.type) {
			case "script":
				upg.next_use = (upg.last_time || 0) + upg.cooldown * 1000;
				upg.is_on_cd = _START < upg.next_use;
				upg.cd_remain = upg.is_on_cd ? (upg.next_use - _START) : 0;
				upg.script = upg.description
					.split(" ")[0]
					.split(".")[1];
				break;
		}
	}	

	function createTable(data, columns) {

		function decolor (val) {
			return String(val).replaceAll(/`\w(.*?)`/g, '$1')
		}

		if (!data.length) {
			return '';
		}
	
		// Use the provided columns or get all keys from the first object
		columns = columns || Object.keys(data[0]);
	
		// Calculate the width for each column
		const colWidths = columns.map(key => Math.max(key.length, ...data.map(row => decolor(String(row[key] || '')).length)));
	
		// Padding function
		const pad = (str, length) => String(str).padEnd(length, ' ');
	
		// Function to create the border
		const border = (left, mid, right, horizontal) => 
			left + colWidths.map(width => horizontal.repeat(width + 2)).join(mid) + right;
	
		// Create the header row
		const header = "┃" + columns.map((key, i) => `\`1 ${pad(key.toUpperCase(), colWidths[i])} \``).join('┃') + "┃";
	
		// Create the data rows
		const rows = data.map(row => 
			"┃" + columns.map((key, i) => ` ${pad(row[key] || '', colWidths[i])} `).join('┃') + "┃"
		);
	
		// Create the borders
        const topBorder = border('┏', '┳', '┓', '━');
        const midBorder = border('┣', '╋', '┫', '━');
        const bottomBorder = border('┗', '┻', '┛', '━');
	
		// Combine all parts to create the table
		return [
			topBorder,
			header,
			midBorder,
			...rows,
			bottomBorder
		].join('\n');
	}	
}