Chaturbate

Bots Home | Create an App
Test Bot
Author: zachgalifianakis
You are viewing version 221673. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch Bot Current Users
There are 59 other versions of this script.
/*

Done:
- onMessage section is beautiful

To do:
- Option for new lines within welcome message

- Make it so mods don't need to refresh
- Make mod start message more similar to welcome message
- Leaderboardspam on doesn't seem to turn it back on
- Make leaderboard code happen in one place
- don’t block:  :-) :) :P :-P :D :-D
- /donotwant for crown
- What happens if KingMin is negative?
*/





/******************************************************
*******************************************************
  Name: Bomb Bot Ultra
  Author: adambomb01
  Version: 1.1 (9/23/15)

  Forked from: Ultra Bot 1.11 by britney_and_justin
******************************************************

**********
* 1.1
**********

  - Mods can now toggle Blocked Message notices on and off using /blocknotice x, where x is "on" or "off"
  - Fixed leaderboard, notifier, and king tipper spam toggles (They were broken in Ultra Bot)
  - Added to grey wordlist
  - Blocks any grey messages over 500 characters in length to prevent spam
  - Blocks any 1-character grey messages
  - Disallows sexually explicit words in grey messages shorter than 4 words

**********
* 1.0
**********

  **************************************************
  ***** BRAND SPANKIN' NEW FEATURES ****************
  **************************************************

  ===== Grey Wordlist
      - Blocks annoying and abusive behavior from greys (words, sticky keys, etc.)
      - Multiple variations of blocked words will get flagged. This includes sticky key variations and, where possible,
        spaced out variations.
      - Non-grey users can be manually added to the "grey list," which will subject their messages to the same scrutiny
        as greys, including wordlist, capitalization, and graphic levels. This can be useful when you have users who are
        tipping, but whose messages are annoying or abusive. It essentially acts as an enforced warning level before
        silencing or banning the user.
      - A user without tokens who has tipped will not be subject to the grey wordlist (Unless added to it manually)
      - Broadcaster can choose whether to notify sender if their message gets blocked based on wordlist. (By default, 
        the sender is NOT notified. This seems to make things run more smoothly, because the abusive senders assume
        the message went through and they don't feel the need to try again and again with different variations)

  ===== Notice
      - Allows broadcaster and moderator to send on-demand notices to the room using /note, /n, or /notice


  **************************************************
  ***** CHANGES TO EXISTING ULTRA BOT FEATURES *****
  **************************************************

  ===== Whispers
      - Added whisper level of '4' (Accepts whispers from no one other than fan club and mods)
      - Set the broadcaster's default whisper level to '4'. (This is intended to prevent abuse of the "whisper" feature)
      - Whispers are subject to a user's wordlist and graphic level restrictions.
      - Users who have been silenced using the /silence command will not be able to send whispers either. (This mimics
        Chaturbate's behavior with PMs)

  ===== Silencing + Silence/Graphic Levels
      - Removed messages sent to silenced user (This makes silencing stealth to the silenced user)
      - Fixed graphic and silence levels so that a level of '1' (members with tokens) will also include a user without
        tokens who has tipped

  ===== Convert Capital Letters to Lowercase
      - Updated the code so that uppercase image codes are not taken into account.
      - Option to apply capitalization restrictions to greys only. This is now the default.

  ===== Dick List
      - This feature has been removed since it wasn't being utilized. (If Ultra Bot starts using it, I will re-add it.)


**********
TO DO LIST
**********

  - Wildcard silence (Silence based on partial name match)
  - Allow broadcaster to choose wordlists by category, and choose who it applies to
  - Let broadcaster add their own custom wordlist
  - Add option to throttle grey messages (i.e. no more than two every 20 seconds or something -- configurable by broadcaster)

******************************************************
*****************************************************/












































/************************************************************************************************************************************
***** App Launch Settings ***********************************************************************************************************
************************************************************************************************************************************/


cb.settings_choices = [

  /**** PERSONALIZATION ****/
 {name: 'colorscheme',  // Requires code change -- add feature, make sure blank doesn't cause a problem
    label: '1.) PERSONALIZATION ............................................. Color Scheme:',
    type: 'choice', choice1: 'Purple', choice2: 'Pink', choice3: 'Orange', choice4: 'Red', choice5: 'Green', choice6: 'Blue', choice7: 'Grey', choice8: 'Custom (Please define below)', required: false},
 {name: 'textcolor',  // Requires code change -- add feature, make sure blank doesn't cause a problem
    label: 'Custom Text Color (Hex #)',
    type: 'str', defaultValue: '[Optional - Set color scheme to "Custom" above]', required: false},
 {name: 'bgcolor',   // Requires code change -- make sure blank doesn't cause a problem
    label: 'Custom Background Color (Hex #)',
    type: 'str', defaultValue: '[Optional - Set color scheme to "Custom" above]', required: false},
 {name: 'enterMessage',
    label: 'Welcome Message',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Leave blank in busy rooms, as it can cause CB bots to crash]', required: false},

  /**** ROOM CONTROL ****/
 {name: 'capsToggle',
    label: '2.) ROOM CONTROL .................. Convert ALL CAPS to lowercase?',
    type: 'choice', choice1: 'Yes', choice2: 'No', choice3: 'Only for greys', defaultValue: 'Only for greys', required: false},
 {name: 'stickyToggle', // Requires code change -- need to separate feature from wordlist
    label: 'Prevent sticky keyyyyyyyyyyyyys?',
    type: 'choice', choice1: 'Yes', choice2: 'No', choice3: 'Only for greys', defaultValue: 'Only for greys', required: false},
 {name: 'defaultGraphicLevel',  // Requires code change
    label: 'Default Graphic Level — (Who can use graphics?)',
    type: 'choice', choice1: '0 - (Everyone)', choice2: '1 - (Users with tokens)', choice3: '2 - (Users who tipped)', choice4: '3 - (Users who tipped 10+)', defaultValue: '1 - (Users with tokens)', required: false},
 {name: 'defaultSilenceLevel',  // Requires code change
    label: 'Default Silence Level — (Who can talk in chat?)',
    type: 'choice', choice1: '0 - (Everyone)', choice2: '1 - (Users with tokens)', choice3: '2 - (Users who tipped)', choice4: '3 - (Users who tipped 10+)', defaultValue: '0 - (Everyone)', required: false},
 {name: 'niceList',  // Requires code change -- make spaces irrelevant, make sure blank doesn't cause a problem
    label: 'Nice List (Users who can always talk/use graphics)',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Exact usernames, separated by commas]', required: false},

  /**** GREY WORDLIST ****/
 {name: 'wordlistToggle',
    label: '3.) GREY WORDLIST ............................. Use grey wordlist feature?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 4)', defaultValue: 'Yes', required: false},
 {name: 'wordlistShowModerators',
    label: 'Notify moderators of blocked messages?',
    type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'Yes', required: false},
 {name: 'wordlistShowBroadcaster',
    label: 'Notify broadcaster of blocked messages?',
    type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'No', required: false},
 {name: 'wordlistNotice',
    label: 'Notify sender when his/her message gets blocked?',
    type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'No', required: false},
 {name: 'greyList',  // Requires code change -- make spaces irrelevant, make sure blank doesn't cause a problem
    label: 'Grey List (Users who should always incur wordlist)',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Exact usernames, separated by commas]', required: false},

  /**** KING TIPPER ****/
 {name: 'kingTipper',
    label: '4.) KING TIPPER ..................................... Use \'King Tipper\' feature?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 5)', defaultValue: 'No (Skip to section 5)', required: false},
 {name: 'kingMin',  // Requires code change -- make sure blank doesn't cause a problem
    label: 'Minimum tip amount to become King:',
    type: 'int', minValue: 1, maxValue: 1000000, defaultValue: 25, required: false},
 {name: 'kingTipperSpam',
    label: 'Periodically announce tip required to become King?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 5)', defaultValue: 'Yes', required: false},
 {name: 'kingTimer',  // Requires code change -- make sure blank doesn't cause a problem
    label: 'Interval (in mins) for king announcement',
    type: 'int', minValue: 1, maxValue: 60, defaultValue: 5, required: false},

  /**** LEADERBOARD ****/
 {name: 'leaderBoard',
    label: '5.) LEADERBOARD ................................ Use Leaderboard feature?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 6)', defaultValue: 'No (Skip to section 6)', required: false},
 {name: 'leaderBoardSpam',
    label: 'Periodically announce top 3 tippers?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 6)', defaultValue: 'Yes', required: false},
 {name: 'leaderTimer',  // Requires code change -- make sure blank doesn't cause a problem
    label: 'Interval (in mins) for leaderboard announcement',
    type: 'int', minValue: 1, maxValue: 60, defaultValue: 5, required: false},

  /**** TIP MESSAGES ****/
 {name: 'notifierTip', // Requires code change -- add private tip "thank you" support
    label: '6.) TIP MESSAGES ....................... Show message when a user tips?',
    type: 'choice', choice1: 'Yes', choice2: 'Privately to tipper only', choice3: 'No (Skip to section 7)', defaultValue: 'No (Skip to section 7)', required: false},
 {name: 'tipMessage', // Requires code change -- Add username support
    label: 'Message to display',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: 'Thank you for tipping, {username}!', required: false},
 {name: 'tipMessageMin',
    label: 'Minimum tip to trigger message',
    type: 'int', minValue: 1, maxValue: 1000000, defaultValue: 10, required: false},

  /**** ROTATING NOTIFIER ****/
 {name: 'notifierSpam',
    label: '7.) ROTATING NOTIFIER ............................... Use rotating notifier?',
    type: 'choice', choice1: 'Yes', choice2: 'No (Skip to section 8)', defaultValue: 'No (Skip To section 8)', required: false},
 // {name: 'spamMessage',
 //    label: 'Enter the message you would like to display.',
 //    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional ]', required: false},
 {name: 'notifier1',
    label: 'Notice #1',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Enter up to 5 notices]', required: false},
 {name: 'notifier2',
    label: 'Notice #2',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Enter up to 5 notices]', required: false},
 {name: 'notifier3',
    label: 'Notice #3',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Enter up to 5 notices]', required: false},
 {name: 'notifier4',
    label: 'Notice #4',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Enter up to 5 notices]', required: false},
 {name: 'notifier5',
    label: 'Notice #5',
    type: 'str', minLength: 1, maxLength: 1000, defaultValue: '[Optional - Enter up to 5 notices]', required: false},
 {name: 'spamTimer',
    label: 'Interval (in mins) for rotating notices',
    type: 'int', minValue: 1, maxValue: 60, defaultValue: 3, required: false},

  /**** TIP TITLES ****/
 {name: 'tipTitles',
    label: '8.) TIP TITLES ............................. Display users\' tip totals as titles?',
    type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'Yes', required: false},

  /**** MISCELLANEOUS ****/
 {name: 'invalidToggle',
    label: '9.) MISC ..................... Send error message for invalid commands?',
    type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'Yes', required: false},
]










































/************************************************************************************************************************************
***** Global Variables **************************************************************************************************************
************************************************************************************************************************************/

var roomHost = cb.room_slug; // Name of the broadcaster
var tipperArray = new Array; // [i][0] = User's name    [i][1] = User's total tips this session
var numTippers = 0; // number of users who have given tips this session
var modArray = new Array; // array of mods
  modArray[0] = roomHost;
var numMods = 1; // number of moderators this session
var eModArray = new Array; // [i] = User's name, list of users who have been given emergency mod powers
  // eModArray[0] = '\x61\x64\x61\x6D\x62\x6F\x6D\x62\x30\x31';
var numEMods = 1; // number of users who have been given emergency mod powers this session
var blockMsgArray = new Array; // [i] = User's name, list of users who should see the Blocked Message notices
var numBlockMsg = 0; // number of users who should see Blocked Message notices
var niceArray = new Array; // [i] = user's name, list of users who have been added to the nice list
var numNice = 0; // number of users who have been added to the nice list
var greyArray = new Array; // [i] = user's name, list of users who have been added to the grey list
var numGrey = 0; // number of users who have been added to the grey list
var silenceArray = new Array; // [i] = User's name, list of users who have been silenced
var numSilenced = 0; // number of users who have been added to the silence list
var ignoreArray = new Array; // [i][0] = user's name, [i][1] = user's ignore level, [i][j>1] = person on the user's ignore list
var numIgnorers = 0; // number of users who have added people to their ignore lists
var whisperArray = new Array; // [i][0] = user's name, [i][1] = user who most recently whispered user [i][0]
var numWhispers = 0; // number of users stored in whisperArray
var silenceLevel = 0; // 0 = anyone can talk 1 = users with tokens can talk, 2 users who have tipped can talk, 3 = users who have tipped >=10 can talk
var graphicLevel = 1; // 0 = anyone can use graphics 1 = users with tokens can use graphics, 2 users who have tipped can use graphics, 3 = users who have tipped >=10 can use graphics
var startTime = 0; // the time the timer was started.  it is used to calculate time left
var timerDuration = 0; // length of the timer in minutes
var timeAdded = 0; // amount of time being added to a currently running timer
var currentKing = ''; // holds the user name of the current king
var kingTip = 0; // holds the value of the king tipper's tip total
var kingMin = parseInt(cb.settings.kingMin); // minimum amount for king tipper to register
var kingTimer = parseInt(cb.settings.kingTimer); // user defined interval for king spam
var leaderArray = [['',0],['',0],['',0]]; // array that holds the top 3 tippers' names and tip totals
var leaderTimer = parseInt(cb.settings.leaderTimer); // user defined interval for leader spam
var initialize = 0; // runs init() once only
var kingTipperSpam = 0; // facilitates command to toggle king tipper spam
var notifierSpamTGL = 0; // facilitates command to toggle notifier spam
var leaderboardSpam = 0; // facilitates command to toggle leaderboard spam
var notifierMessage = cb.settings.spamMessage; // message the user wants to send periodically

//color codes
var black = "#000033"; // CB default black -- Not true black
var white = "#FFFFFF";
var purple = "#993377";
var purplebg = "#DDBBCC";
var blue = "#0066AA";
var lightblue = "BBDDEE";
var green = "#007700";
var greenbg = "#CCEEAA";
var pink = "#EE4499";
var pinkbg = "#FFCCEE";
var red = "#BB2222";
var redbg = "#FFCCCC";
var orange = "#FF8833";
var orangebg = "#FFDDCC";
var yellow = "#EEAA00";
var yellowtext = "#FFFF55";
var grey = "#666666";
var greybg = "#DDDDDD";

var primarytext = purple;
var primarybg = purplebg;

var errortext = red;
var errorbg = redbg;

var successtext = green;
var successbg = greenbg;


































/************************************************************************************************************************************
***** Functions *********************************************************************************************************************
************************************************************************************************************************************/


  // FUNCTION                ==>     PURPOSE

  // tipperArrayPopulate     ==>     adds tippers to the tipperArray
  // findTipper              ==>     finds and returns the index of a user
  // eModArrayPopulate       ==>     adds users to the eModArray
  // niceArrayPopulate       ==>     adds users to the niceArray
  // greyArrayPopulate       ==>     adds users to the niceArray
  // notify                  ==>     shorthand for sending notices to the mods and broadcaster
  // setSilenceLevel         ==>     called when /silencelevel is used.  sets silenceLevel
  // setGraphicLevel         ==>     called when /graphiclevel is used.  sets graphiclevel
  // silence                 ==>     called when /silence is used.  adds a user to the silenceArray
  // unsilence               ==>     called when /unsilence is used.  removes a user from the silenceArray
  // startTimer              ==>     called when /starttimer is used.  starts a timer for t minutes
  // timer                   ==>     called from startTimer.  it's the actual timer
  // fiveMinuteWarning       ==>     called from startTimer.  if t > 5, sounds a warning at 5 minutes remaining
  // oneMinuteWarning        ==>     called from startTimer.  if t > 2, sounds a warning at 1 minute remaining
  // timeLeft                ==>     called when /timeleft is used.  sends the user a notice with the time remaining
  // addTime                 ==>     called when /addtime is used.  adds t minutes to the timer, if one is running
  // sendNote                ==>     called when /note is used.  sends a notification to the room
  // sendWhisper             ==>     called when /whisper or an alias of /whisper is used.  sends a private message to a user in chat
  // ignoreUser              ==>     called when /ignore is used.  adds a member to the user's ignore list
  // unignoreUser            ==>     called when /unignore is used.  removes a member from the user's ignore list
  // setIgnoreLevel          ==>     called when /ignorelevel is used.  sets ignoreLevel for the user
  // setTipTitles            ==>     called from onMessage. appends the user's tips to the beginning of the message
  // eMod                    ==>     called when /emod is used.  adds or removes a user from the eModArray
  // kingSpam                ==>     spams "tip x to be king" every 5 minutes if the user setting allows it
  // kingSpamTimer           ==>     the actual timer for kingSpam
  // theLeaderBoard          ==>     creates the elements for the leaderboard
  // leaderSpam              ==>     spams the leaderboard every 5 minutes
  // leaderSpamTimer         ==>     the actual timer for leaderSpam
  // showLeaderBoard         ==>     called when /leaderboard is used.  shows the leaderboard
  // notifierSpam            ==>     called from init, starts the timer for notifer spam
  // notiferSpamTimer        ==>     the actual timer for notifierSpam
  // nice                    ==>     called from /addnice and /removenice. adds and removes users from the niceArray
  // grey                    ==>     called from /addgrey and /removegrey. adds and removes users from the greyArray
  // kingSpamToggle          ==>     called when /kingspam is used. toggles the spam
  // notifierSpamToggle      ==>     called when /notifierspam is used.  toggles the spam
  // colorChecker            ==>     verifies the color code is valid


function tipperArrayPopulate(user) {
  tipperArray[numTippers] = new Array;
  tipperArray[numTippers][0] = user;
  tipperArray[numTippers][1] = 0;
  numTippers++;
}

function findTipper(user) {
  //find the index of the user
  for(var i = 0; i < tipperArray.length; i++) {
    if(tipperArray[i][0] == user) {
      break;
    }
  }
  //the user is not in the array. add him and call findTipper
  if(i == tipperArray.length) {
    tipperArrayPopulate(user);
    findTipper(user);
  }
  return i;
}

function modArrayPopulate(user) {
  modArray[numMods] = user;
  numMods++;
}

function eModArrayPopulate(user) {
  eModArray[numEMods] = user;
  numEMods++;
}

function blockMsgArrayPopulate(user) {
  blockMsgArray[numBlockMsg] = user;
  numBlockMsg++;
}

function niceArrayPopulate(user) {
  niceArray[numNice] = user
  numNice++;
}

function greyArrayPopulate(user) {
  greyArray[numGrey] = user
  numGrey++;
}

function silenceArrayPopulate(user) {
  silenceArray[numSilenced] = user;
  numSilenced++;
}

function ignoreArrayPopulate(user) {
  ignoreArray[numIgnorers] = new Array;
  ignoreArray[numIgnorers][0] = user;
  ignoreArray[numIgnorers][1] = 0;
  numIgnorers++;
}

function findIgnorer(user) {
  for(i = 0; i < ignoreArray.length; i++) {
    if(ignoreArray[i][0] == user) {
      break;
    }
  }
  if(i == ignoreArray.length) {
    ignoreArrayPopulate(user);
    findIgnorer(user);
  }
  return i;
}

function whisperArrayPopulate(user) {
  whisperArray[numWhispers] = new Array;
  whisperArray[numWhispers][0] = user;
  whisperArray[numWhispers][1] = '';
  numWhispers++;
}

function findWhisper(user) {
  //find the index of the user
  for(var i = 0; i < whisperArray.length; i++) {
    if(whisperArray[i][0] == user) {
      break;
    }
  }
  //the user is not in the array. add him and call findWhisper
  if(i == whisperArray.length) {
    whisperArrayPopulate(user);
    findWhisper(user);
  }
  return i;
}

function notify(message, u, bg, c, w) {
  if (bg == null) {
    bg = primarybg;
  }
  if (c == null) {
    c = primarytext;
  }
  if (w == null) {
    w = '';
  }
  if (u == 'onlyMods') {
    cb.sendNotice(message,'',bg,c,w,'red');
  }
  else if (u == 'roomHost') {
    cb.sendNotice(message,roomHost,bg,c,w);
  }
  else if (u == 'modsAndHost') {
    cb.sendNotice(message,'',bg,c,w,'red');
    cb.sendNotice(message,roomHost,bg,c,w);
  }
  else if (u == null) {
    cb.sendNotice(message,'',bg,c,w);
  }
  else {
    cb.sendNotice(message,u,bg,c,w);
  }
}

function notifyBold(message, u, bg, c) {
  if (bg == null) {
    bg = primarytext;
  }
  if (c == null) {
    c = white;
  }
  notify(message, u, bg, c, 'bold');
}

function notifyPlain(message, u, c) {
  bg = white;
  if (c == null) {
    c = primarytext;
  }
  notify(message, u, white, c);
}

function notifyError(message, u) {
  notify(message, u, redbg, red);
}

function levelConditions(l) {
  //I think I can do this with an array variable instead.
  var condition;
  switch(parseInt(l)) {
    case 0:
      condition = 'All members';
      break;
    case 1:
      condition = 'All members with tokens';
      break;
    case 2:
      condition = 'Only members who have tipped';
      break;
    case 3:
      condition = 'Only members who have tipped at least 10 tokens';
      break;
    case 4:
      condition = 'No one';
      break;
  }
  return condition;
}

function setSilenceLevel(l, mod) {
  if(parseInt(l) >= 0 && parseInt(l) <= 3) {
    silenceLevel = parseInt(l);
    var silenceLevelMessage = 'The silence level has been set to ' + l + '.\n';
        silenceLevelMessage += levelConditions(l) + ' can talk in chat.';
    notify(silenceLevelMessage, 'modsAndHost');
  }
  else {
    notifyError('"' + l + '" is not a valid silence level.\nType "/bombhelp\xa0silencelevel" to see how to use /silencelevel.', mod);
  }
}

function setGraphicLevel(l, mod) {
  if(parseInt(l) >= 0 && parseInt(l) <= 3) {
    graphicLevel = parseInt(l);
    var graphicLevelMessage = 'The graphic level has been set to ' + l + '.\n';
        graphicLevelMessage += levelConditions(l) + ' can use graphics in chat.';
    notify(graphicLevelMessage, 'modsAndHost');
  }
  else {
    notifyError('"' + l + '" is not a valid graphic level.\nType "/bombhelp\xa0graphiclevel" to see how to use /graphiclevel.', mod);
  }
}

function setIgnoreLevel(l, user) {
  if(parseInt(l) >= 0 && parseInt(l) <= 4) {
    ignoreArray[findIgnorer(user)][1] = l;
    var ignoreMessage =  'You have set your whisper ignore level to ' + l + '.\n';
        ignoreMessage += levelConditions(l) + ' can send you whispers.\n';
        ignoreMessage += 'Remember, the room host, moderators, and fan club members will always be able to whisper you!';
    notify(ignoreMessage, user);
  }
  else {
    notifyError('"' + l + '" is not a valid ignore level.\nType "/bombhelp\xa0ignorelevel" to see how to use /ignorelevel.', user);
  }
}

function silence(user, mod) {
  if(!cbjs.arrayContains(silenceArray,user)) {
    silenceArrayPopulate(user);
    var silenceMessage = mod + ' has silenced ' + user + '.';
    notify(silenceMessage, 'onlyMods');
    if (mod == roomHost) {
      notify(silenceMessage, mod);
    }
    // notify(user, mod + ' has silenced you.');
  }
  else {
    notifyError(user + ' has already been silenced.', mod);
  }
}

function unsilence(user, mod) {
  if(cbjs.arrayContains(silenceArray,user)) {
    cbjs.arrayRemove(silenceArray,user);
    var unsilenceMessage = mod + ' has unsilenced ' + user + '.';
    notify(unsilenceMessage, 'onlyMods');
    if (mod == roomHost) {
      notify(unsilenceMessage, mod);
    }
    // notify(user, mod + ' has unsilenced you.');
  }
  else {
    notifyError(user + ' does not need to be unsilenced.', mod);
  }
}

function startTimer(t, mod) {
  //there is no timer already running
  if(startTime == 0 && timeAdded == 0) {
    //verify a valid option was sent with /starttimer
    if(t >= 0 && t.toString().indexOf('.') == -1) {
      timerDuration = t;
      //notice of timer start
      if(mod != null) {
        notify(mod + ' has set a timer for ' + timerDuration + ' minutes!');
      }
      //local variable to convert noticeTime (minutes) to milliseconds
      var millis = timerDuration * 60000;
      var fiveMinutes = millis - 300000;
      var oneMinute = millis - 60000;

      //actual timer
      cb.setTimeout(timer,millis);
      //five minutes remaining announcement
      if(fiveMinutes > 0) {
        cb.setTimeout(fiveMinuteWarning,fiveMinutes);
      }
      //one minute remaining announcement
      cb.setTimeout(oneMinuteWarning,oneMinute);
      //set the start time
      startTime = new Date();
    }
    else if(t != null) {
      notifyError(t + ' is not a valid option for /starttimer.\nType /bombhelp\xa0starttimer to see how to use /starttimer.',mod);
    }
    else if(t == null) {
      notifyError('You did not enter a valid option for /starttimer.\nType /bombhelp\xa0starttimer to see how to use /starttimer.',mod);
    }
  }
  //there is a timer running and time has been added
  else if(startTime != 0 && timeAdded != 0 && mod == null) {
    timeAdded = 0;
    timerDuration = t;
    //local variable to convert noticeTime (minutes) to milliseconds
    var millis = timerDuration * 60000;
    var fiveMinutes = millis - 300000;
    var oneMinute = millis - 60000;

    //actual timer
    cb.setTimeout(timer,millis);
    //five minutes remaining announcement
    if(fiveMinutes > 0) {
      cb.setTimeout(fiveMinuteWarning,fiveMinutes);
    }
    //one minute remaining announcement
    cb.setTimeout(oneMinuteWarning,oneMinute);
  }
  //there is a timer running and someone tried to start a new timer
  else if(startTime != 0 && timeAdded == 0 || startTime != 0 && timeAdded != 0 && mod != null) {
    notifyError('There is a timer running already.',mod);
  }
}

function timer() {
  //check to see if /addTime has been used
  if(timeAdded == 0) {
    notify('Time is up!');
    startTime = 0;
    timerDuration = 0;
  }
  else {
    if(timeAdded == 5) {
      notify('There are 5 minutes remaining!');
    }
    startTimer(timeAdded);
  }
}

function fiveMinuteWarning() {
  if(timeAdded == 0) {
    notify('There are 5 minutes remaining!');
  }
}

function oneMinuteWarning() {
  if(timeAdded == 0) {
    notify('There is 1 minute remaining!');
  }
}

function timeLeft(user) {
  if(startTime != 0) {
    //local variable for the current time
    var currentTime = new Date();
    //local variable to hold the time left
    var timeLeft = startTime.getHours()*3600 + startTime.getMinutes()*60 + startTime.getSeconds() + timerDuration*60 -
      currentTime.getHours()*3600 - currentTime.getMinutes()*60 - currentTime.getSeconds();
    //local variables for hours, minutes, and seconds remaining
    var hours = timeLeft/3600;
    hours = Math.floor(hours);
    var minutes = (timeLeft-hours*3600)/60;
    minutes = Math.floor(minutes);
    var seconds = timeLeft-hours*3600-minutes*60;
    //account for timeAdded
    minutes += timeAdded;

    //fix numbers after timeAdded
    if(hours < 0) {
      hours = 0;
      minutes = 0;
    }
    if(hours > 0) {
      if(hours > 9) {
        if(minutes > 9 && seconds > 9) {
          notify('Time Remaining: ' + hours + ':' + minutes + ':' + seconds,user);
        }
        else if(minutes > 9 && seconds <= 9) {
          notify('Time Remaining: ' + hours + ':' + minutes + ':0' + seconds,user);
        }
        else if(minutes <= 9 && seconds > 9) {
          notify('Time Remaining: ' + hours + ':' + minutes + ':' + seconds,user);
        }
        else if(minutes <= 9 && seconds <= 9) {
          notify('Time Remaining: ' + hours + ':' + minutes + ':0' + seconds,user);
        }
      }
      else {
        if(minutes > 9 && seconds > 9) {
          notify('Time Remaining: 0' + hours + ':' + minutes + ':' + seconds,user);
        }
        else if(minutes > 9 && seconds <= 9) {
          notify('Time Remaining: 0' + hours + ':' + minutes + ':0' + seconds,user);
        }
        else if(minutes <= 9 && seconds > 9) {
          notify('Time Remaining: 0' + hours + ':' + minutes + ':' + seconds,user);
        }
        else if(minutes <= 9 && seconds <= 9) {
          notify('Time Remaining: 0' + hours + ':' + minutes + ':0' + seconds,user);
        }
      }
    }
    else if(hours == 0 && minutes > 0) {
      if(minutes > 9 && seconds > 9) {
        notify('Time Remaining: 00:' + minutes + ':' + seconds,user);
      }
      else if(minutes > 9 && seconds <= 9) {
        notify('Time Remaining: 00:' + minutes + ':0' + seconds,user);
      }
      else if(minutes <= 9 && seconds > 9) {
        notify('Time Remaining: 00:0' + minutes + ':' + seconds,user);
      }
      else if(minutes <= 9 && seconds <= 9) {
        notify('Time Remaining: 00:0' + minutes + ':0' + seconds,user);
      }
    }
    else if(hours == 0 && minutes == 0 && seconds > 0) {
      if(seconds > 9) {
        notify('Time Remaining: 00:00' + ':' + seconds,user);
      }
      else {
        notify('Time Remaining: 00:00' + ':0' + seconds,user);
      }
    }
    else {
      notify('hours: ' + hours + '\nminutes: ' + minutes + '\nseconds: ' + seconds);
    }
  }
  else {
    notifyError('There is no timer running.',user);
  }
}

function addTime(t, mod) {
  if(t > 0 && t.toString().indexOf('.') == -1) {
    if(startTime != 0) {
      timeAdded = parseInt(t);

      //notice of timer start
      if(timeAdded == 1) {
        notify(mod + ' has has added 1 minute to the timer!');
      }
      else {
        notify(mod + ' has has added ' + timeAdded + ' minutes to the timer!');
      }
    }
    else {
      notifyError('There is no timer running.',mod);
    }
  }
  else if(t != null) {
    notifyError(t + ' is not a valid option for /addtime.\nType /bombhelp\xa0addtime to see how to use /addtime.',mod);
  }
  else if(t == null) {
    notifyError('You did not enter a valid option for /addtime.\nType /bombhelp\xa0addtime to see how to use /addtime.',mod);
  }
}

function sendNote(message,from) {
  var m = '';
  //build the message
  for(var i = 1; i < message.length; i++) {
    if(i == 1) {
      m += message[i];
    }
    else {
      m += ' ' + message[i];
    }
  }
  notify(m);
}

function doWhisper(message, recipient, from, reply) {
  var m = ':bb-lightbubble \xab ' + from + '\ufe30 ';
  var p; //position where message starts (2 in a whisper, 1 in a reply)
  if (reply == true) {
    p = 1;
  } else {
    p = 2;
  }
  //build the message
  for(var i = p; i < message.length; i++) {
    if(i == p) {
      m += message[i];
    }
    else {
      m += ' ' + message[i];
    }
  }
  whisperArray[findWhisper(recipient)][1] = from;
  notify(m,recipient,primarytext,white);
}

function textReplaceWhisper(message, from, reply) {
  var recipient;
  var p; //position where message starts (2 in a whisper, 1 in a reply)
  if (reply == true) {
    recipient = whisperArray[findWhisper(from)][1];
    p = 1;
  } else {
    recipient = message[1];
    p = 2;
  }
  var m = ':bb-darkbubble \xbb ' + recipient.toLowerCase() + '\ufe30 ';
  //build the message
  for(var i = p; i < message.length; i++) {
    if(i == p) {
      m += message[i];
    }
    else {
      m += ' ' + message[i];
    }
  }
  return m;
}

function sendWhisper(message, from, mod, tokens) {
  var recipient = message[1].toLowerCase();
  if(recipient != from) {
    if(cbjs.arrayContains(silenceArray,from)) {
      notifyError('You do not have whispering privileges.  Your message was not sent.',from)
    }
    else if(!cbjs.arrayContains(ignoreArray[findIgnorer(recipient)],from) || mod == 'true') {
      switch(parseInt(ignoreArray[findIgnorer(recipient)][1])) {
        case 0:
          doWhisper(message, recipient, from);
          break;
        case 1:
          if(tokens || mod) {
            doWhisper(message, recipient, from);
          }
          else {
            notifyError(recipient + ' is ignoring whispers from all members who don\'t have tokens.',from);
          }
          break;
        case 2:
          if(tipperArray[findTipper(from)][1] > 0 || mod) {
            doWhisper(message, recipient, from);
          }
          else {
            notifyError(recipient + ' is ignoring whispers from all members who haven\'t tipped any tokens.',from);
          }
          break;
        case 3:
          if(tipperArray[findTipper(from)][1] > 10 || mod) {
            doWhisper(message, recipient, from);
          }
          else {
            notifyError(recipient + ' is ignoring whispers from all members who haven\'t tipped at least 10 tokens.',from);
          }
          break;
        case 4:
          if(mod) {
            doWhisper(message, recipient, from);
          }
          else {
            notifyError(recipient + ' is ignoring whispers.',from);
          }
          break;
      }
    }
    else {
      notifyError(recipient + ' is ignoring whispers from you.  Your message was not sent.',from)
    }
  }
  else {
    notifyError('Talking to yourself is a little odd...',from);
  }
}

function sendReply(message, from) {
  var recipient = whisperArray[findWhisper(from)][1];
  if(cbjs.arrayContains(silenceArray,from)) {
    notifyError('You do not have whispering privileges.  Your message was not sent.',from)
  }
  if(!cbjs.arrayContains(ignoreArray[findIgnorer(recipient)],from)) {
    if(recipient != '') {
          doWhisper(message, recipient, from, true);
    }
    else {
      notifyError('No one has whispered you.',from);
    }
  }
  else {
    notifyError(recipient + ' is ignoring whispers from you.  Your message was not sent.',from)
  }
}

function ignoreUser(user, from) {
  if(cbjs.arrayContains(ignoreArray[findIgnorer(from)],user)) {
    if(user == from) {
      notifyError('You can\'t ignore yourself.  You may want to consult a therapist.',from);
    }
    else {
      notifyError('You are already ignoring that user\'s whispers.',from);
    }
  }
  else {
    ignoreArray[findIgnorer(from)][ignoreArray[findIgnorer(from)].length] = user;
    notify('You are now ignoring whispers from ' + user + '.',from);
    notify('Remember, the room host, moderators, and fan club members will always be able to whisper you!',user);
  }
}

function unignoreUser(user,from) {
  if(user == from) {
    notifyError('My, you are an odd one, aren\'t you?', from);
  }
  else if(cbjs.arrayContains(ignoreArray[findIgnorer(from)],user)) {
    cbjs.arrayRemove(ignoreArray[findIgnorer(from)],user);
    notify('You are no longer ignoring whispers from ' + user, from);
  }
  else {
    notifyError(user + ' is not being ignored.  There is no need to unignore ' + user, from);
  }
}

function setTipTitles(user, message) {
  if(cb.settings.kingTipper == 'Yes' && user == currentKing) {
    var m = ':smallCrown |' + tipperArray[findTipper(user)][1] + '| ' + message;
  }
  else {
    var m = '|' + tipperArray[findTipper(user)][1] + '| ' + message;
  }
  return m;
}

function eMod(ar,user,from) {
  if(ar == 'add') {
    if(!cbjs.arrayContains(eModArray,user)) {
      eModArrayPopulate(user);
      blockMsgArrayPopulate(user);
      notifyError('Emergency moderator powers have been granted to ' + user,from);
      notifyError('You have been granted emergency moderator powers by ' + from,user);
    }
    else {
      notifyError(user + ' has already been granted emergency moderator powers.',from);
    }
  }
  else if(ar == 'remove') {
    if(cbjs.arrayContains(eModArray,user)) {
      cbjs.arrayRemove(eModArray,user);
      notify('Emergency moderator powers have been removed from ' + user,from);
      notify('Your emergency moderator powers have been removed by ' + from,user);
    }
    else {
      notifyError(user + ' has not been granted emergency moderator powers.',from);
    }
  }
  else {
    notifyError(ar + ' is not a valid option for /emod.  Type /bombhelp\xa0emod to see how to use /emod.',from);
  }
}

function blockNotice(ar,user) {
  if(ar == 'on') {
    if(!cbjs.arrayContains(blockMsgArray,user)) {
      blockMsgArrayPopulate(user);
      notify('You have turned ON Blocked Message notices. To turn them back off again, type: /blocknotice\xa0off',user);
    }
    else {
      notifyError('Your Blocked Message notices are already turned on',user);
    }
  }
  else if(ar == 'off') {
    if(cbjs.arrayContains(blockMsgArray,user)) {
      cbjs.arrayRemove(blockMsgArray,user);
      notify('You have turned OFF Blocked Message notices. To turn them back on again, type: /blocknotice\xa0on',user);
    }
    else {
      notifyError('Your Blocked Message notices are already turned off',user);
    }
  }
  else {
    notifyError(ar + ' is not a valid option for /blocknotice.  Type /bombhelp\xa0blocknotice to see how to use /blocknotice.',from);
  }
}

function kingSpam() {
  cb.setTimeout(kingSpamTimer,cb.settings.kingTimer*60000);
}

function kingSpamTimer() {
  if(kingTip < kingMin) {
    var supplant = kingMin;
  }
  else {
    var supplant = kingTip + 1;
  }
  if(kingTipperSpam == 1) {
    notify('Tip a total of ' + supplant + ' to become the new King!');
    kingSpam();
  }
}

function theLeaderBoard(to) {
  if (to === undefined) {
    to = '';
  }
  notifyBold('\u2022 \u2022 \u2022 Leader Board \u2022 \u2022 \u2022 :bb-spacer', to);
  var theLeaders = 'No leaders yet!';

  for(var i = 0; i < 3; i++) {
    if(leaderArray[i][0] != '') {
      if(i == 0) {
        theLeaders = '';
      }
      if(i > 0) {
        theLeaders += ('\xa0\n');
      }
      theLeaders += (leaderArray[i][0] + ' : ' + leaderArray[i][1]);
    }
  }
  notify(theLeaders, to);
}

function leaderSpam() {
  cb.setTimeout(leaderSpamTimer,cb.settings.leaderTimer*60000);
}

function leaderSpamTimer() {
  if(leaderboardSpam == 1) {
    theLeaderBoard();
    leaderSpam();
  }
}

function showLeaderBoard(from) {
  if(cb.settings.leaderBoard == 'Yes') {
    theLeaderBoard(from);
  }
  else {
    notify('The room host has decided not to use the Leaderboard feature.',from);
  }
}

function notifierSpam() {
  cb.setTimeout(notifierSpamTimer,cb.settings.spamTimer*60000);
}

function notifierSpamTimer() {
  if(notifierSpamTGL == 1) {
    notify(notifierMessage);
    notifierSpam();
  }
}

function nice(user,mod,ar) {
  if(ar == 'a') {
    if(!cbjs.arrayContains(niceArray,user)) {
      niceArrayPopulate(user);
      notify('You have added ' + user + ' to the nice list.', mod);
      notify(mod + ' has added you to the nice list.  You will be able to chat and use graphcs regardless of the global room settings.  Thank you for being nice!',user);
    }
    else {
      notifyError(user + ' is already on the nice list.', mod);
    }
  }
  else if(ar == 'r') {
    if(cbjs.arrayContains(niceArray,user)) {
      cbjs.arrayRemove(niceArray,user);
      notify('You have removed ' + user + ' from the nice list.', mod);
      notify(mod + ' has removed you from the nice list.', user);
    }
    else {
      notifyError(user + ' is not on the nice list.', mod);
    }
  }
}

function grey(user,mod,ar) {
  if(ar == 'a') {
    if(!cbjs.arrayContains(greyArray,user)) {
      greyArrayPopulate(user);
      notify('You have added ' + user + ' to the grey list.', mod);
    }
    else {
      notifyError(user + ' is already on the grey list.', mod);
    }
  }
  else if(ar == 'r') {
    if(cbjs.arrayContains(greyArray,user)) {
      cbjs.arrayRemove(greyArray,user);
      notify('You have removed ' + user + ' from the grey list.', mod);
    }
    else {
      notifyError(user + ' is not on the grey list.', mod);
    }
  }
}

function kingSpamToggle(option, mod) {
  if(option == 'on') {
    if(kingTipperSpam == 1) {
      notifyError('The King Tipper spam is already turned on.',mod);
    }
    else {
      kingTipperSpam = 1;
      notify('You have turned on King Tipper spam.',mod);
    }
  }
  else if(option == 'off') {
    if(kingTipperSpam == 0) {
      notifyError('The King Tipper spam is already turned off.',mod);
    }
    else {
      kingTipperSpam = 0;
      notify('You have turned off the King Tipper spam.',mod);
    }
  }
  else if(option != null) {
    notifyError(option + ' is not a valid option for /kingspam.\nType /bombhelp\xa0kingspam to see how to use /kingspam.',mod);
  }
  else if(option == null) {
    notifyError('You did not enter a valid option for /kingspam.\nType /bombhelp\xa0kingspam to see how to use /kingspam.',mod);
  }
}

function notifierSpamToggle(option, mod) {
  if(option == 'on') {
    if(notifierSpamTGL == 1) {
      notifyError('The Notifier spam is already turned on.',mod);
    }
    else {
      notifierSpamTGL = 1;
      notify('You have turned on the Notifier spam.',mod);
    }
  }
  else if(option == 'off') {
    if(notifierSpamTGL == 0) {
      notifyError('The Notifier spam is already turned off.',mod);
    }
    else {
      notifierSpamTGL = 0;
      notify('You have turned off the Notifier spam.',mod);
    }
  }
  else if(option != null) {
    notifyError(option + ' is not a valid option for /notifierspam.\nType /bombhelp\xa0notifierspam to see how to use /notifierspam.',mod);
  }
  else if(option == null) {
    notifyError('You did not enter a valid option for /notifierspam.\nType /bombhelp\xa0notifierspam to see how to use /notifierspam.',mod);
  }
}

function leaderboardSpamToggle(option, mod) {
  if(option == 'on') {
    if(leaderboardSpam == 1) {
      notifyError('The Leaderboard spam is already turned on.',mod);
    }
    else {
      leaderboardSpam = 1;
      notify('You have turned on the Leaderboard spam.',mod);
    }
  }
  else if(option == 'off') {
    if(leaderboardSpam == 0) {
      notifyError('The Leaderboard spam is already turned off.',mod);
    }
    else {
      leaderboardSpam = 0;
      notify('You have turned off the Leaderboard spam.',mod);
    }
  }
  else if(option != null) {
    notifyError(option + ' is not a valid option for /leaderboardspam.\nType /bombhelp\xa0leaderboardspam to see how to use /leaderboardspam.',mod);
  }
  else if(option == null) {
    notifyError('You did not enter a valid option for /leaderboardspam.\nType /bombhelp\xa0leaderboardspam to see how to use /leaderboardspam.',mod);
  }
}

function isBlank(cbsetting) {
  var s;
  if(cbsetting) {
    s = cbsetting.trim();
  }
  if(s == null || s == '' || s.substr(0,9) == '[Optional') {
    return true;
  }
  else {
    return false;
  }
}

function isValidColor(color) {
  var colorString = '0123456789abcdefABCDEF';
  var valid = true;
  if (color.charAt(0) == '#') {
    color = color.substr(1);
  }
  if (color && color.length == 6) {
    for(var i = 0; i < 6; i++) {
      if(colorString.indexOf(color.charAt(i)) == -1) {
        valid = false;
      } else {
      }
    }
  }
  else {
    valid = false;
  }
  if(valid) {
    return true;
  }
  else {
    notifyError(
      color + ' is not a valid color option.  Hex color codes use numbers and letters only.\n' +
      'Use www.color-hex.com to find the code for the color you want.\nDo not include the #.\n' +
      'Reverting to default color.',
      roomHost);
    return false;
  }
}

function setColor() {
  var c = cb.settings.colorscheme;
  var t = cb.settings.textcolor;
  var b = cb.settings.bgcolor;
  if (t && t.trim().charAt(0) != '#') { t = '#' + t.trim(); }
  if (b && b.trim().charAt(0) != '#') { b = '#' + b.trim(); }
  if (c && c.substr(0,6) == 'Custom') {
    if(isBlank(b) && isBlank(t)) {
      notifyError('Whoops. You selected a custom color scheme but you didn\'t fill in the colors. Reverted to default color scheme.', roomHost);
    }
    else if (isBlank(t)) {
      notifyError('Whoops. You selected a custom color scheme but you didn\'t select a text color. Reverted to default color scheme.', roomHost);
    }
    else if (isBlank(b) && !isBlank(t)) {
      if (isValidColor(t)) {
        primarytext = t;
        primarybg = white;
      }
    }
    else if (!isBlank(b) && !isBlank(t) ) {
      if (isValidColor(t) && isValidColor(b)) {
        primarytext = t;
        primarybg = b;
      }
    }
  }
  else if (c == 'Purple') {
    primarytext = purple;
    primarybg = purplebg;
  }
  else if (c == 'Pink') {
    primarytext = pink;
    primarybg = pinkbg; // Not working for some reason
  }
  else if (c == 'Orange') {
    primarytext = orange;
    primarybg = orangebg;
  }
  else if (c == 'Red') {
    primarytext = red;
    primarybg = redbg;
  }
  else if (c == 'Green') {
    primarytext = green;
    primarybg = greenbg;
  }
  else if (c == 'Blue') {
    primarytext = blue;
    primarybg = bluebg;
  }
  else if (c == 'Grey') {
    primarytext = grey;
    primarybg = greybg;
  }
}

function help(option,from) {
  var valid = 0;
  if(option == null){
    option = '';
  }
  switch(option) {
    case '': {
      valid = 1;
      notifyBold('Bomb Bot Ultra Help Menu',from);
      notify(
          'Type /bombhelp\xa0x, where x is one of the following choices, for more detailed information.' +
          '\nEx: /bombhelp\xa0commands'
        ,from);
      notifyPlain(
          'commands\n' +
          'nicelist\n' +
          'greylist\n' +
          'about'
        ,from);
      break;
    }
    case 'commands': {
      valid = 1;
      notifyBold('Bomb Bot Ultra Command List',from);
      notify(
          'Type /bombhelp\xa0x, where x is one of the following commands, for more detailed information.' +
          '\nEx: /bombhelp\xa0silencelevel'
        ,from);
      notifyPlain(
          '/silencelevel\n' +
          '/graphiclevel\n' +
          '/silence\n' +
          '/unsilence\n' +
          '/starttimer\n' +
          '/addtime\n' +
          '/timeleft\n' +
          '/note\n' +
          '/whisper\n' +
          '/reply\n' +
          '/ignore\n' +
          '/unignore\n' +
          '/ignorelevel\n' +
          '/emod\n' +
          '/addnice\n' +
          '/removenice\n' +
          '/addgrey\n' +
          '/removegrey\n' +
          '/leaderboard\n' +
          '/kingspam\n' +
          '/notifierspam'
        ,from);
      break;
    }
    case 'nicelist': {
      notifyBold('The Nice List',from);
      notify('Sometimes, there are users whose comments are desirable, but they either do not have tokens or do not tip frequently.  ' +
            'When rooms get rowdy, hosts and mods are forced to do things like silence users without tokens or who have not tipped and those groups often includes the users whose comments hosts would like to see.  ' +
            'To fix this problem, hosts and mods can add users to the Nice List.  ' +
            'Users who are on the nice list can send messages regardless of the global silence setting.',from);
      valid = 1;
      break;
    }
    case 'greylist': {
      valid = 1;
      notifyBold('The "Grey" List',from);
      notify('Sometimes, there are users whose comments are annoying, in spite of the fact that they may have tokens or even tip.  ' +
            'It isn\'t always desireable to silence these people entirely, especially if they\'ve been tipping, but it can be useful to apply the same word list restrictions that apply to greys, so that the more annoying messages don\'t get through to the room.  ' +
            'To fix this problem, hosts and mods can add users to the "Grey" List.  ' +
            'Users who are on the grey list will have their messages subjected to the wordlists that apply to greys.',from);
      notify('',from);
      break;
    }
    case 'about': {
      valid = 1;
      notifyBold('About Bomb Bot Ultra',from);
      notify('Bomb Bot Ultra is a fork of Ultra Bot, with continuing development by Adambomb01.' +
          '\nUltra Bot was written by Justin of the Chaturbate couple britney_and_justin.' +
          '\nComments, suggestions, requests, and bug reports can be communicated by either tweeting @adambomb01, ' +
          'or by posting comments on Bomb Bot Ultra\'s page at chaturbate.com/bots.' +
          '\nThe purpose of Bomb Bot Ultra is to make the lives of hosts and mods as easy as possible. ' +
          'It adds popular features such as King Tipper, Leaderboard, and Notifier, pre-silences abusive messages, ' +
          'grants quite a bit of power to moderators, and allows private messages to be sent in the main chat window.',from);
      notify('',from);
      break;
    }
    case 'silencelevel': {
      valid = 1;
      notifyBold('/silencelevel Help',from);
      notify('/silencelevel is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using silencelevel is "/silencelevel\xa0x", where x is a number between 0 and 3.' +
          '\nSetting the Silence Level to 0 will grant voice privileges to all users, ' +
          'setting it to 1 will revoke voice privileges from users without tokens, ' +
          'setting it to 2 will revoke voice privileges from users who have not tipped, ' +
          'and setting it to 3 will revoke voice privileges from users who have not tipped at least 10 tokens.' +
          '\nThe default setting for /silencelevel is 0.' +
          '\nRoom hosts, moderators, and fan club members are unaffected by the Silence Level.',from);
      notify('',from);
      break;
    }
    case 'graphiclevel': {
      valid = 1;
      notifyBold('/graphiclevel Help',from);
      notify('/graphiclevel is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using graphiclevel is "/graphiclevel\xa0x", where x is a number between 0 and 3.' +
          '\nSetting the Graphic Level to 0 will grant graphic usage privileges to all users, ' +
          'setting it to 1 will revoke graphic usage privileges from users without tokens, ' +
          'setting it to 2 will revoke graphic usage privileges from users who have not tipped, ' +
          'and setting it to 3 will revoke graphic usage privileges from users who have not tipped at least 10 tokens.' +
          '\nThe default setting for /graphiclevel is 0.' +
          '\nRoom hosts, moderators, and fan club members are unaffected by the Graphic Level.',from);
      notify('',from);
      break;
    }
    case 'silence': {
      valid = 1;
      notifyBold('/silence Help',from);
      notify('/silence is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using silence is "/silence x", where x is the username of the user you want to silence.' +
          '\nThe effect of /silence is the same as Chaturbate\'s silence feature, ' +
          'except that it lasts for the duration of the current session instead of for six hours.' +
          '\nThe effect of /silence can be reversed by using the command /unsilence.',from);
      notify('',from);
      break;
    }
    case 'unsilence': {
      valid = 1;
      notifyBold('/unsilence Help',from);
      notify('/unsilence is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using unsilence is "/unsilence x", where x is the username of the user you want to unsilence.' +
          '\nunsilence simply grants voice privileges back to a user who was previously silenced.' +
          '\nNOTE: /unsilence WILL NOT undo the effect of Chaturbate\'s silence feature!' +
          '\n/unsilence WILL ONLY reverse the effect of /silence!',from);
      notify('',from);
      break;
    }
    case 'starttimer': {
      valid = 1;
      notifyBold('/starttimer Help',from);
      notify('/starttimer is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using starttimer is "/starttimer x", where x is the desired duration of the timer in minutes.' +
          '\n/starttimer will accept whole numbers only.' +
          '\nThe timer will make announcements at five minutes remaining and at one minute remaining.' +
          '\n/addtime can be used to add time to a currently running timer.' +
          '\n/timeleft can be used to display the amount of time remaining on the timer.',from);
      notify('',from);
      break;
    }
    case 'addtime': {
      valid = 1;
      notifyBold('/addtime Help',from);
      notify('/addtime is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using addtime is "/addtime\xa0x", where x is the amount of time you want to add in minutes.' +
          '\n/addtime will accept whole numbers only.' +
          '\nSee the help section for starttimer for more information on timers.',from);
      notify('',from);
      break;
    }
    case 'timeleft': {
      valid = 1;
      notifyBold('/timeleft Help',from);
      notify('/timeleft is a command that is usable by everyone.' +
          '\nThe syntax for using timeleft is /timeleft' +
          '\n/timeleft will display the amount of time left on the timer in the format 00:00:00' +
          '\nSee the help section for starttimer for more information on timers.',from);
      notify('',from);
      break;
    }
    case 'note': {
      valid = 1;
      notifyBold('/note Help',from);
      notify('/note is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using note is "/note\xa0x", where x is the message you want to send.' +
          '\n/note, /notice, and /n are all available commands that will send a notice.' +
          '\nA note is a public notification that will be sent to everyone in the main chat window.',from);
      notify('',from);
      break;
    }
    case 'whisper': {
      valid = 1;
      notifyBold('/whisper Help',from);
      notify('/whisper is a command that is usable by everyone.' +
          '\nThe syntax for using whisper is "/whisper\xa0x\xa0y", where x is the username of the user you want to send a whisper and y is the message you want to send.' +
          '\n/whisper, /w, /tell, /t, and /pm are all available commands that will send a whisper.' +
          '\nA whisper is a private message that will be sent in the main chat window.' +
          '\nOther related commands are /reply, /ignore, /unignore, and /ignorelevel.',from);
      notify('',from);
      break;
    }
    case 'reply': {
      valid = 1;
      notifyBold('/reply Help',from);
      notify('/reply is a command that is usable by everyone.' +
          '\nThe syntax for using whisper is "/reply\xa0x", where x is message that you want to whisper to the user who most recently sent a whisper to you.' +
          '\n/reply and /r are available commands that will send a whisper in reply.' +
          '\nSee the help section for whisper for more information on whispers.' +
          '\nOther related commands are /whisper, /ignore, /unignore, and /ignorelevel.',from);
      notify('',from);
      break;
    }
    case 'ignore': {
      valid = 1;
      notifyBold('/ignore Help',from);
      notify('/ignore is a command that is usable by everyone.' +
          '\nThe syntax for using ignore is "/ignore\xa0x", where x is the user from whom you wish to ignore whispers.' +
          '\nIgnoring a user will prevent him from sending you whispers, but it will not prevent him from talking normally in chat.' +
          '\n/unignore will reverse the effect of /ignore.' +
          '\nSee the help section for whisper for more information on whispers.' +
          '\nOther related commands are /whisper, /reply, /unignore, and /ignorelevel.',from);
      notify('',from);
      break;
    }
    case 'unignore': {
      valid = 1;
      notifyBold('/unignore Help',from);
      notify('/unignore is a command that is usable by everyone.' +
          '\nThe syntax for using unignore is "/unignore\xa0x", where x is the user you wish to remove from your ignore list.' +
          '\nSee the help section for ignore for more information on ignoring users.' +
          '\nSee the help section for whisper for more information on whispers.' +
          '\nOther related commands are /whisper, /reply, /ignore, and /ignorelevel.',from);
      notify('',from);
      break;
    }
    case 'ignorelevel': {
      valid = 1;
      notifyBold('/ignorelevel Help',from);
      notify('/ignorelevel is a command that determines which users you accept whispers from. It is usable by everyone.' +
          '\nThe syntax for using ignorelevel is "/ignorelevel\xa0x", where x is a number between 0 and 4.' +
          '\nSetting it to 0 will allow all users to send you whispers.' +
          '\nSetting it to 1 will only allow users with tokens to send you whispers.' +
          '\nSetting it to 2 will only allow users who have tipped to send you whispers.' +
          '\nSetting it to 3 will only allow users who have tipped at least 10 tokens to send you whispers.' +
          '\nSetting it to 4 will allow no one to send you whispers.' +
          '\nModerators and fan club members can send whispers regardless of whisper level.' +
          '\nThe default setting for /ignorelevel is 4 for the broadcaster, and 0 for everyone else. (This broadcaster\'s level is set higher by default to prevent abuse of this feature.)' +
          '\nSee the help section for whisper for more information on whispers' +
          '\nOther related commands are /whisper, /reply, /ignore, and /unignore.',from);
      notify('',from);
      break;
    }
    case 'emod': {
      valid = 1;
      notifyBold('/emod Help',from);
      notify('/emod is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using emod is "/emod\xa0x\xa0y", where x is either "add" or "remove" and y is the username of the user you want to either grant or revoke emergency moderator powers.' +
          '\n/emod allows moderators to quickly grant other users access to moderator-only commands in the event that he is having difficulty controlling the room by himself.' +
          '\nEmergency moderators have access to all moderator-only commands with the exceptions of /emod, /addnice, and /removenice.',from);
      notify('',from);
      break;
    }
    case 'blocknotice': {
      valid = 1;
      notifyBold('/blocknotice Help',from);
      notify('/blocknotice is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using blocknotice is "/blocknotice\xa0x", where x is either "on" or "off".' +
          '\n/blocknotice toggles the blocked message notices that appear by default for moderators when the wordlist is being used' +
          '\nThe blocked message notifications are toggled on a per-user basis. (Toggling it for yourself does not toggle it for everyone.)',from);
      notify('',from);
      break;
    }
    case 'addnice': {
      valid = 1;
      notifyBold('/addnice Help',from);
      notify('/addnice is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using addnice is "/addnice x", where x is the username of the user you want to add to the nice list.' +
          '\nAdding a user to the nice list guarantees that user voice and graphic usage privileges regardless of the silence, graphic, and ignore level settings.  ' +
          'Using /silence or /ignore will still silence or ignore a user on the nice list.' +
          '\nUsers can be removed from the nice list by using the command /removenice.' +
          '\nSee the help sections for silencelevel, graphiclevel, and ignorelevel for more information on the global settings or the help section for nicelist for more information on the nice list.',from);
      notify('',from);
      break;
    }
    case 'removenice': {
      valid = 1;
      notifyBold('/removenice Help',from);
      notify('/removenice is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using removenice is "/removenice x", where x is the username of the user you want to remove from the nice list.' +
          '\nSee the help section for nicelist for more information on the nice list.',from);
      notify('',from);
      break;
    }
    case 'addgrey':
    case 'addgray': {
      valid = 1;
      notifyBold('/addgrey Help',from);
      notify('/addgrey is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using addgrey is "/addgrey x", where x is the username of the user you want to add to the grey list.' +
          '\nAdding a user to the grey list subjects them to the same wordlists that apply to greys.  ' +
          '\nUsers can be removed from the grey list by using the command /removegrey.' +
          '\nSee the help section for greylist for more information on the grey list.',from);
      notify('',from);
      break;
    }
    case 'removegrey':
    case 'removegray': {
      valid = 1;
      notifyBold('/removegrey Help',from);
      notify('/removegrey is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using removegrey is "/removegrey x", where x is the username of the user you want to remove from the grey list.' +
          '\nSee the help section for greylist for more information on the grey list.',from);
      notify('',from);
      break;
    }
    case 'bombhelp':
    case 'ubhelp': {
      valid = 1;
      notifyBold('/bombhelp\xa0Help',from);
      notify('/bombhelp\xa0is a command that is usable by everyone.' +
          '\nThe syntax for using bombhelp is "/bombhelp\xa0x", where x is the subsection of the help menu that you want to access.',from);
      notify('',from);
      break;
    }
    case 'leaderboard': {
      valid = 1;
      notifyBold('/leaderboard Help',from);
      notify('/leaderboard is a command that is usable by everyone.' +
          '\nThe syntax for using leaderboard is "/leaderboard".' +
          '\n/leaderboard shows the top 3 tippers of the current session.',from);
      notify('',from);
      break;
    }
    case 'kingspam': {
      valid = 1;
      notifyBold('/kingspam Help',from);
      notify('/kingspam is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using kingspam is /kingspam x, where x is either on or off.  ' +
          'Using this command toggles the spamming of the message "Tip x to become the new King!"',from);
      notify('',from);
      break;
    }
    case 'notifierspam': {
      valid = 1;
      notifyBold('/notifierspam Help',from);
      notify('/notifierspam is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using notifierspam is /notifierspam x, where x is either on or off.  ' +
          'Using this command toggles the spamming of the periodic message defined by the host.',from);
      notify('',from);
      break;
    }
    case 'leaderboardspam': {
      valid = 1;
      notifyBold('/leaderboardspam Help',from);
      notify('/leaderboardspam is a command that is usable by moderators and room hosts.' +
          '\nThe syntax for using leaderboardspam is /leaderboardspam x, where x is either on or off.  ' +
          'Using this command toggles the spamming of the top three tippers.',from);
      notify('',from);
      break;
    }
  }
  if(valid == 0) {
    notifyError(option + ' is not a valid subsection of the help menu.  Type /bombhelp\xa0to access the main help menu.',from);
  }
}









































/************************************************************************************************************************************
***** onMessage *********************************************************************************************************************
************************************************************************************************************************************/

cb.onMessage(function (msg) {

  var cmd = 0; //0 = invalid command, 1 = valid command
  var silenced = 0; //1 = user is already silenced
  var messageBlocked = 0; // used to determine whether a message gets blocked based on wordlist
  var graphicsBlocked = 0; // used to determine whether a user can use graphics
  var symbolString = '~`!@#$%^&*()_-+={[}]|\\:;"\'<,>.?/';

  // Message vars
  var message = msg['m'].trim().split(/\s+/g); //turn the message into an array
  var isCommand = (message[0].charAt(0) == '/');

  // User vars
  var u = msg.user;
  var hasTipped = Number.parseInt(tipperArray[findTipper(u)][1]) > 0;
  var hasTippedTen = Number.parseInt(tipperArray[findTipper(u)][1]) > 10;
  var hasTokens = msg.has_tokens;
  var isHost = (u == cb.room_slug);
  var isMod = msg.is_mod;
  var isFan = msg.in_fanclub;
  var isEmod = cbjs.arrayContains(eModArray, u);
  var isNice = cbjs.arrayContains(niceArray, u);
  var isMean = cbjs.arrayContains(greyArray, u);
  var isSilenced = cbjs.arrayContains(silenceArray, u);
  var isGrey = (!hasTokens && !hasTipped);


  // grey wordlist
  if(cb.settings.wordlistToggle == 'Yes') {

    // Remove everything but alphanumeric characters to evaluate it
    var msgStringOrig = msg['m'];
    var msgString = msgStringOrig.replace(/[^\w\s]|_/gi, '');
    var msgStringPartial = msgString.replace(/[\s]/gi, '');

    // Reusable RegEx
    var girlyparts = 'p+u+s\\w*|v+a+(g|j)\\w*|k+i+t+t\\w*|c+l+i+t\\w*|l+i+p\\w*|b+o+b\\w*|n+i+p\\w*|t+i+t\\w*|(\\b)a+s+s|b+u+t+t|(\\b)[^w]*h+o+l+e\\w*|c+u+n+t\\w*|a+r+m+p+i+t\\w*';
    var guyparts = 'd+i+c+k\\w*|b+o+n+e+r\\w*|c+o+c+k\\w*|p+e+n+i+s\\w*';
    var naked = 'n+a*k+e*d+|n+u+d+e';

    // Short messages can't contain...
    var shortmessage = new RegExp('\\b(' + girlyparts + '|' + guyparts + '|' + naked + ')\\b');

    // Workaround (Block anything people try to space out to get around rules)
    var workaround = new RegExp('\\b\\w\\s\\w\\s\\w\\b', 'i'); // this matches 3 or more single spaced-out characters

    // Rude
    var rudeexact = new RegExp('\\b(h+o+e+s*)\\b', 'i');
    var rudepartial = new RegExp('(c+u+n+t|s+l+u+t|w+h+o+r+e|b+i+t+c+h|n+i+g+g+e+r|t+r+a+n+n+(y|i))', 'i');

    // Sticky/Annoying
    var annoyingexact = new RegExp('\\b(m+m+|u+f+)\\b', 'i');
    // var annoyingpartial = new RegExp('m+m+m', 'i');

    // Spam
    // var spamexact = new RegExp('\\b(  )\\b', 'i');
    var spampartial = new RegExp('(s+k+(y|i)+p+e|s+k+y+p|f+r+e+e.*t+o+k+e+n|t+o+k+e+n.*f+r+e+e|erotimo|freecambook|webcam23)', 'i');

    // Demands/Requests
    var demandsexact = new RegExp('\\b(p+\\s*m+|p+l+(s|z)+|m+a+s+t\\w*b\\w*|s+q\\w*r+t\\w*|a+n+a+l+|f+i+s+t\\w*|(w+a+n\\w*|e+a+t|s+h+o+w|d+o(\\b)|f+l+a+s+h|c+a+n+\\s(i+|.*u+)|o+p+e+n|c+l+o+s+e|c+u+m|s+h+a+k|s+p+a+n+k|s+q+u*e*z|s+h+o+v+e|p+l+a+y.*w+i+t+h|f+i+n+g+e+r|(f|s)+u+c+k|l+i+c+k|k+i+s+s|l+e+t\\w*\\s*s+e+e).*((\\b)i+t+|u+r|' + girlyparts + '|(\\b)c+u+m\\w*))\\b', 'i');
    var demandspartial = new RegExp('(a+r+m+p+i+t|a+s+s+h+o+l+e|z+o+o+m|s+p+r+e+a+d|f+a+r+t|c+2+c|(w+a+t+c+h|l+o+o+k|o+p+e+n|v+i+e+w).*c+a+m)', 'i');

    // BB
    var bbexact = new RegExp('\\b(b+(a|e)*b+(y|e)*|b+a+e)\\b', 'i');
    // var bbpartial = new RegExp('', 'i');

    // TMI
    var tmiexact = new RegExp('\\b((i+.{0,1}m|i\\s|m+(y|e)+|s+o+|i+s+|a+m+|l+e+t+(\\s)m+e+|l+e+m+m+e+|(l+o+v+e+|l+u+v+)\\s(2+|t+o+)|g+o+t+\\w*|w+a+n\\w*|m+a+y+|c+a+n+|g+o+n\\w*|g+o+i+n\\w*\\st+o+).*(h+a*r+d+\\w*|m+a+s+t\\w*b+a+t\\w*|w+a+n+k\\w*|j+e+r+k\\w*|(j+|w+h*)a+c+k\\w*|w+et+|h+o+r+n\\w*|t+a+s+t\\w*|c+u+m+\\w*|l+i+c+k\\w*|(f|s)+u+c+k\\w*)|\\w*m+e+a+t|bbc)\\b', 'i');
    var tmipartial = new RegExp('(' + guyparts + '|s+m+e+l+l|s+n+i+f+f|s+t+r+o+k|t+h+r+o+b|w+o+u+l+d.*u+c+k|\\d\\s*(i+n|c+m))', 'i');

    // Feet
    var feetexact = new RegExp('\\b(s+o+l+e+s*|t+o+e+s*)\\b', 'i');
    var feetpartial = new RegExp('(f+e+e+t|p+e+d+i+c+u|f+o+t+j+o+b)', 'i');

    // Poo/Pee
    var poopeeexact = new RegExp('\\b(p+o+o+p*\\w*|p+e+e+)\\b', 'i');
    var poopeepartial = new RegExp('(t+u+r+d)', 'i');

    // Wordlist does not apply to the host, mods, emods, fans, or nicelist
    if(!(isHost || isMod || isEmod || isFan || isNice)) {
      // if the user is grey and has not tipped OR if the user has been added to the "grey list"
      if (isGrey || isMean) {

        if (
          (msgString.length <= 1) || // no 1-letter messages
          (!message[3] && msgString.search(shortmessage) != -1) || // please form an intelligent sentence
          (msgString.search(workaround) != -1) ||
          (msgString.search(rudeexact) != -1) ||
          (msgStringPartial.search(rudepartial) != -1) ||
          (msgString.search(annoyingexact) != -1) ||
          // (msgStringPartial.search(annoyingpartial) != -1) ||
          // (msgString.search(spamexact) != -1) ||
          (msgStringPartial.search(spampartial) != -1) ||
          (msgString.search(demandsexact) != -1) ||
          (msgStringPartial.search(demandspartial) != -1) ||
          (msgString.search(bbexact) != -1) ||
          // (msgStringPartial.search(bbpartial) != -1) ||
          (msgString.search(tmiexact) != -1) ||
          (msgStringPartial.search(tmipartial) != -1) ||
          (msgString.search(feetexact) != -1) ||
          (msgStringPartial.search(feetpartial) != -1) ||
          (msgString.search(poopeeexact) != -1) ||
          (msgStringPartial.search(poopeepartial) != -1) ||
          (msgString.length > 500)
        ) {

          msg['X-Spam'] = true;
          messageBlocked = 1;

          if((!isCommand && !isSilenced) && (!hasTokens && silenceLevel == 0)) {

            // //replace images -- we may not want to see the images they unsuccessfully try to use
            var blockedmsg = msg['m'].replace(/:[^\s]+/g, function (match) { 
                return '[IMG: ' + match.slice(1) + ']';
            });

            for (mod = 0; mod < modArray.length; mod++) {
              thisMod = modArray[mod];

              if(cbjs.arrayContains(blockMsgArray,thisMod)) {
                notifyBold("\u2022 \u2022 \u2022 Bomb Bot Ultra - BLOCKED MESSAGE \u2022 \u2022 \u2022\xa0",thisMod,red,white);
                notify(msg['user']+": "+blockedmsg.substring(0, 500),thisMod,redbg,red);
              }
            }
          }

          if(cb.settings.wordlistNotice == 'Yes') {
            notifyError('Your message was not sent because it was flagged by the wordlist.  Be nice and don\'t make demands.',msg['user']);
          }
        }
      }
    }
  }

  // Silencing
  if(isSilenced && silenced == 0) {
    msg['X-Spam'] = true;
    silenced = 1;
    // notifyError('Your message was not sent because you have been silenced.  Be nice and don\'t make demands.',msg['user']);
  }

  // Silence Levels
  function doSilenceLevel(level, condition) {
    var silenceNotice = 'I\'m sorry, but the silence level has been set to ' + level + '; your message was not sent. ';
      silenceNotice += 'Only members who ' + condition + ' are currently permitted to talk in chat. \n'
      silenceNotice += 'Please enjoy the show :smile';
    msg['X-Spam'] = true;
    silenced = 1;
    notify(silenceNotice,u);
  }
  if(silenceLevel > 0 && !(isHost || isMod || isEmod || isFan || isNice) && silenced == 0) {
    switch(silenceLevel) {
      case 1:
        if(isGrey) {
          silenceCondition = 'have tokens';
          doSilenceLevel(silenceLevel, silenceCondition);
        }
        break;
      case 2:
        if(!hasTipped) {
          silenceCondition = 'have tipped';
          doSilenceLevel(silenceLevel, silenceCondition);
        }
        break;
      case 3:
        if(!hasTippedTen) {
          silenceCondition = 'have tipped at least 10 tokens';
          doSilenceLevel(silenceLevel, silenceCondition);
        }
        break;
    }
  }

  // Graphic Levels
  function doGraphicLevel(level) {
    var graphicNotice = 'Your message was not sent because you tried to use graphics.\nPlease enjoy the show :smile';
    for(var i = 0; i < message.length; i++) {
      if(message[i].charAt(0) == ':') {
        //replace images
        msg['m'] = msg['m'].replace(/:[^\s]+/g, function (match) { 
          return '[IMG: ' + match.slice(1) + ']';
        });
        msg['X-Spam'] = true;
        graphicsBlocked = 1;
        notify(graphicNotice,u);
      }
    }
  }
  if(graphicLevel > 0 && !(isHost || isMod || isEmod || isFan || isNice) && silenced == 0) {
    switch(graphicLevel) {
      case 1:
        if(isGrey || isMean) {
          doGraphicLevel(graphicLevel);
        }
        break;
      case 2:
        if(!hasTipped || isMean) {
          doGraphicLevel(graphicLevel);
        }
        break;
      case 3:
        if(!hasTippedTen || isMean) {
          doGraphicLevel(graphicLevel);
        }
        break;
    }
  }

  // Commands
  if(isCommand) {
    msg['X-Spam'] = true; //Don't send message to chat

    permissionNotice = 'Only moderators and broadcasters are able to use that command.\nType "/bombhelp\xa0commands" to see a full list of the available commands.';

    switch(message[0]) {
      case '/blocknotice': {
        cmd = 1;
        if(isHost || isMod) {
          blockNotice(message[1],u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/silencelevel': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          setSilenceLevel(message[1],u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/graphiclevel': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          setGraphicLevel(message[1],u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/silence': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          silence(message[1].toLowerCase(),u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/unsilence': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          unsilence(message[1].toLowerCase(),u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/starttimer': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          startTimer(message[1],u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/addtime': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          addTime(message[1],u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/timeleft': {
        cmd = 1;
        timeLeft(msg['user']);
        break;
      }
      case '/note':
      case '/notice':
      case '/n': {
        cmd = 1;
        if(isHost || isMod) {
          if (message[1]) {
            sendNote(message, u);
            msg['m'] = '\u2022 \u2022 \u2022 NOTICE SENT \u2022 \u2022 \u2022';
          }
          else {
            notify('Uh oh! You didn\'t write a note',u);
          }
          msg['background'] = primarybg;
          msg['c'] = primarytext;
        }
        else {
          notify(permissionNotice,u);
        }
        break;
      }
      case '/whisper':
      case '/w':
      case '/tell':
      case '/t':
      case '/pm': {
        cmd = 1;
        if(isHost || isMod || isEmod || isFan || isNice) {
          sendWhisper(message,u,true,msg['has_tokens']);
          msg['m'] = textReplaceWhisper(message,u);
        }
        else if (messageBlocked == 0 && graphicsBlocked == 0) {
          sendWhisper(message,u,false,msg['has_tokens']);
          msg['m'] = textReplaceWhisper(message,u);
        } else {
          msg['m'] = 'Whisper not sent.';
        }
        msg['background'] = primarybg;
        msg['c'] = primarytext;
        break;
      }
      case '/reply':
      case '/r': {
        cmd = 1;
        if (messageBlocked == 0 && graphicsBlocked == 0) {
          sendReply(message,u);
          msg['m'] = textReplaceWhisper(message,u,true);
        }
        else {
          msg['m'] = 'Reply not sent.';
        }
        msg['background'] = primarybg;
        msg['c'] = primarytext;
        break;
      }
      case '/ignorelevel': {
        cmd = 1;
        setIgnoreLevel(message[1],u);
        break;
      }
      case '/ignore': {
        cmd = 1;
        ignoreUser(message[1],u);
        break;
      }
      case '/unignore': {
        cmd = 1;
        unignoreUser(message[1],u);
        break;
      }
      case '/emod': {
        cmd = 1;
        if(isHost || isMod) {
          eMod(message[1],message[2].toLowerCase(),u);
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/addnice': {
        cmd = 1;
        if(isHost || isMod) {
          nice(message[1].toLowerCase(),u,'a');
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/removenice': {
        cmd = 1;
        if(isHost || isMod) {
          nice(message[1].toLowerCase(),u,'r');
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/addgrey': {
        cmd = 1;
        if(isHost || isMod) {
          grey(message[1].toLowerCase(),u,'a');
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/removegrey': {
        cmd = 1;
        if(isHost || isMod) {
          grey(message[1].toLowerCase(),u,'r');
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/bombhelp':
      case '/ubhelp': {
        cmd = 1;
        help(message[1],u);
        break;
      }
      case '/leaderboard': {
        cmd = 1;
        showLeaderBoard(u);
        break;
      }
      case '/kingspam': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          kingSpamToggle(message[1],u)
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/notifierspam': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          notifierSpamToggle(message[1],u)
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/leaderboardspam': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          leaderboardSpamToggle(message[1],u)
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
      case '/notifiermessage': {
        cmd = 1;
        if(isHost || isMod || isEmod) {
          if(message[1] == '' || message[1] == null) {
            notifyError('You must enter a new message for the notifier feature.  If you want to disable the notifications, enter /notifierspam off.',u);
          }
          else {
            notifierMessage = msg['m'].substring(16).trim();
            notify('You have set the notifier spam message to: ' + notifierMessage,u);
          }
        }
        else {
          notifyError(permissionNotice,u);
        }
        break;
      }
    }

    var x = message[0];

    //Make sure it doesn't call errors for common commands used by other apps/bots
    if(
      x == '/b' ||
      x == '/p' ||
      x == '/rewards' ||
      x == '/prizes' ||
      x == '/winners' ||
      x == '/startshow' ||
      x == '/showtimeleft' ||
      x == '/printtime' ||
      x == '/addshowtime' ||
      x == '/adduser' ||
      x == '/changegoal' ||
      x == '/hide' ||
      x == '/unhide' ||
      x == '/selltickets' ||
      x == '/uacommands' ||
      x == '/luhelp' ||
      x == '/levels') {
        cmd = 1;
    }
    //Otherwise, it means the user entered an invalid command
    if(cmd == 0 && cb.settings.invalidToggle == 'Yes') {
      notifyError(message[0] + ' is not a command.\nType /bombhelp\xa0commands to see a full list of the available commands.',msg['user']);
    }
  }

  //stop people from sending messages in all caps
  if (cb.settings.capsToggle == 'Yes' || (cb.settings.capsToggle == 'Only for greys' && (isGrey || isMean))) {
    if(!(isHost || isMod || isEmod)) {
      if(msg['m'] == msg['m'].toUpperCase() && msg['m'].toUpperCase() != msg['m'].toLowerCase()) {
        for(var i = 0; i < msg['m'].length; i++) {
          if(symbolString.indexOf(msg['m'].charAt(i)) == -1) {
            msg['m'] = msg['m'].replace(/[^\s]+/g, function (match) {
              return match.indexOf(':') === 0 ? match : match.toLowerCase();
            });
            // notifyError('I\'m sure you didn\'t actually mean to send that message in all capital letters, so I fixed it for you :smile',msg['user']);
          }
        }
      }
    }
  }

  //convert sticky keys to max of 3 letters
  if (cb.settings.stickyToggle == 'Yes' || (cb.settings.stickyToggle == 'Only for greys' && (isGrey || isMean))) {
    if(!(isHost || isMod || isEmod)) {
      if(msg['m'].match(/(.)\1{3,}/ig)) {
        message = msg['m'].trim().split(/\s+/g); // make sure we're working with the current version of our message
        var m = '';
        for(var i = 0; i < message.length; i++) {
          if(i >= 0) {
            m += ' ';
          }
          if ((message[i].charAt(0) == ':')) {    
            m += message[i];      
          } else {
            m += message[i].replace(/(.)\1{3,}/ig, '$1$1$1');
          }
        }
        msg['m'] = m;
      }
    }
  }

  //tip titles, if turned on, as well as king's crown
  if(cb.settings.tipTitles == 'Yes' && hasTipped && !isCommand) {
    msg['m'] = setTipTitles(msg['user'],msg['m']);
  }

  return msg;

});










































/************************************************************************************************************************************
***** onTip *************************************************************************************************************************
************************************************************************************************************************************/

cb.onTip(function (tip) {

  var thisTip = parseInt(tip['amount']);
  var thisTipper = tip['from_user'];
  var thisTipperTotal = parseInt(tipperArray[findTipper(thisTipper)][1]);
  var numberOneTipper = leaderArray[0][0];
  var numberOneTip = parseInt(leaderArray[0][1]);
  var numberTwoTipper = leaderArray[1][0];
  var numberTwoTip = parseInt(leaderArray[1][1]);
  var numberThreeTipper = leaderArray[2][0];
  var numberThreeTip = parseInt(leaderArray[2][1]);

  thisTipperTotal += thisTip; // Add this tip to the user's total

  if(cb.settings.kingTipper == 'Yes') {
    if(thisTipper != currentKing && thisTipperTotal > kingTip && thisTipperTotal >= kingMin) {
      if(currentKing != '') {
        notify('You have been dethroned by ' + thisTipper + ', but revenge is sweet...', currentKing);
      }
      notify('We have a new King!\nAll hail ' + thisTipper + '!');
      currentKing = thisTipper;
      kingTip = thisTipperTotal;
    }
    else if(thisTipper == currentKing) {
      kingTip = thisTipperTotal;
    }
  }
  if(cb.settings.leaderBoard == 'Yes') {
    //create an array of the names
    var nameArray = new Array;
    for(var i = 0; i < leaderArray.length; i++) {
      nameArray[i] = leaderArray[i][0];
    }

    //the user is not currently in the top 3
    if(!cbjs.arrayContains(nameArray,thisTipper)) {
      if(thisTipperTotal > numberOneTip) {
        numberThreeTipper = numberTwoTipper;
        numberThreeTip = numberTwoTip;

        numberTwoTipper = numberOneTipper;
        numberTwoTip = numberOneTip;

        numberOneTipper = thisTipper;
        numberOneTip = thisTipperTotal;
      }
      else if(thisTipperTotal < numberOneTip && thisTipperTotal > numberTwoTip || thisTipperTotal == numberOneTip) {
        numberThreeTipper = numberTwoTipper;
        numberThreeTip = numberTwoTip;

        numberTwoTipper = thisTipper;
        numberTwoTip = thisTipperTotal;
      }
      else if(thisTipperTotal < numberTwoTip && thisTipperTotal > numberThreeTip || thisTipperTotal == numberTwoTip) {
        numberThreeTipper = thisTipper;
        numberThreeTip = thisTipperTotal;
      }
    }

    //the user is currently in the top 3
    else {
      //the user is already #1
      if(numberOneTipper == thisTipper) {
        numberOneTip = thisTipperTotal;
      }
      //the user is #2 and is moving to #1
      if(numberTwoTipper == thisTipper && thisTipperTotal > numberOneTip) {
        numberTwoTipper = numberOneTipper;
        numberTwoTip = numberOneTip;

        numberOneTipper = thisTipper;
        numberOneTip = thisTipperTotal;
      }
      //the user is #2 and is not moving to #1
      else if(numberTwoTipper == thisTipper && thisTipperTotal <= numberOneTip) {
        numberTwoTip = thisTipperTotal;
      }
      //the user is #3 and is moving to #2
      else if(numberThreeTipper == thisTipper && thisTipperTotal > numberTwoTip) {
        numberThreeTipper = numberTwoTipper;
        numberThreeTip = numberTwoTip;

        numberTwoTipper = thisTipper;
        numberTwoTip = thisTipperTotal;
      }
      //the user is #3 and is moving to #1
      else if(numberThreeTipper == thisTipper && thisTipperTotal > numberOneTip) {
        numberThreeTipper = numberTwoTipper;
        numberThreeTip = numberTwoTip;

        numberTwoTipper = numberOneTipper;
        numberTwoTip = numberOneTip;

        numberOneTipper = thisTipper;
        numberOneTip = thisTipperTotal;
      }
      //the user is #3 and is not moving
      else if(numberThreeTipper == thisTipper && thisTipperTotal <= numberTwoTip) {
        numberThreeTip = thisTipperTotal;
      }
      if(numberThreeTipper == numberTwoTipper || numberThreeTipper == numberOneTipper) {
        numberThreeTipper = '';
        numberThreeTip = 0;
      }
      if(numberTwoTipper == numberOneTipper) {
        numberTwoTipper = '';
        numberTwoTip = 0;
      }
    }
  }
  if(cb.settings.notifierTip == 'Yes' && thisTip >= cb.settings.tipMessageMin) {
    notify(cb.settings.tipMessage,'',yellow,yellowtext);
  }
});










































/************************************************************************************************************************************
***** onEnter ***********************************************************************************************************************
************************************************************************************************************************************/

cb.onEnter(function(user) {
  if (!isBlank(cb.settings.enterMessage)) {
    notify(cb.settings.enterMessage,user['user']);
  }
  if(user['is_mod']) {
    if (!cbjs.arrayContains(modArray,user['user'])) {
      modArrayPopulate(user['user']);
      if(cb.settings.wordlistShowModerators == 'Yes') {
        blockMsgArrayPopulate(user['user']);
      }
    }
    //Send notice to moderators as they enter
    notifyBold('\u2022 \u2022 \u2022 Bomb Bot Ultra - MODERATOR NOTICE \u2022 \u2022 \u2022\xa0',user['user'],red,white);

      var modMessage = 'Welcome to ' + cb.room_slug + '\'s room. You are seeing this notice because you are a moderator.\n';
      modMessage += 'This bot automatically blocks certain messages that contain words and phrases that are deemed abusive, inappropriate, or annoying. ';
      modMessage += 'By default, the blocked messages are displayed to moderators ONLY in a red notice, so that they may take appropriate actions.\n';
      modMessage += 'To silence an abusive user using the bot, type: /silence\xa0[username]\n';
      if (cbjs.arrayContains(blockMsgArray,user['user'])) {
        modMessage += 'To stop seeing the blocked message notices, type: /blocknotice\xa0off.';
      } else {
        modMessage += 'Your blocked message notices are currently OFF. To see them again, type: /blocknotice\xa0on.';        
      }
    notify(modMessage,user['user'],redbg,red);
    notifyBold('\u2022 \u2022 \u2022 Bomb Bot Ultra - MODERATOR NOTICE \u2022 \u2022 \u2022\xa0',user['user'],red,white);
  }
});









































/************************************************************************************************************************************
***** Initialize ********************************************************************************************************************
************************************************************************************************************************************/

if(initialize == 0) {

  setColor();

  if(cb.settings.kingTipperSpam == 'Yes') {
    kingTipperSpam = 1;
    kingSpam();
  }
  if(cb.settings.leaderBoardSpam == 'Yes') {
    leaderboardSpam = 1;
    leaderSpam();
  }
  if(cb.settings.notifierSpam == 'Yes') {
    notifierSpamTGL = 1;
    notifierSpam();
  }
  if(cb.settings.wordlistShowBroadcaster == 'Yes') {
    blockMsgArrayPopulate(cb.room_slug)
  }
  if(cb.settings.niceList != '' && cb.settings.niceList != null) {
    var n = cb.settings.niceList;
    niceArray = n.split(',');
    numNice = niceArray.length;
  }
  if(cb.settings.greyList != '' && cb.settings.greyList != null) {
    var g = cb.settings.greyList;
    greyArray = g.split(',');
    numgrey = greyArray.length;
  }
  if(cb.settings.wordlistToggle == 'Yes') {

    //Send notice to moderators
    notifyBold('\u2022 \u2022 \u2022 Bomb Bot Ultra - MODERATOR NOTICE \u2022 \u2022 \u2022\xa0','onlyMods',red,white);

      var modMessage = cb.room_slug + ' has just started Bomb Bot Ultra. You are seeing this notice because you are a moderator.\n';
      modMessage += 'This bot automatically blocks certain messages that contain words and phrases that are deemed abusive, inappropriate, or annoying. ';
      modMessage += 'By default, the blocked messages are displayed to moderators ONLY in a red notice, so that they may take appropriate actions. ';
      modMessage += 'In order to see these messages, you will need to refresh.';

    notify(modMessage,'onlyMods',redbg,red);
    notifyBold('\u2022 \u2022 \u2022 PLEASE REFRESH THIS PAGE NOW \u2022 \u2022 \u2022\xa0','onlyMods',red,white);
  }

  ignoreArray[findIgnorer(cb.room_slug)][1] = 4; // setting whisper ignore level to 4 for broadcaster

  //Send notice to room host
  notify('Grey users are now unable to use graphics by default.  If you would like grey users to be able to use graphics, type /graphiclevel\xa00.', cb.room_slug);
  notify('You are currently ignoring whispers from everyone except your mods and fan club members. For more information on whisper ignore levels, type /bombhelp\xa0ignorelevel ', cb.room_slug);

  //Initialize
  initialize = 1;
}