369 lines
14 KiB
JavaScript
Executable File
369 lines
14 KiB
JavaScript
Executable File
/**
|
|
* GHBot4Twitch
|
|
*/
|
|
|
|
// @TODO: modularize OBS and Twitch code
|
|
// @TODO: Make the bot aware of what video is current active
|
|
// @TODO: Change video playlist source on an interval
|
|
// @TODO: Rotating background images (leftside)
|
|
|
|
|
|
// Import modules
|
|
const irc = require('irc');
|
|
const OBSWebSocket = require('obs-websocket-js');
|
|
const schedule = require('node-schedule');
|
|
const util = require('./lib/util');
|
|
|
|
// Read internal configuration
|
|
let config = require('./config.json');
|
|
let currentPlaylist = config.obs.defaultPlaylist;
|
|
let twitchChannel = config.twitch.channels[0].toLowerCase();
|
|
|
|
// Connect to OBS Websocket
|
|
const obs = new OBSWebSocket();
|
|
console.log(`Connecting to OBS...`);
|
|
obs.connect({ address: config.obs.websocket.address, password: config.obs.websocket.password })
|
|
.then(() => {
|
|
console.log(`Success! We're connected to OBS!`);
|
|
return twitchInit(config, obs);
|
|
})
|
|
.then(data => {
|
|
return streamInit(config, obs, data);
|
|
})
|
|
.catch(err => {
|
|
console.log(err);
|
|
});
|
|
|
|
obs.on('error', err => {
|
|
console.error('OBS socket error:', err);
|
|
});
|
|
|
|
const twitchInit = (config, obs) => {
|
|
return new Promise((resolve, reject) => {
|
|
console.log('Connecting to Twitch...');
|
|
|
|
// Connect to Twitch IRC server with the Bot
|
|
let twitchChat = new irc.Client(config.twitch.ircServer, config.twitch.username, {
|
|
password: config.twitch.oauth,
|
|
autoRejoin: true,
|
|
retryCount: 10,
|
|
channels: config.twitch.channels,
|
|
debug: config.debug
|
|
});
|
|
|
|
// Also connect with an editor account
|
|
let editorChat = new irc.Client(config.twitch.ircServer, config.twitch.editorLogin.username, {
|
|
password: config.twitch.editorLogin.oauth,
|
|
autoRejoin: true,
|
|
retryCount: 10,
|
|
channels: config.twitch.channels,
|
|
debug: config.debug
|
|
});
|
|
|
|
// Set up event listeners for Twitch
|
|
twitchChat.addListener('message', (from, to, message) => {
|
|
// Ignore everything from blacklisted users
|
|
if (config.twitch.blacklistedUsers.includes(from)) return;
|
|
|
|
// Listen for commands that start with the designated prefix
|
|
if (message.startsWith(config.twitch.cmdPrefix)) {
|
|
let commandParts = message.slice(config.twitch.cmdPrefix.length).split(' ');
|
|
let commandNoPrefix = commandParts[0] || '';
|
|
|
|
// Listen for specific commands from admins
|
|
if (config.twitch.admins.includes(from) || from === config.twitch.username.toLowerCase()) {
|
|
|
|
if (commandNoPrefix === 'show' || commandNoPrefix === 'hide') {
|
|
|
|
let newVisibility = (commandNoPrefix === 'show');
|
|
let visibleTerm = (newVisibility ? 'visible' : 'hidden');
|
|
|
|
let target = commandParts[1] || false;
|
|
if (!target) {
|
|
twitchChat.say(to, `A scene item name is required!`);
|
|
return;
|
|
}
|
|
|
|
let sceneItem = {"item": target};
|
|
|
|
let sceneOrGroup = commandParts[2] || false;
|
|
if (sceneOrGroup !== false) {
|
|
sceneItem["scene-name"] = sceneOrGroup;
|
|
}
|
|
|
|
obs.getSceneItemProperties(sceneItem)
|
|
.then(data => {
|
|
if (data.visible === newVisibility) {
|
|
twitchChat.say(to, `This scene item is already ${visibleTerm}. DerpHam`);
|
|
} else {
|
|
sceneItem.visible = newVisibility;
|
|
obs.setSceneItemProperties(sceneItem)
|
|
.then(res => {
|
|
twitchChat.say(to, `${target} is now ${visibleTerm}.`);
|
|
})
|
|
.catch(console.error);
|
|
}
|
|
})
|
|
.catch(err => {
|
|
twitchChat.say(to, JSON.stringify(err));
|
|
});
|
|
|
|
} else if (commandNoPrefix === 't') {
|
|
let target = commandParts[1] || false;
|
|
if (!target) {
|
|
twitchChat.say(to, `A scene item name is required!`);
|
|
return;
|
|
}
|
|
|
|
let sceneItem = {"item": target};
|
|
|
|
obs.getSceneItemProperties(sceneItem)
|
|
.then(data => {
|
|
let newVisibility = !data.visible;
|
|
let visibleTerm = (newVisibility ? 'visible' : 'hidden');
|
|
|
|
sceneItem.visible = newVisibility;
|
|
obs.setSceneItemProperties(sceneItem)
|
|
.then(res => {
|
|
twitchChat.say(to, `${target} is now ${visibleTerm}.`);
|
|
})
|
|
.catch(console.error);
|
|
})
|
|
.catch(err => {
|
|
twitchChat.say(to, JSON.stringify(err));
|
|
});
|
|
} else if (commandNoPrefix === 'swap') {
|
|
// hide first argument, show second argument
|
|
let targetToHide = commandParts[1] || false;
|
|
let targetToShow = commandParts[2] || false;
|
|
if (targetToHide === false || targetToShow == false) {
|
|
twitchChat.say(to, `Format: ${config.twitch.cmdPrefix}swap <item-to-hide> <item-to-show>`);
|
|
return
|
|
}
|
|
|
|
obs.setSceneItemProperties({"item": targetToHide, "visible": false})
|
|
.then(res => {
|
|
obs.setSceneItemProperties({"item": targetToShow, "visible": true});
|
|
})
|
|
.catch(console.error);
|
|
} else if (commandNoPrefix === 'auw') {
|
|
// @TODO: switch to 'commercial' scene and show appropriate items, then switch back
|
|
// this way, playing a commercial doesn't have to know what's playing in the other scene
|
|
obs.setCurrentScene({"scene-name": "commercial"})
|
|
.then(res => {
|
|
// show the video
|
|
return obs.setSceneItemProperties({"item": "everybody-wow", "scene-name": "commercial", "visible": true});
|
|
})
|
|
.then(res => {
|
|
// mute songrequest audio
|
|
editorChat.say(to, '!volume 0');
|
|
// show owen
|
|
obs.setSceneItemProperties({"item": "owen", "scene-name": "commercial", "visible": true});
|
|
// tell chat what's up
|
|
twitchChat.say(to, 'Everybody OwenWow');
|
|
// swap back to fgfm scene after the video ends
|
|
setTimeout(() => {
|
|
// hide video
|
|
obs.setSceneItemProperties({"item": "everybody-wow", "scene-name": "commercial", "visible": false})
|
|
// hide owen
|
|
obs.setSceneItemProperties({"item": "owen", "scene-name": "commercial", "visible": false});
|
|
// unmute songrequest audio
|
|
editorChat.say(to, '!volume 75');
|
|
// swap back to fgfm
|
|
obs.setCurrentScene({"scene-name": "fgfm"});
|
|
}, 248000);
|
|
})
|
|
.catch(console.error);
|
|
|
|
} else if (commandNoPrefix === 'switch') {
|
|
|
|
let target = commandParts[1] || false;
|
|
if (!target) {
|
|
twitchChat.say(to, `A scene name is required!`);
|
|
return;
|
|
}
|
|
|
|
obs.getCurrentScene()
|
|
.then(data => {
|
|
if (data.name === target) {
|
|
twitchChat.say(to, `That scene is already active! DerpHam`);
|
|
} else {
|
|
obs.setCurrentScene({"scene-name": target})
|
|
.then(() => {twitchChat.say(to, `${target} is now active`)})
|
|
.catch(console.error);
|
|
}
|
|
})
|
|
.catch(console.error);
|
|
} else if (commandNoPrefix === 'reboot') {
|
|
console.log('Received request from admin to reboot...');
|
|
twitchChat.say(to, 'Rebooting...');
|
|
process.exit(0);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
twitchChat.addListener('error', message => {
|
|
if (message.command != 'err_unknowncommand') {
|
|
console.error('error from Twitch IRC Server: ', message);
|
|
}
|
|
});
|
|
editorChat.addListener('error', message => {
|
|
if (message.command != 'err_unknowncommand') {
|
|
console.error('error from Twitch IRC Server: ', message);
|
|
}
|
|
});
|
|
|
|
twitchChat.addListener('registered', message => {
|
|
console.log(`Connected to ${message.server}`);
|
|
});
|
|
|
|
twitchChat.addListener('join', (channel, nick, message) => {
|
|
if (nick === config.twitch.username) {
|
|
console.log(`Joined channel ${channel}`);
|
|
}
|
|
});
|
|
|
|
twitchChat.addListener('part', (channel, nick, message) => {
|
|
if (nick === config.twitch.username) {
|
|
console.log(`Left channel ${channel}`);
|
|
}
|
|
});
|
|
|
|
twitchChat.addListener('motd', motd => {
|
|
console.log(`Received MOTD: ${motd}`);
|
|
});
|
|
|
|
resolve({"botChat": twitchChat, "editorChat": editorChat});
|
|
});
|
|
}
|
|
|
|
const streamInit = (config, obs, twitch) => {
|
|
return new Promise((resolve, reject) => {
|
|
console.log(`Initializing stream timers...`);
|
|
|
|
// When: Every 4 hours at 55 past
|
|
// What: AUW
|
|
let auwJob = schedule.scheduleJob("55 */4 * * *", () => {
|
|
// AUW
|
|
twitch.editorChat.say(twitchChannel, `${config.twitch.cmdPrefix}auw`);
|
|
});
|
|
console.log(`AUW is scheduled to be shown at ${auwJob.nextInvocation()}`);
|
|
|
|
let userVotes = [];
|
|
let playlistChoices = config.obs.availablePlaylists.map((e, i, a) => {
|
|
return `[${i+1}] ${e.chatName}`;
|
|
});
|
|
const sayVote = () => {twitch.botChat.say(twitchChannel, `Vote for which video playlist you'd like to see next using ${config.twitch.cmdPrefix}vote #: ${playlistChoices.join(' | ')}`)};
|
|
/*setTimeout(sayVote, 5000);
|
|
setInterval(sayVote, 900000);*/
|
|
|
|
|
|
// When: Every 2 Hours
|
|
// What: Change the video playlist
|
|
let changePlaylistJob = schedule.scheduleJob("* */2 * * *", () => {
|
|
// Base the selection on user votes collected since the last invocation (unless there are 0 votes, then choose randomly)
|
|
let newPlaylist;
|
|
if (userVotes.length === 0) {
|
|
// choose a random item other than currentPlaylist from config.obs.availablePlaylists
|
|
let choices = config.obs.availablePlaylists.slice(0);
|
|
currentChoice = choices.indexOf(e => e.sceneItem === currentPlaylist);
|
|
choices.splice(currentChoice, 1);
|
|
newPlaylist = util.randElement(choices);
|
|
console.log(`PLAYLIST CHOSEN RANDOMLY: ${newPlaylist.chatName}`);
|
|
twitch.botChat.say(twitchChannel, `No Votes Logged -- Next Playlist Chosen at Random: ${newPlaylist.chatName}`);
|
|
} else {
|
|
// tally and sort votes
|
|
let voteTallies = [];
|
|
util.asyncForEach(userVotes, vote => {
|
|
tallyIndex = voteTallies.findIndex(e => e.id === vote.vote);
|
|
if (tallyIndex !== -1) {
|
|
voteTallies[tallyIndex].count++;
|
|
} else {
|
|
voteTallies.push({id: vote.vote, count: 1});
|
|
}
|
|
});
|
|
voteTallies.sort((a, b) => {
|
|
if (a.count < b.count) {
|
|
return -1;
|
|
}
|
|
if (a.count > b.count) {
|
|
return 1;
|
|
}
|
|
// a must be equal to b
|
|
return 0;
|
|
});
|
|
|
|
console.log(`Voting Results: ${JSON.stringify(voteTallies)}`);
|
|
newPlaylist = config.obs.availablePlaylists[voteTallies[0].id-1];
|
|
console.log(`WINNER OF THE VOTE: ${newPlaylist.chatName}`);
|
|
twitch.botChat.say(twitchChannel, `Winner of the Playlist Vote: ${newPlaylist.chatName}`);
|
|
|
|
// clear user votes
|
|
userVotes = [];
|
|
}
|
|
|
|
// only do this if the playlists are actually different
|
|
if (currentPlaylist === newPlaylist.sceneItem) {
|
|
twitch.botChat.say(twitchChannel, `We gucci. Stay comfy, nerds. DataComfy`);
|
|
} else {
|
|
console.log(`Changing playlist from ${currentPlaylist} to ${newPlaylist.sceneItem}`);
|
|
// @TODO: Don't use twitch chat for this
|
|
twitch.editorChat.say(twitchChannel, `${config.twitch.cmdPrefix}swap ${currentPlaylist} ${newPlaylist.sceneItem}`);
|
|
twitch.editorChat.say(twitchChannel, `!setcurrent NOW SHOWING: ${newPlaylist.activity}`);
|
|
// if we're showing TTAS segments, hide the label, if it's anything else, show
|
|
if (newPlaylist.sceneItem === 'ttas-segments') {
|
|
twitch.editorChat.say(twitchChannel, `${config.twitch.cmdPrefix}hide current-activity`);
|
|
} else {
|
|
twitch.editorChat.say(twitchChannel, `${config.twitch.cmdPrefix}show current-activity`);
|
|
}
|
|
currentPlaylist = newPlaylist.sceneItem;
|
|
}
|
|
});
|
|
console.log(`Playlist will be changed at ${changePlaylistJob.nextInvocation()}`);
|
|
|
|
// Track user votes for playlist
|
|
twitch.botChat.addListener('message', (from, to, message) => {
|
|
// Ignore everything from blacklisted users
|
|
if (config.twitch.blacklistedUsers.includes(from)) return;
|
|
|
|
// Listen for commands that start with the designated prefix
|
|
if (message.startsWith(config.twitch.cmdPrefix)) {
|
|
let commandParts = message.slice(config.twitch.cmdPrefix.length).split(' ');
|
|
let commandNoPrefix = commandParts[0] || '';
|
|
if (commandNoPrefix === 'vote') {
|
|
let userVote = commandParts[1] || false;
|
|
|
|
if (userVote === false) {
|
|
return sayVote();
|
|
}
|
|
|
|
userVote = Number.parseInt(userVote);
|
|
|
|
if (!Number.isInteger(userVote) || userVote < 1 || userVote > playlistChoices.length) {
|
|
return twitch.botChat.say(to, `@${from}, please choose an option from 1 - ${playlistChoices.length}!`);
|
|
}
|
|
|
|
// Check for uniqueness of vote
|
|
// if it's not unique, update the vote
|
|
let prevVote = userVotes.findIndex(e => e.from === from);
|
|
if (prevVote !== -1) {
|
|
if (userVotes[prevVote].vote !== userVote) {
|
|
// update vote and inform the user
|
|
userVotes[prevVote].vote = userVote;
|
|
twitch.botChat.say(to, `@${from}, your vote has been updated!`);
|
|
}
|
|
} else {
|
|
// log user vote
|
|
userVotes.push({"from": from, "vote": userVote});
|
|
twitch.botChat.say(to, `@${from}, your vote has been logged!`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// catches Promise errors
|
|
process.on('unhandledRejection', console.error);
|