Chaturbate

Bots Home | Create an App
Timers
Author: testerino
Description Source Code Launch Bot Current Users
There are 106 other versions of this script.
// Author: @grassyknoll35
// Version: 1.0

let owner;

const timers = {};

const messageToAdmins = `"Timers Bot" commands:
/timers "[name]" [duration]
/timers "[name]" [+/-][duration]
/timers "[name]" pause
/timers "[name]" resume
/timers "[name]" end
/timers "[name]"
/timers pause
/timers resume
/timers end
/timers
/timers [h/help]`;

const helpMessage = `"Timers Bot" help: /timers help`;

const messageToNonAdmins = `"Timers Bot" commands:
/timers
/timers "[name]"
/timers [h/help]`;

function atLeastOneTimerIsRunning() {
  let running = false;
  for (const name in timers) {
    if (timers[name].paused == false) {
      running = true;
      break;
    }
  }
  return running;
}

function usageReminder() {
  //if there are timers active
  if (Object.keys(timers).length > 0 && atLeastOneTimerIsRunning()) {
    //send help usage message to everyone
    cb.sendNotice(helpMessage, "", bg, fg, weight, "");
  } else {
    //if no timers active, just send the help command reminder to the owner and mods
    cb.sendNotice(helpMessage, owner.user, bg, fg, weight, "");
    cb.sendNotice(helpMessage, "", bg, fg, weight, "red");
  }
}

cb.settings_choices = [
  {name:"countdown", type:"choice",
    choice1:"Yes", choice2:"No", defaultValue:"Yes", required:true,
    label:"Give countdown for last 10 seconds of timer"},
  {name:"notice_times", type:"str", minLength:0, maxLength:255, defaultValue:"15m,5m,1m,30s",
    label:"Display timer when it hits any of these values. Separate values with commas. Example: '15m,5m,1m,30s'. Enter '-' or leave blank to disable."},
  {name:"help_interval", type:"str", minLength:0, maxLength:255, defaultValue:"20m",
    label:"Interval for displaying help command. Example: '20m'. Enter '-' or leave blank to disable."},
  {name:"background", type:"str", minLength:0, maxLength:7, defaultValue:"",
    label:"Timer message background color (html/hex color code). Example: '#33FFBA' (light blue). Enter '-' or leave blank to disable."},
  {name:"foreground", type:"str", minLength:0, maxLength:7, defaultValue:"",
    label:"Timer message foreground color (html/hex color code). Example: '#9233FF' (dark violet). Enter '-' or leave blank to disable."},
  {name:"font_weight", type:"choice",
    choice1:"normal", choice2:"bold", choice3:"bolder", defaultValue:"bold", required:true,
    label:"Timer message font weight"}
];

let notifyTimes = [15*60, 5*60, 60, 30]; //15m, 5m, 1m, 30s
let usageReminderTime = 20; //every 20 minutes
let bg = fg = "";
let weight = "bold";

function getTotalSeconds(hours, minutes, seconds) {
  //convert string value to number, or 0 if undefined
  hours = hours ? parseInt(hours, 10) : 0;
  minutes = minutes ? parseInt(minutes, 10) : 0;
  seconds = seconds ? parseInt(seconds, 10) : 0;
  return (hours*60*60 + minutes*60 + seconds);
}

function setNoticeTimes(notice_times) {
  notifyTimes = [];
  //trim all whitespace from string
  notice_times = notice_times.replace(/\s/g, "");
  //turn it into an array of times
  notice_times = notice_times.split(",");
  //for every item, calculate how many seconds it is
  for (let i=0; i<notice_times.length; i++) {
    const time = notice_times[i];
    //match on #h#m#s format
    const timeRegex = new RegExp(String.raw`^((\d+)h)?((\d+)m)?((\d+)s)?$`, "i");
    const match = timeRegex.exec(String.raw`${time}`);
    if (match) {
      let hours = match[2];
      let minutes = match[4];
      let seconds = match[6];
      //get the total amount of seconds
      const totalSeconds = getTotalSeconds(hours, minutes, seconds);
      if (totalSeconds)
        notifyTimes.push(totalSeconds); //add this second value to the array for notifications
    } else {
      cb.log(`This setting (notice time) is not formatted correctly: ${time}`);
    }
  }
}

function setHelpInterval(help_interval) {
  usageReminderTime = 0;
  //trim whitespace
  help_interval = help_interval.replace(/\s/g, "");
  //match on #h#m#s format
  const timeRegex = new RegExp(String.raw`^((\d+)h)?((\d+)m)?((\d+)s)?$`, "i");
  const match = timeRegex.exec(String.raw`${help_interval}`);
  if (match) {
    let hours = match[2];
    let minutes = match[4];
    let seconds = match[6];
    //get total seconds
    const totalSeconds = getTotalSeconds(hours, minutes, seconds);
    if (totalSeconds)
      usageReminderTime = totalSeconds; //set usage interval to this many seconds
  } else {
    cb.log(`This setting (help interval) is not formatted correctly: ${help_interval}`);
  }
}

function setBgFg(background, foreground) {
  const colorRegex = new RegExp(String.raw`^#[\da-fA-F]{6}$`, "i");
  let match = colorRegex.exec(String.raw`${background}`);
  if (match)
    bg = background;
  else
    cb.log(`This setting (background) is not formatted correctly: ${background}`);
  match = colorRegex.exec(String.raw`${foreground}`);
  if (match)
    fg = foreground;
  else
    cb.log(`This setting (foreground) is not formatted correctly: ${foreground}`);
}

cb.onStart(user => {
  owner = user;
  setNoticeTimes(cb.settings.notice_times);
  setHelpInterval(cb.settings.help_interval);
  setBgFg(cb.settings.background, cb.settings.foreground);
  weight = cb.settings.font_weight;
  usageReminder();
  if (usageReminderTime) {
    //every x minutes, remind how to run the help command
    function recurringReminder() {
      usageReminder();
      cb.setTimeout(recurringReminder, usageReminderTime*1000);
    }
    cb.setTimeout(recurringReminder, usageReminderTime*1000);
  }
});

cb.onBroadcastStart(user => {
  if (!owner) //just in case somehow owner is not defined
    owner = user;
  usageReminder();
});

cb.onEnter(user => {
  const isAdmin = (isOwner(msg.user) || msg.is_mod);
  //if stream owner or mod entered, show them the help command
  //if there are no timers and a regular user entered, don't show
  if (isAdmin || Object.keys(timers).length > 0) {
    //send help usage message
    cb.sendNotice(helpMessage, user.user, bg, fg, weight, "");
  }
});

cb.onMessage(msg => {
  const isAdmin = (isOwner(msg.user) || msg.is_mod);
  const username = isAdmin ? "" : msg.user;
  const hideRegex = new RegExp(String.raw`^\/timers.*$`, "i");
  const hideMatch = hideRegex.exec(String.raw`${msg.m}`);
  const timersRegex = new RegExp(String.raw`^(\/timers)(\s+((h(elp)?)|(("(.+)")?(\s*((\bpause\b|\bresume\b|\bend\b)|(([+-])?(((\d+)h)?((\d+)m)?((\d+)s)?))))?)))?$`, "i");
  const match = timersRegex.exec(String.raw`${msg.m}`);
  if (hideMatch) {
    msg["X-Spam"] = true;
  }
  if (match) {
    if (match[2]) {
      if (match[4]) {
        //we are running the help command
        if (isAdmin)
          cb.sendNotice(messageToAdmins, msg.user, bg, fg, weight, "");
        else
          cb.sendNotice(messageToNonAdmins, msg.user, bg, fg, weight, "");
      }
      else if (match[8]) {
        //we are operating on a single timer
        const name = match[8].toLowerCase();
        if (match[11]) {
          const action = match[11];
          switch (action) {
            case "pause":
              //pause timer
              if (isAdmin && timers[name])
                timers[name].paused = true;
              break;
            case "resume":
              //resume timer
              if (isAdmin && timers[name])
                timers[name].paused = false;
              break;
            case "end":
              //end timer
              if (isAdmin && timers[name])
                timers[name].time = 0;
              break;
            default:
              //invalid
              break;
          }
        } else if (match[12]) {
          const duration = match[12];
          const plusOrMinus = match[13];
          let hours = match[16];
          let minutes = match[18];
          let seconds = match[20];
          const totalSeconds = getTotalSeconds(hours, minutes, seconds);
          if (timers[name] && isAdmin) //if timer exists, update
            timers[name].updateTimer(plusOrMinus, totalSeconds);
          else if ((!plusOrMinus || plusOrMinus == "+") && isAdmin) //create a new timer
            createTimer(name, totalSeconds);
        } else {
          //print single timer value
          if (timers[name])
            timers[name].printTime("", username);
        }
      } else if (match[11]) {
        //we are operating on all timers
        const action = match[11];
        switch (action) {
          case "pause":
            if (isAdmin)
              pauseAllTimers();
            break;
          case "resume":
            if (isAdmin)
              resumeAllTimers();
            break;
          case "end":
            if (isAdmin)
              endAllTimers();
            break;
          default:
            //invalid
            break;
        }
      } else {
        //invalid
      }
    } else {
      //print all timers
      for (const name in timers)
        timers[name].printTime("", username);
    }
  }
  return msg;
});

function isOwner(username) {
  return (username == owner.user || username == cb.room_slug);
}

function pauseAllTimers() {
  for (const name in timers)
    timers[name].paused = true;
}

function resumeAllTimers() {
  for (const name in timers)
    timers[name].paused = false;
}

function endAllTimers() {
  for (const name in timers)
    timers[name].time = 0;
}

function createTimer(name, totalSeconds) {
  const t = {
    name: name,
    _paused: false,
    _updated: false,
    _time: totalSeconds,
    get paused() {
      return this._paused;
    },
    set paused(val) {
      this._paused = val;
      if (this._paused)
        this.printTime("paused", "");
      else
        this.printTime("resumed", "");

    },
    get time() {
      return this._time;
    },
    set time(val) {
      this._time = val;
      if (this._updated) {
        this._updated = false;
        this.printTime("updated", "");
      }
      //notify when timer is low
      if (notifyTimes.includes(this._time) || (cb.settings.countdown == "Yes" && (this._time <= 10 && this._time > 0)))
        this.printTime("", "");
      if (this._time <= 0)
        cb.sendNotice(`Timer "${this.name}" finished`, "", bg, fg, weight, "");
    },
    updateTimer(plusOrMinus, seconds) {
      this._updated = true;
      if (plusOrMinus == "+")
        this.time += seconds;
      else if (plusOrMinus == "-")
        this.time -= seconds;
      else
        this.time = seconds;
    },
    printTime(status, username) {
      if (this.paused == true)
        status = "paused";
      cb.sendNotice(`Timer "${this.name}" ${status}: ${convertTimeToHrMinSec(this._time)}`, username, bg, fg, weight, "");
    },
    decrementTime(ticks) {
      this.time -= ticks;
    }
  };
  timers[t.name] = t;
  timers[t.name].printTime("", "");
}

//convert time to readable format for chat
function convertTimeToHrMinSec(time) {
  const hrs = Math.floor(time / (60*60));
  time %= (60*60);
  const mins = Math.floor(time / 60);
  time %= 60;
  const secs = time;
  let returnString = "";
  if (hrs)
    returnString += `${hrs}h`;
  if (mins)
    returnString += `${mins}m`;
  if (secs)
    returnString += `${secs}s`;
  return returnString;
}


//code taken from: https://github.com/unimonkiez/self-adjusting-interval
function setSelfAdjustingInterval(callback, ms) {
  let expected = Date.now() + ms;
  let stop = false;
  const step = () => {
    if (stop) {
      return;
    }
    const delta = Date.now() - expected;
    const ticks = Math.max(1, 1 + Math.round(delta / ms));
    callback(ticks);
    const addToExpected = ms * ticks;
    expected += addToExpected;
    cb.setTimeout(step, addToExpected - delta);
  };
  cb.setTimeout(step, ms);
  const stopInterval = () => {
    stop = true;
  };
  return stopInterval;
}

//run the second ticker
const stopInterval = setSelfAdjustingInterval(ticks => {//ticks = 1 usually
  //decrement each timer by how many ticks have passed (usually 1)
  for (const name in timers) {
    //if the timer is at zero
    if (timers[name].time <= 0) {
      delete timers[name];
      continue;
    }
    //if the timer is non zero and not paused
    if (!timers[name].paused)
      timers[name].decrementTime(ticks);
  }
}, 1000);

//call this to stop the ticker
//stopInterval();