Chaturbate

Apps Home | Create an App
Seamless Show
Author: pumagrl
You are viewing version 725318. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch App Current Users
Created by: Pumagrl
There are 25 other versions of this script.
(function (cb) {
'use strict';

cb = cb && cb.hasOwnProperty('default') ? cb['default'] : cb;

const once = (fn) => {
	let val = null;
	return () => {
		if (val === null) {
			val = fn();
		}
		return val;
	};
};

const timeago = (timestamp) => {
	const s = Math.ceil((Date.now() - timestamp) / 1000);

	const seconds = s % 60;
	const minutes = Math.floor(s / 60) % 60;
	const hours = Math.floor(s / 3600);

	if (hours) {
		return `${hours}h${minutes}m${seconds}s`;
	}
	if (minutes) {
		return `${minutes}m${seconds}s`;
	}
	return `${seconds}s`;
};

const filterUnqiue = (v, i, arr) => {
	return arr.indexOf(v) === i;
};

const count = 20;

(function () {
	cb["settings_choices"] = [];

	for (let i = 1; i <= count; i++) {
		cb["settings_choices"].push({
			label: String(i),
			name: "item" + String(i),
			type: "str",
			required: false,
		});
	}
})();

const getMenuSettings = once(() => {
	const items = [];
	for (let i = 1; i <= count; i++) {
		const name = "item" + String(i);
		const config = cb.settings[name];
		if (config === "") {
			continue;
		}
		const penaltyMatch = config.match(/\d+%/);
		const penalty = penaltyMatch ? parseFloat(penaltyMatch[0].slice(0, -1)) : 0;
		const cmdMatch = config.match(/\/\w+/);
		const cmd = cmdMatch[0];
		const title = config
			.replace(/\s\d+%/, "").replace(/\d+%\s/, "")
			.replace(/\s\/\w+/, "").replace(/\/\w+\s/, "");
		items.push({ title, cmd, penalty });
	}
	return items;
});

let performedMenuItem = null;

const cloneMenuItem = (menuItem) => {
	return Object.assign({ }, menuItem, {
		contributions: menuItem.contributions.slice(0),
	});
};

const getMenu = once(() => {
	const menuSettings = getMenuSettings();
	const maxPenalty = menuSettings
		.map(item => item.penalty)
		.reduce((max, v) => Math.max(max, v));
	const menu = menuSettings.map((itemSettings) => {
		const percent = Math.max(itemSettings.penalty - maxPenalty, -50);
		return Object.assign({ percent, contributions: []}, itemSettings);
	});
	return menu;
});

const getMenuItemByTitle = (title) => {
	return getMenu().find(item => item.title.indexOf(title) !== -1);
};

const getSortedMenu = () => {
	const menu = getMenu();
	const sortedMenu = menu.slice(0).sort((a, b) => {
		const asum = a.contributions.reduce((sum, c) => sum + c.amount, 0);
		const bsum = b.contributions.reduce((sum, c) => sum + c.amount, 0);
		return bsum - asum;
	});
	return sortedMenu;
};

const getPerformedMenuItem = () => {
	return performedMenuItem;
};

const getNextMenuItem = () => {
	const nextItem = getSortedMenu()[0];
	return cloneMenuItem(nextItem);
};

const getChasingMenuItem = () => {
	const chasing = getSortedMenu()[1];
	return cloneMenuItem(chasing);
};

const addContribution = (title, username, tokens) => {
	const timestamp = Date.now();
	const menuItem = getMenuItemByTitle(title);
	const div = 1 + (menuItem.percent / 100);
	const amount = tokens / div;
	menuItem.contributions.push({ username, tokens, amount, timestamp });
};

const addContributionToPerformance = (username, tokens) => {
	if (performedMenuItem !== null) {
		addContribution(performedMenuItem.title, username, tokens);
	}
};

const startPerformance = (title) => {
	performedMenuItem = cloneMenuItem(getMenuItemByTitle(title));

	for (const menuItem of getMenu()) {
		if (menuItem.title === performedMenuItem.title) {
			menuItem.percent += menuItem.penalty;
			menuItem.contributions.splice(0, menuItem.contributions.length);
		}
		else {
			menuItem.percent = Math.max(-50, menuItem.percent - 1);
		}
	}
};

const startNextPerformance = () => {
	const nextItem = getNextMenuItem();
	startPerformance(nextItem.title);
};

const colors = {
	bgmain: "#FFFFFF",
	fgmain: "#230129",

	bgfailure: "#B70B14",
	fgfailure: "#FFFFFF",

	bgsuccess: "#179809",
	fgsuccess: "#FFFFFF",
};

const nbsp = String.fromCodePoint(0x00A0);
const bullet = String.fromCodePoint(0x2022);
const li = `${nbsp}${nbsp}${nbsp}${bullet}`;

const sendMenuNotice = (username, mod) => {
	const menu = getSortedMenu();
	const nextMenuItem = getNextMenuItem();
	const nextAmount = nextMenuItem.contributions
		.reduce((sum, c) => sum + c.amount, 0);
	const lines = ["Whatever is on top of the list is performed next"];

	for (const { title, percent, contributions } of menu) {
		const amount = contributions.reduce((sum, c) => sum + c.amount, 0);
		const div = 1 + (percent / 100);
		const diff = nextAmount - amount;
		const need = Math.floor(1 + (diff * div));

		const parts = [title];
		if (nextMenuItem.title === title) {
			parts.push("(next)");
		}
		else if (need === 1) {
			parts.push("(1 token behind)");
		}
		else {
			parts.push(`(${need} tokens behind)`);
		}
		if (mod) {
			if (percent > 0) {
				parts.push(`+${percent}% expensive`);
			}
			if (percent < 0) {
				parts.push(`-${Math.abs(percent)}% discount`);
			}
		}
		lines.push(parts.join(" "));

		const usernames = contributions
			.map(c => c.username)
			.filter(filterUnqiue);
		const aggregatedContributions = usernames.map((username_) => {
			const userContributions = contributions
				.filter(c => c.username === username_);
			const tokens = userContributions
				.reduce((sum, c) => sum + c.tokens, 0);
			const timestamp = userContributions
				.map(c => c.timestamp)
				.reduce((min, v) => Math.min(min, v));
			return { username: username_, tokens, timestamp };
		});
		const topContributions = aggregatedContributions
			.sort((a, b) => b.tokens - a.tokens)
			.slice(0, 3);

		for (const c of topContributions) {
			lines.push(`${li} ${c.tokens} tokens by @${c.username} ${timeago(c.timestamp)} ago`);
		}
	}

	if (mod) {
		const lastContributions = menu
			.map((item) => {
				return item.contributions.map(c => Object.assign({ }, c, {
					title: item.title,
				}));
			})
			.reduce((arr, sub) => arr.concat(sub))
			.sort((a, b) => b.timestamp - a.timestamp)
			.slice(0, 5);

		if (lastContributions.length !== 0) {
			lines.push("");
			for (const c of lastContributions) {
				lines.push(`${c.tokens} tokens by @${c.username} ${timeago(c.timestamp)} ago -- ${c.title}`);
			}
		}
	}

	cb.sendNotice(lines.join("\n"), username, colors.bgmain, colors.fgmain, "bold");
};

const sendAnnouncePerformanceNotice = () => {
	const { title, contributions } = getPerformedMenuItem();
	const contributors = contributions
		.map(c => c.username)
		.filter(filterUnqiue)
		.map(username => `@${username}`).join(", ");
	const announcement = contributors ? `${title} (thanks to ${contributors})` : title;

	cb.sendNotice(announcement, null, colors.bgmain, colors.fgmain, "bold");
};

const getPerformedPanelRow = () => {
	const performedMenuItem = getPerformedMenuItem();
	return performedMenuItem === null ? "" : performedMenuItem.title;
};

const getNextPanelRow = () => {
	const nextMenuItem = getNextMenuItem();
	return `${nextMenuItem.title} (next)`;
};

const getChasingPanelRow = () => {
	const nextMenuItem = getNextMenuItem();
	const chasingMenuItem = getChasingMenuItem();
	const nextAmount = nextMenuItem.contributions
		.reduce((sum, c) => sum + c.amount, 0);
	const chasingAmount = chasingMenuItem.contributions
		.reduce((sum, c) => sum + c.amount, 0);
	const diff = nextAmount - chasingAmount;
	const div = 1 + (chasingMenuItem.percent / 100);
	const need = Math.floor(1 + (diff * div));

	if (need === 1) {
		return `${chasingMenuItem.title} (1 token behind)`;
	}
	else {
		return `${chasingMenuItem.title} (${need} tokens behind)`;
	}
};

cb.tipOptions(() => {
	const menu = getMenu();
	const options = menu.map(item => ({ label: item.title }));
	const label = cb.settings["label"];
	return { options, label };
});

cb.onTip((evt) => {
	const username = evt["from_user"];
	const tokens = parseInt(evt["amount"]);
	const message = evt["message"];

	if (message !== "") {
		addContribution(message, username, tokens);
	}
	else {
		addContributionToPerformance(username, tokens);
	}

	cb.drawPanel();
});

cb.onEnter((evt) => {
	const username = evt["user"];
	sendMenuNotice(username);
});

cb.onMessage((evt) => {
	const username = evt["user"];
	const message = evt["m"];
	const mod = evt["is_mod"] || username === cb.room_slug;

	const isMenuCommand =
		message.toLowerCase() === "/menu" ||
		message.toLowerCase() === "/tipmenu";

	if (isMenuCommand) {
		sendMenuNotice(username, mod);
		evt["X-Spam"] = true;
	}

	if (username === cb.room_slug) {
		if (message.toLowerCase() === "/next") {
			startNextPerformance();
			sendAnnouncePerformanceNotice();
			evt["X-Spam"] = true;
			cb.drawPanel();
		}
		else {
			const menu = getMenu();
			for (const { cmd, title } of menu) {
				if (message.toLowerCase() === cmd) {
					startPerformance(title);
					sendAnnouncePerformanceNotice();
					evt["X-Spam"] = true;
					cb.drawPanel();
					break;
				}
			}
		}
	}

	return evt;
});

cb.onDrawPanel(() => {
	const performedRow = getPerformedPanelRow();
	const nextRow = getNextPanelRow();
	const chasingRow = getChasingPanelRow();

	return {
		"template": "3_rows_11_21_31",
		"row1_value": performedRow,
		"row2_value": nextRow,
		"row3_value": chasingRow,
	};
});

}(cb));