Chaturbate

Bots Home | Create an App
Luckys Helper Bot - User Filter+
Author: lucky_larry
Description Source Code Launch Bot Current Users
There are 19 other versions of this script.
/* Lucky_Larry User-Filter-Chat bot 
   Development started 27Sep21
   Latest update 09Oct21
*/

var botVersion = 'Luckys User-Filter Bot Version R7.3';

//R8 User Object Implementation
//R7.3 Dump messages for individual user with rrr{username}  (no spaces)
//R7.2 Print Last Messagers functionality
//R7.1 Improvements in Session Info function
//R7 Implement the Asshole list for rude chatters that will replace their attempts to chat
  //with something silly or deameaning
//R6.3 Fixed bug allowing tokened females to escape being quarantined or silenced automatically
//R6.1 Options to ignore grey females
//R6 Implement quarantine feature for certain classes of users where their chat will only be
  //visible to Broadcaster and bot-admins until they are explicitly unsilenced
//R5 Implement User Object array to simplify other features by storing several data fields 
  //related to user such as a binary status field that could indicate they are in quarantine
  //or silenced.  R5 will also load this new data structure with current room viewers during
  //the onStart code and in the onEnter code it will first check if the user is already
  //in the data structure before adding them as a new entry
//R4-PUBLISHED-Implements user-count system and alerts Broadcaster if a new viewer is Female
  //and implements a quick way to silence their chat to anyone but the Broadcaster
//R3 adding Broadcaster Messages
//R2 adding code to get number of followers
//R1 Initial main purpose is to allow a broadcaster to specify a part of a username and 
  //then any username that contains that part will be unable to send messages into the chat.

//***************************************************************************************
//******************  SESSION VARIABLES *************************************************

//To hold broadcaster's name
var bname;
//To hold the time the session was launched
var startTime;
//Note if Debug mode is on or not
var debugMode = false;

//***************************************************************************************
//******************  BOT FUNCTION VARIABLES ********************************************

//How does the Broadcaster want to be referred to in notices?
var bNoticeName;

//Do we show blocked messages to Broadcaster & bot-Admins?
var showBlkdMsgs = true;

//Store how Broadcaster wants to handle grey females
doIgnoreGreyFemales = true;
doSilenceGreyFemales = true;
doQuarantineGreyFemales = true;

//Arrays that hold information on all users coming and going
const userArray = [];
const userSilencedArray = [];
const userQuarantineArray = [];
const userAssholesArray = [];
const userAssholesMsgRepCount = [];
const wasAdded = [false];

//Will be set by the bot-setup setting canFemaleUsersChat
//var doShowFemaleMessages = false;
var doAllowPublicFemaleMsgs = false;

//Note the username that last entered the chat
var lastEntered = '';

//Note the username that last sent a message
const lastMessagedUsers = [];

//Note username to Filter on for various purposes
var userNameToFilter = '';

//Hold the text that the Broadcaster specifies that should replace what they say
var assholeSubText = 'I have been rude in the chatroom or not following the rules '
      + 'so this the only message I can put in the chat now.';
//Hold name of last person that is in Asshole list and attempted to message.  This is used
  //for the calculation of the additional exclamation points kept in variable assholeIndex
  //to keep each of the same user's subsequent messages unique
var lastAsshole = '';
var assholeIndex = 0;

//For font weight of messages
var msgBCWeight = 'bolder';
var msgAllWeight = 'bolder';

//To hold Motivational Message current index and timeout values in milliseconds
var motvNextMessage = -1;
var motvMsgInterval = -1;
var motvMsgDefaultInterval = 660000; //11 Minutes by default
var motvMsgCount = -1;
var motvMsgArray;

//***************************************************************************************
//******************  myTrim ************************************************************
function myTrim(aStr) {
//Replacement for string trim method that uses a Regular-Expression
  return aStr.replace(/^\s+|\s+$/gm,'');
}

//***************************************************************************************
//******************  GET CURRENT TIME **************************************************
function getCurrentTime() {
  var d = new Date();
  return d;
}  //End getCurrentTime

//***************************************************************************************
//******************  SEND BROADCASTER MESSAGE ******************************************
function sendBroadcasterMsg(msgForBroadcaster,showTime = false,reqBy = 'BC',copyLarry = true) {
  let message = 'Admin Message:  ' + msgForBroadcaster;
  if (showTime == true) {
    
    //var currTime = new Date();
    
    message = getCurrentTime() + ' ' + message;
    //message = currTime.getTime() + ' ' + message;
  
  }
  if (reqBy == 'BC' || reqBy == bname) {cb.sendNotice(message,bname,'lightblue','red',msgBCWeight);}
  if (copyLarry == true || reqBy == 'lucky_larry') {cb.sendNotice(message,'lucky_larry','','',msgBCWeight);}
}  //End sendBroadcasterMsg

//***************************************************************************************
//******************  SEND DEBUG MESSAGE ************************************************
function sendDebugMsg(msgForBroadcaster,showTime = false,reqBy = 'BC',copyLarry = true) {

  if (debugMode == false) {
    return;
  } else {
    sendBroadcasterMsg('Debug Message: ' + msgForBroadcaster,showTime,reqBy,copyLarry);
  }

}  //End sendDebugMessage

//***************************************************************************************
//******************  WAS USER ADDED ****************************************************
function wasUserAdded() {
//Return the value of array variable wasAdded[0] to see if its true and set to false
//It would be set true only in a case where a user was added to the userArray

  if (wasAdded[0] == true) {
    wasAdded[0] = false;
    return true;
  } else {
    return false;
  }
}  //End function wasUserAdded

//***************************************************************************************
//******************  MILLISECONDS TO TIME STRING ***************************************
function millisecsToTime(mills) {
  let secs = mills / 1000;
  let mins = secs / 60;
  let hrs = mins / 60;
  
  return Math.trunc(hrs) + ' Hours ' + Math.trunc(mins % 60)
    + ' Minutes ' + Math.round(secs % 60) 
    + ' Seconds.  Calculated from ' + mills + ' Milliseconds';
}  //End function millisecsToTime

//***************************************************************************************
//******************  ARRAY TO STRING ***************************************************
function arrayToString(x,maxLength=255) {
//Function to take an array and build a string with it up to the maxLength

  sendBroadcasterMsg('Users array has length of [' + x.length + ']');

  var xOut = 'Start:[';
  
  for (let i = 0; i<x.length; i++) {
    sendBroadcasterMsg('Processing array element [' + i + '] '
      + 'which has a value of [' + x[i] + '] and length of [' + x[i].length + ']');
    if (xOut.length + x[i].length + 1 > maxLength) {return xOut + ']';}
    xOut = xOut + x[i] + ';';
  }
  return xOut + ']';
}  //End arrayToString

//***************************************************************************************
//******************  OUTPUT ARRAY ******************************************************
function outputArray(x,reqBy = 'BC') {
// Send a message to broadcaster for each element in the Array
  for (let i = 0; i<x.length; i++) {
    sendBroadcasterMsg('Processing array element [' + i + '] which has a value of [' + x[i] + '] '
      + 'and length of [' + x[i].length + ']',false,reqBy);
  }
}  //End outputArray

//***************************************************************************************
//******************  ADD TO USER ARRAY *************************************************
function addToUserArray (newUser,wasUserAdded = false) {
//Adds a new user to the userArray if the entry does not already exist

  let indexElement = userArray.indexOf(newUser);
  let debugThis = false;
  
  wasAdded[0] = false;
  
  //Debug Message
  if (debugThis == true) {
    sendDebugMsg('1) In addToUserArray for elementToPut = [' + newUser + '] '
      + 'Current array length = [' + userArray.length + '] '
      + 'Value of indexOf = [' + indexElement + ']');}
  
  if (indexElement >= 0) {
  
    //Debug Message
    if (debugThis == true) {
      sendDebugMsg('2) In addToUserArray for newUser = [' + newUser + '] '
        + 'element WAS FOUND so no element creation needed.  '
        + 'Current array length = [' + userArray.length + '] '
        + 'And userArray[indexElement] = [' + userArray[indexElement] + ']');}
        
    return indexElement;
    
  } else {
    
    //Since the Array counter is Zero-based the length of the array should always be
      //the amount for the next new slot
    let newIndex = userArray.length;
    
    userArray[newIndex] = newUser;

    //Set flag that user was added here
    wasAdded[0] = true;

    //Debug Message
    if (debugThis == true) {
      sendDebugMsg('2) In addToUserArray for newUser = [' + newUser + '] '
        + 'AFTER ADDING new element Array Index = [' + newIndex + '] '
        + 'Current array length = [' + userArray.length + '] '
        + 'indexOf for newUser = [' + userArray.indexOf(newUser) + '] '
        + 'And userArray[newIndex] = [' + userArray[newIndex] + ']');}
    
    return newIndex;
    
  }  //End if indexElement >= 0
}  //End function addToUserArray

//***************************************************************************************
//******************  PUT IN ARRAY ******************************************************
function putInArray (arrayToPutInto,elementToPut) {
//Check if the element already exists in array and push it in if not
  //Return the index number of the element created or found
  
  let indexElement = arrayToPutInto.indexOf(elementToPut);

  //Control availability of debug messages for just this section only
  let debugPutInArray = false;
  
  //Debug Message
  if (debugPutInArray == true) {
    sendDebugMsg('1) In putInArray for elementToPut = [' + elementToPut + '] '
      + 'Current array length = [' + arrayToPutInto.length + '] '
      + 'populating variable indexElement with Current indexOf = ['+indexElement+']');}
  
  if (indexElement >= 0) {
  
    //Debug Message
    if (debugPutInArray == true) {
      sendDebugMsg('2) In putInArray for elementToPut = ['+elementToPut+'] '
        + 'element WAS FOUND so no Push needed.  '
        + 'Current array length = [' + arrayToPutInto.length + '] ');}
        
    return indexElement;
    
  } else {
    
    let newIndex = arrayToPutInto.length;
    
    arrayToPutInto[newIndex] = elementToPut;

    //Debug Message
    if (debugPutInArray == true) {
      sendDebugMsg('2) In putInArray for elementToPut = [' + elementToPut + '] '
        + 'AFTER adding new element Array Index = [' + newIndex + '] '
        + 'Current array length = [' + arrayToPutInto.length + '] '
        + 'indexOf for elementToPut = [' + arrayToPutInto.indexOf(elementToPut) + ']');}
    
    return newIndex;
    
    //let newArrayLength = arrayToPutInto.push(elementToPut);
    
    //indexElement = arrayToPutInto.indexOf(elementToPut);
    
    //Debug Message
    //if (debugPutInArray == true) {
      //sendDebugMsg('2) Debugging In putInArray for elementToPut = [' + elementToPut + '] '
        //+ 'AFTER push variable indexElement now = [' + indexElement + '] '
        //+ 'Current array length = [' + arrayToPutInto.length + '] '
        //+ 'indexOf for elementToPut = [' + arrayToPutInto.indexOf(elementToPut) + ']');}
    
    //return indexElement;
    
    //return arrayToPutInto.push(elementToPut) + 1;
  }  //End if indexElement was already found
}  //End function putInArray

//***************************************************************************************
//******************  POP OUT OF ARRAY **************************************************
function popOutOfArray(arrayToPopOut,elementToPopOut) {
//Check if the element exists in array and pop it out if so
  //Return true if it was found
  
  let indexElement = arrayToPopOut.indexOf(elementToPopOut);
  
  if (indexElement >= 0) {
    arrayToPopOut.pop(indexElement);
    return true;
  } else {
    return false;
  }  //End if indexElement was found
}  //End function popOutOfArray

//***************************************************************************************
//******************  SEND UNAME SPLIT ***********************************************
function send_uname_split(uname_split) {
  //Loop through all username parts to send a message to lucky_larry that it is being monitored for
        
  for (let i=0; i<uname_split.length; i++) {

    cb.sendNotice('Monitoring for Username part [' + uname_split[i] + ']','lucky_larry');

    cb.sendNotice('Monitoring for Username part [' + uname_split[i] + ']',bname);
    
  }
  return true;
} //End function send_uname_split

//***************************************************************************************
//******************  NEXT MOTIVATION MESSAGE *******************************************
function nextMotivMsg() {
//Send the next motivational method and start a new timer for calling this function again to send the next one
    
    //Check the One-Based Motivational Message Next-Message value and if greater than the number of messages reset to zero.
    if (motvNextMessage > motvMsgCount - 1) {
      motvNextMessage = 1;
    } else {
      motvNextMessage++;
    }
    
    //Send the motivational message for the current value of motvNextMessage index
    sendBroadcasterMsg(motvMsgArray[motvNextMessage]);
    
    //This was for building and troubleshooting:
    //sendBroadcasterMsg('Motivational Index = [' + motvNextMessage + '] and Message: [' + motvMsgArray[motvNextMessage] + ']',true);
    
    cb.setTimeout(nextMotivMsg, motvMsgInterval);
}  //End nextMotivMsg

//***************************************************************************************
//******************  SETUP MOTIVATION MESSAGES *****************************************
function setupMotivationalMessages() {
//Combine the Motivational Messages set by the broadcaster into an array and create timers for each based on the motvInterval setting also set by the Broadcaster.  Array will be 1-based.  Setting the "0" element of the array to a value we will never reference to hold he Zeroth place.
  
  //Set the motivational message interval x 1,000 of value user put in for minutes since it is expressed in Milliseconds.
  if(cb.settings.motvInterval <= 0) {
    motvMsgInterval = motvMsgDefaultInterval;
  } else {
    motvMsgInterval = cb.settings.motvInterval * 60000; //60,000 Milliseconds is one minute
  }
  
  //Set the motvMsgArray equal to all the different Broadcaster specified messages
  motvMsgArray = ['Ignore Zeroth',cb.settings.motvMsg1,cb.settings.motvMsg2,cb.settings.motvMsg3,
    cb.settings.motvMsg4,cb.settings.motvMsg5,cb.settings.motvMsg6,cb.settings.motvMsg7,
    cb.settings.motvMsg8,cb.settings.motvMsg9,cb.settings.motvMsg10];

  //sendBroadcasterMsg('In setupMotivationalMessages and motvMsgInterval set to [' + motvMsgInterval + '] and Messages Array length = [' + //motvMsgArray.length + ']');
    
  //Check if anything other than the Ignore Zeroth message was populated into the Motivational Messages array and if so call next message
  if (motvMsgArray.length > 1) {
    motvNextMessage = 0;
    motvMsgCount = motvMsgArray.length - 1;
    nextMotivMsg();
  }  //End if motvMsgArray Length > 1
  
}  //End setupMotivationalMessages

//**********************************************************************************
//******************  SETUP GREY USER HANDLING *************************************
function setupGreyFemaleHandling() {

  doIgnoreGreyFemales = true;
  doSilenceGreyFemales = true;
  doQuarantineGreyFemales = true;
  
  sendBroadcasterMsg('Grey Female Action Setting = [' + cb.settings.greyFemaleAction + ']'); 
    
  switch (cb.settings.greyFemaleAction.slice(0,1)) {      
    case '1': //Ignore & Silence
      doQuarantineGreyFemales = false;
      break;
    case '2': //Notify & Silence
      doIgnoreGreyFemales = false;
      doQuarantineGreyFemales = false;
      break;
    case '3':  //Ignore & Quarantine
      doSilenceGreyFemales = false;
      break;
    case '4':  //Notify & Quarantine
      doIgnoreGreyFemales = false;
      doSilenceGreyFemales = false;
      break;
  }
  
  sendBroadcasterMsg('Ignore Grey Females? ' + doIgnoreGreyFemales);
  sendBroadcasterMsg('Silence Grey Females? ' + doSilenceGreyFemales);
  sendBroadcasterMsg('Quarantine Grey Females? ' + doQuarantineGreyFemales + ' '
    + 'NOTE Quarantine setting will be ignored if set to Silence Grey Females also.');
  
}  //End function setupGreyFemaleHandling

//***************************************************************************************
//******************  CB SETTINGS CHOICES ***********************************************
//Establishes the variables input by Broadcaster
//Would like to add a setting that Broadcaster can opt-out of seeing the messages and only send to mods.
cb.settings_choices = [
    {name:'botversion', type:'choice', choice1: botVersion, defaultValue:'Broadcaster',
      label: "Luckys User Filter Version " + botVersion},
    {name:'broadcasterNameInNotices', type:'str', minLength:1, maxLength:40,
        label: 'How would you like your name to appear in various messages the bot will generate?'},
    {name:'uname_parts', type:'str',
        minLength:1, maxLength:255, defaultValue:"bad,user,name,part", 
        label: 'Comma-Separated Username Fragments where if a user comes to chat and any '
          + 'fragment partially matches his username he will be silenced automatically.'},
    {name:'uname_forward', type:'str',
        minLength:1,maxLength:255, defaultValue:"lucky_larry", label: 'Bot-Admins:  In this version '
          + 'lucky_larry is hard-coded as the only bot-admin and can always see messages regardless '
          + 'of what you put here.  Flexibility here coming in future release.'},
    {name:'canFemaleUsersChat', 
      type:'choice', choice1:'Quarantine', choice2:'Yes Chat-Freely', 
      defaultValue: 'Quarantine', 
      label: 'Are female Viewers allowed to chat?  Choose Yes or Quarantine.  '
        + 'Quarantine means their messages will only show to you, the Broadcaster '
        + 'unless you decide to unsilence them with the uuuX command where X is their '
        + 'numeric user-ID in this session OR their spelled-out name.  You can still '
        + 'silence them to invoke the behavior you have chosen for silenced Viewers.'},
    {name:'greyFemaleAction', 
      type:'choice', choice1:'1: Ignore & Silence', choice2:'2: Notify You & Silence',
        choice3:'3: Ignore & Quarantine', choice4:'4: Notify You & Quarantine',
      defaultValue:'Ignore & Silence',
      label: 'How do you want to handle Gray-User Females?'},
    {name:'assholeSubText',type:'str',maxLength:255,
      defaultValue:assholeSubText,label:'Asshole Substitution Text'},
    {name:'showBlkdMsgs', type:'choice', 
      choice1:'Yes', choice2:'No', defaultValue: 'No', 
      label: 'When messages are blocked do you want to see them privately?  '
        + 'If you choose No they will just be ignored.'},    
    {name:'useMotivateMsgs', type:'choice', 
      choice1:'Yes', choice2:'No', defaultValue: 'No', 
      label: 'Do you want to use the Motivation and Helper Messages feature?  '
        + 'These are messages that only the Broadcaster and bot-admins will see at the '
        + 'interval you specify in the next setting.'},
    {name:'motvInterval', type:'int', minValue:0, maxValue:99, defaultValue:7, 
      label: 'Enter the number of minutes between messages:'},
    {name:'motvMsg1', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"YOU ARE GODDESS!  MAY THEY HEAR YOU ROAR!!", 
      label: "Motivational Money or Helper Message 1"},
    {name:'motvMsg2', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"WHAT CAN YOU DO RIGHT NOW TO ENGAGE MORE WITH YOUR GUYS??", 
      label: "Motivational Money or Helper Message 2"},
    {name:'motvMsg3', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"DO YOU NEED WATER?", 
      label: "Motivational Money or Helper Message 3"},
    {name:'motvMsg4', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"YOU ARE BEAUTIFUL POWERFUL & ABUNDANCE IS HEADED YOUR WAY!!", 
      label: "Motivational Money or Helper Message 4"},
    {name:'motvMsg5', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"HAVE YOU THANKED EVERYONE FOR VISITING YOU LATELY?", 
      label: "Motivational Money or Helper Message 5"},
    {name:'motvMsg6', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"PLAY WITH BUBBLES??", 
      label: "Motivational Money or Helper Message 6"},
    {name:'motvMsg7', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"HULA??", 
      label: "Motivational Money or Helper Message 7"},
    {name:'motvMsg8', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"YOU ARE BEAUTIFUL POWERFUL & ABUNDANCE IS HEADED YOUR WAY!!", 
      label: "Motivational Money or Helper Message 8"},
    {name:'motvMsg9', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"SHOUT OUT CLIP STORES & LINK!", 
      label: "Motivational Money or Helper Message 9"},
    {name:'motvMsg10', type:'str',
      minLength:1,maxLength:255, 
      defaultValue:"WHAT CAN YOU DO RIGHT NOW TO ENGAGE MORE WITH YOUR GUYS??", 
      label: "Motivational Money or Helper Message 10"},
    {name:'debugMode', type:'choice', choice1:'Debug On', choice2:'Debug Off',
      defaultValue: 'Debug Off',
      label: 'Show extra messages for bot-Debugging purposes?'}
]; //End Settings_Choices set

//**********************************************************************************
//******************  ON START *****************************************************
cb.onStart(user => {

    //Store Broadcaster's name
    bname = cb.room_slug;
    
    //Initialize userArray with Broadcaster's name
    userArray[0] = bname;

    //Set Session Start Time
    startTime = new Date();
    
    //Set if Debug Mode on
    debugMode = (cb.settings.debugMode == 'Debug On');
    
    //Note to Broadcaster if Debug Mode is on
    sendDebugMsg('DEBUG Mode is ON so expect more messages for troubleshooting the bot');
    
    //cb.chatNotice(user['user'] + ' started an app!');
    cb.chatNotice(bname + ' started bot Luckys_User_Filter_Flexible! '
        + 'Version ' + botVersion + ' ' + 'At ' + startTime,
      '','','bold');
    
    //Store Broadcaster's Notice Name that was set
    bNoticeName = cb.settings.broadcasterNameInNotices;
    
    //Store setting to show blocked messages
    showBlkdMsgs = cb.settings.showBlkdMsgs;
    
    //Set value to note if female viewers can chat freely
    doAllowPublicFemaleMsgs = (cb.settings.canFemaleUsersChat == 'Yes');

    setupGreyFemaleHandling();
    
    assholeSubText = cb.settings.assholeSubText;
    
    //Print blocked messages status to the Broadcaster only
    sendBroadcasterMsg('Broadcaster will see blocked messages?  [' + showBlkdMsgs +']');
    
    //Initialize special user arrays to make them 1-based
    userSilencedArray[0] = 'Silenced Placeholder of Index 0';
    userQuarantineArray[0] = 'Quarantine Placeholder of Index 0';
    userAssholesArray[0] = 'Assholes Placeholder of Index 0';
    
    //Uncomment below to print a private list of all username 
      //parts that will be scanned for into the chat at bot-start
    //send_uname_split(cb.settings.uname_parts.split(','));
    
    //Need to call function to load all current chatroom users into the array
    //loadCurrentUsers();
    
    //Function to setup the Motivational Messages
    if (cb.settings.useMotivateMsgs == "Yes") {
      setupMotivationalMessages();
    }  //End IF if Motivational Messages should be used    
  }  //End function passed into cb.onStart event
);  //End cb.onStart event code

//**********************************************************************************
//******************  CB GET ROOM OWNER DATA ***************************************
cb.getRoomOwnerData(ownerData => {
    if (ownerData['success']) {
        cb.chatNotice(cb.room_slug + ' has ' + ownerData['data']['followers'] + ' followers!')
    }
});

//**********************************************************************************
//******************  HANDLE FEMALE VIEWERS ON ENTER *******************************
function handleFemViewersOnEnter(usr,isUserGrey,userIndex) {
//Handle females and Prompt Broadcaster in accordance with Broadcaster Preferences
  
  //Initialize variables that will accumulate what to do    
  let doSilence = false;
  let doQuarantine = false;
  let doNotify = false;
  
  //sendBroadcasterMsg('About to setup handling for user ' + usr + ' '
    //+ 'where isUserGrey = ' + isUserGrey + ' and '
    //+ 'doIgnoreGreyFemales = [' + doIgnoreGreyFemales + '] & '
    //+ 'doSilenceGreyFemales = [' + doSilenceGreyFemales + '] & '
    //+ 'doQuarantineGreyFemales = [' + doQuarantineGreyFemales + '] & '
    //+ 'doAllowPublicFemaleMsgs = [' + doAllowPublicFemaleMsgs + ']');
  
  //Figure out if we should notify Broadcaster of the arrival of this female
  if (doIgnoreGreyFemales == true && isUserGrey == true) {
      //Do not need to change anything since doNotify already initialized as false     
  } else if (doIgnoreGreyFemales == false && isUserGrey == true) {
      doNotify = true;
  } else if (isUserGrey == false) {
      doNotify = true;
  }  //End if for figure out doNotify
  
  //Figure out if we should silence or quarantine this female
  if (doSilenceGreyFemales == true && isUserGrey == true) {
    //sendBroadcasterMsg('Hit on doSilenceGreyFemales is true and isUserGrey is true for user ' + usr);
    doSilence = true;
  } else if (doQuarantineGreyFemales == true && isUserGrey == true) {
    //sendBroadcasterMsg('Hit on doQuarantineGreyFemales is true and isUserGrey is true for user ' + usr);
    doQuarantine = true;
  } else if (isUserGrey == false) {
    //sendBroadcasterMsg('Hit on isUserGrey == false for user ' + usr);
    doQuarantine = !doAllowPublicFemaleMsgs;
  } else {
    //sendBroadcasterMsg('ERROR No true condition found when determining if should silence or quarantine for user ' + usr);
  } //End if to figure out doSilence & doQuarantine

  //sendBroadcasterMsg('In function handleFemaleViewersOnEnter for user ' + usr + ' '
    //+ 'where isUserGrey = ' + isUserGrey + ' and '
    //+ 'doSilence = [' + doSilence + '] & doQuarantine = [' + doQuarantine + '] & '
    //+ 'doNotify = [' + doNotify + ']');
  
  //If Broadcaster wants female messages to show
  if (doAllowPublicFemaleMsgs == true) {
    sendBroadcasterMsg(
      'WARNING!  User #' + userIndex + ' ' + usr + ' is FEMALE.  ' 
        + 'Are they broadcasting?  '
        + 'Enter sss' + userIndex + ' to silence them as needed.');
            
  } else {
    
    //Push new female user into Silence or Quarantine Array so their messages will not show
      //to anyone.  If Silenced the Quarantine push doesn't matter and they 
      //should be popped out of Quarantine if in there.
    if (doSilence == true) {
      popOutOfArray(userQuarantineArray,usr);
      putInArray(userSilencedArray,usr);

      if (doNotify == true) {
        if (showBlkdMsgs == 'Yes') {
          whoSees = 'Only Broadcaster and Bot-Admins';
        } else {
          whoSees = 'Nobody';
        }
        sendBroadcasterMsg('WARNING!  User #' + userIndex + ' ' + usr + ' is FEMALE.  ' 
        + 'They are Silenced automatically.  ' + whoSees + ' will see their chat.  '
        + 'Enter uuu' + userIndex + ' to allow them to chat freely with the room.');}    
        
    //Push new female user into Quarantine Array so their messages will not show
      //to public chat
    } else if (doQuarantine == true) {
      putInArray(userQuarantineArray,usr);
      popOutOfArray(userSilencedArray,usr);
  
      if (doNotify == true) {
        sendBroadcasterMsg('WARNING!  User #' + userIndex + ' ' + usr + ' is FEMALE.  ' 
        + 'They are Quarantined automatically so only you can see their chat.  '
        + 'Enter uuu' + userIndex + ' to allow them to chat freely with the room.');}     
        
    }  //End if doSilence == true
  }  //End if doShowFemaleMessages
    
}  //End function handleFemaleViewersOnEnter

//**********************************************************************************
//******************  ADD USER TO ARRAYS *******************************************
function addUserToArrays(usr,isUserGrey,gender) {
//Auto-Silence or Quarantine users as appropriate

    //Flag to collect if the user was added in addToUserArray.  This will remain false if
      //the user already existed.
    wasAdded[0] = false;
    
    //Check if user is already in the userArray and add if not returning the index number for the user
    userIndex = addToUserArray(usr);
    
    //Debug message
    sendDebugMsg('in onEnter Just called addToUserArray for user [' + usr + '] '
      + 'at Index [' + userIndex + '] and wasAdded flag was returned [' + wasAdded[0] + '].');
    
    //Check if username should be filtered
    isUserNameFiltered(usr,cb.settings.uname_parts.split(','));
    
    //Uncomment below to give a message for each new person joining.
    //cb.chatNotice('Welcome ' + usr + '! '
      //+ 'You are visitor number ' + userIndex + ' into my room today!','lucky_larry');
    
    //If female go figure out if we need to notify Broadcaster and / or silence new viewer
    if (gender == 'f') {handleFemViewersOnEnter(usr,isUserGrey,userIndex);}
    
}

//**********************************************************************************
//******************  ON ENTER *****************************************************
cb.onEnter(function(user) {

  let usr = user['user'];
  let isUserGrey = !user['has_tokens'];

  //Set last entered username for various other functions
  lastEntered = usr;
  
  sendDebugMsg('In onEnter for user ' + usr + ' '
    + 'isUserGrey = [' + isUserGrey + '] & '
    + 'gender = [' + user['gender'] + ']',true);

  //Make sure first element of userArray is set to Broadcaster just in case this onEnter
    //runs before onStart somehow
  if (userArray.length == 0) {userArray[0] = bname;}

  //If user = Broadcaster make sure Zeroth element of userArray = Broadcaster
  if (usr == bname) {
  
    userArray[0] = bname;   
  
  } else {
    
    addUserToArrays(usr,isUserGrey,user['gender']);
    
  } //End if user = bname (Broadcaster)
});

//*******************************************************************************
//******************  IS USERNAME FILTERED **************************************
function isUserNameFiltered(checkuname,uname_split) {
//Check if the passed-in username matches any of the username fragments that
  //should be blocked and if so add them to the Silenced-Users Array
  
  //If user being checked is Broadcaster then return false
  if (checkuname == bname) {return false;}
  
  //If user is already in the Silenced array no need to continue
  if (userSilencedArray.indexOf(checkuname) >= 0) {return true;}
  
  //Checks if the username matches any of the filter-fragments
  for (let i=0; i<uname_split.length; i++) {
  
    if (checkuname.includes(uname_split[i])) {
    
      //Add user to the SilencedArray to shortcut this next time they send a message
      userSilencedArray.push(checkuname);
          
      return true;
    }  //End IF block testing if message-sender's username contains any of the username split parts
  }  //End For-Each block iterating through all the username-parts
  return false;
}  //End function isUserNameFiltered

//*******************************************************************************
//******************  SHOULD_BLOCK_MSG ******************************************
function should_block_msg(msg) {
//Determine if the message sent should be blocked for various reasons

try {

  let checkuname = msg['user'];
  let uname_split = cb.settings.uname_parts.split(',');
  let doBlockMessage = false;

  //Make sure Broadcaster is never silenced by exiting function immediately
  if (checkuname == bname) {return false;}

  isAsshole = (userAssholesArray.includes(checkuname) == true);
  
  //Get the index for the user for to-Unsilence helper message
  let userIndex = userArray.indexOf(checkuname);

  sendDebugMsg('1) In should_block_msg:  checkuname = [' + checkuname + '] and '
      + 'uname_split has [' + uname_split.length + '] elements '
      + 'from uname_parts = [' + cb.settings.uname_parts + '] '
      + 'isAsshole = ['+isAsshole+']',bname);

  //If user is Silenced OR Quarantined then print messages to Broadcaster & Bot-Admins
  if (isAsshole == true) {
  
    sendBroadcasterMsg('Blocked message from ASSHOLED user ' + checkuname + ': '
          + '[' + msg['m'] + '] enter uuu' + userIndex + ' to Un-Silence them.');
    
    sendDebugMsg('3) in shouldBlockMsg Starting asshole calculation and lastAsshole = [' + lastAsshole + '] and '
      + 'assholeIndex = [' + assholeIndex + ']');

    if (lastAsshole == 1) {
      lastAsshole = 0;
      exclaimString = '!!!';
  	} else {
  	  lastAsshole = 1;
  	  exclaimString = '!';
  	};    

    //Prevent too many exclamation points from cluttering chat or initialize assholeIndex
    if (assholeIndex > 50 || assholeIndex <= 0) {assholeIndex = 1;}

    sendDebugMsg('4) in shouldBlockMsg AFTER asshole incrementation now lastAsshole = ' + lastAsshole + ' and '
      + 'assholeIndex = [' + assholeIndex + ']');
    
    sendDebugMsg('5) Asshole exclaimString is ' + exclaimString.length + ' chars long and '
      + 'has value of [' + exclaimString + ']');

    //Change the message text to remove what the Asshole said and replace with AssholeSubText
    msg['m'] =  assholeSubText + exclaimString;
    
    return false;
        
  } 
  
  isQuarantined = (userQuarantineArray.includes(checkuname) == true);
  isSilenced = (userSilencedArray.includes(checkuname) == true);  

  sendDebugMsg('2) In should_block_msg:  checkuname = [' + checkuname + '] and '
      + 'uname_split has [' + uname_split.length + '] elements '
      + 'from uname_parts = [' + cb.settings.uname_parts + '] '
      + 'isQuarantined = ['+isQuarantined+'] '
      + 'isSilenced = ['+isSilenced+']'
    ,bname);
  
  if  (isSilenced == true || isQuarantined == true) {

    if (msg['has_tokens'] == false && msg['gender'] == 'f' && doIgnoreGreyFemales == true) {
    
      return true; 
        
    } else if (showBlkdMsgs == 'Yes') {
    
      if (isSilenced == true) {
        sendBroadcasterMsg('Blocked message from SILENCED user ' + checkuname + ': '
          + '[' + msg['m'] + '] enter uuu' + userIndex + ' to Un-Silence them.');
      } else {
        sendBroadcasterMsg('Blocked message from QUARANTINED user ' + checkuname + ': '
          + '[' + msg['m'] + '] enter uuu' + userIndex + ' to Un-Silence them.');        
      }  //end if isSilenced
      
      //showBlkdMsgs is not 'Yes'
    } else {
      if (isSilenced == true) {
        sendBroadcasterMsg('Blocked message from SILENCED user ' + checkuname + ': '
          + '[' + msg['m'] + '] enter uuu' + userIndex + ' to Un-Silence them.',false,'lucky_larry');
      } else {
        sendBroadcasterMsg('Blocked message from QUARANTINED user ' + checkuname + ': '
          + '[' + msg['m'] + '] enter uuu' + userIndex + ' to Un-Silence them.',false,'lucky_larry');        
      }  //end if isSilenced and showBlockedMsgs is not 'Yes'   
    }  //end if showBlkdMsgs
    return true;
    
    //If user is neither Silenced nor Quarantined then see if filtered
  } else if (isUserNameFiltered(checkuname,uname_split) == true) {

    doBlockMessage = true;

    if (doBlockMessage == true) {
      cb.sendNotice('Blocked message from FILTERED user ' + checkuname + ': [' + msg['m'] + ']','lucky_larry','bolder');  
      if (showBlkdMsgs == 'Yes') {
        sendBroadcasterMsg('Blocked message from ' + checkuname + ': [' + msg['m'] + ']');}
  
    }  //End If doBlockMessage is true
  
  }  //If username in SilencedArray
  return doBlockMessage;  
  
} catch(err) {

  sendDebugMsg('Error in shouldBlockMessage name ['+err.name+'] and message ['+err.message+']');
  
  return false;

}  //End Try - Catch
}  //End function should block message

//*************************************************************************
//******************  SEND_FOLLOWER_COUNT *********************************
function sendFollowerCount() {
  //This function is intended to create a notice in the chatroom indicating the number of followers.
  cb.getRoomOwnerData(ownerData => {
    if (ownerData['success']) {
        cb.chatNotice(cb.room_slug + ' has ' + ownerData['data']['followers'] + ' followers!')
    }
  });
}  //End function SendFollowerCount

//*************************************************************************
//******************  ADD USER TO ARRAY INDEX OR NAME *********************
function addUserToArrayIndexOrName (arrayForAdd,uname,umsg,umsg3) {
//Receive a user-index OR username and add it to the given array as appropriate.
//This will be  useful for the silenced, quarantined, and Assholes lists.

  sendDebugMsg('1) In addUserToArray and uname ['+uname+'] umsg ['+umsg+'] umsg3 ['+umsg3+']');
  
  //userAdd = Number(umsg3);
  
  //sendDebugMsg('2) In addUserToArray after userAdd = Number(umsg3) = ['+userAdd+'] '
    //+ 'and umsg3 = ['+umsg3+']');
  
  if (isNaN(umsg3) == true) {
  
    userAdd = userArray.indexOf[umsg3];
    
    sendDebugMsg('2) In addUserToArray NaN - NAME get userArray.indexOf[umsg3] and userAdd now ['+userAdd+']');
    
    if (userAdd >= 0) {
      putInArray(arrayForAdd,userArray[umsg3]);
      uname = userArray[umsg3];
      
      sendDebugMsg('3) In addUserToArray by INDEX Number and uname ['+uname+'] umsg ['+umsg+'] umsg3 ['+umsg3+']'); 
      
      return umsg3;
    } else {
      sendBroadcasterMsg('In function addUserToArrayIndexOrName for [' + umsg + '] '
        + 'and username to act on cannot be determined or is not in users Array.');
      uname = 'Unknown';
      return -1;
    }  //End if userAdd >= 0
  } else {
    
    userAdd = Number(umsg3);
  
    putInArray(arrayForAdd,userArray[userAdd]);
    
    uname = userArray[umsg3];

    sendDebugMsg('2) In addUserToArray by INDEX NUMBER and uname ['+uname+'] umsg ['+umsg+'] umsg3 ['+umsg3+']');     
    
    return umsg3;
  }  //End if userAdd == false

  return -1;

}  //End function addUserToArrayIndexOrName

//*************************************************************************
//******************  ADD TO ASSHOLE LIST *********************************
function addUserToAssholeList (uname,umsg,umsg3) {


  indexAdded = addUserToArrayIndexOrName(userAssholesArray,uname,umsg,umsg3) 
  
  if (indexAdded >= 0) {
    sendBroadcasterMsg('User ' + userArray[indexAdded] + ' was added to the Assholes List.')};
    
}  //End function addUserToAssholeList

//*************************************************************************
//******************  REMOVE FROM ASSHOLE LIST ****************************
function removeUserFromAssholeList (uname,umsg,umsg3) {

  sendDebugMsg('Removing from Asshole list uname ['+uname+'] umsg ['+umsg+'] umsg3 ['+umsg3+']');

  if (Number.isNaN(umsg3) == false) {
    uname = userArray[umsg3];
    userIndex = umsg3;
  } else {
    userIndex = userAssholesArray.indexOf(umsg3);
    uname = umsg3;
  }
  userAssholesArray.pop(userIndex);

  sendBroadcasterMsg('User ' + uname + ' has been removed from the Assholes list.');

}  //End function removeUserFromAssholeList

//*************************************************************************
//******************  SILENCE USER ****************************************
function silenceUser (uname,umsg,umsg3) {
//Code to prevent chat from users that should be silenced.  As of 29Sep21 mechanism is by
  //adding the user to the array userSilencedArray
      
  //Debug message can probably delete it
  //sendBroadcasterMsg('Message = [' + msg['m'] + '] Length = [' + msg['m'].length + '] '
    //+ 'Substring = [' + msg['m'].substring(3,msg['m'].length-3) + ']',false,uname);
  
  if (isNaN(umsg3) == true) {  
    let userToSilence = umsg3;  
  } else {
    let userToSilence = userArray[umsg3];
  }  //End if isNaN(umsg3)
    
  sendDebugMsg('Calling putInArray for userToSilence = ['+userToSilence+']');
   
  //Add the user to the array of silenced users
  //userSilencedArray.push(userArray[userToSilence]);
  putInArray(userSilencedArray,userToSilence);
  
  //DONT Think we need to remove from Quarantine array when silencing as long as 
    //we check silence array first
  
  sendBroadcasterMsg('User #' + userToSilence + ' [' + userArray[userToSilence] + '] '
    + 'has been added to the silence list.  Enter uuu' + userToSilence + ' to unsilence them.');  

}  //End function silenceUser

//*************************************************************************
//******************  UN-SILENCE USER *************************************
function unSilenceUser(uname,umsg,umsg3) {
//Code to allow silenced or quarantined users to chat feely by removing them out of the
  //silence or quarantine arrays
           
      //Code to remove a user from the silence array
      userUnsilence = Number(umsg3);

      sendBroadcasterMsg('Running unsilence command for ' + umsg + ' and '
        + 'userUnsilence value = [' + userUnsilence + '].',false,uname);
      
      //if (userUnsilence == NaN) {
			if (userUnsilence == false || userSilencedArray.includes(umsg3) == true) {

        //Must have been the alpha-numeric username passed so get the Index of that username from the userSilencedArray
        let userIndex = userSilencedArray.indexOf(umsg3);
        
        if (userIndex > 0) {
        
          //Change that array element to remove the username from there
          userSilencedArray[userIndex] = 'Unsilenced ' + userIndex;
        
          //Pass confirmation message to broadcaster & bot-admin
          sendBroadcasterMsg('Unsilenced by name ' + umsg3 + ' Index [' + userIndex + '] '
            + 'and now reads [' + userSilencedArray[userIndex] + ']',false,uname);
        }  //End if userIndex > 0
        
        //Must have been the alpha-numeric username passed so get the Index 
          //of that username from the userSilencedArray
        userIndex = userQuarantineArray.indexOf(umsg3);
        
        if (userIndex > 0) {
        
          //Change that array element to remove the username from there
          userQuarantineArray[userIndex] = 'Un-Quarantined ' + userIndex;
        
          //Pass confirmation message to broadcaster & bot-admin
          sendBroadcasterMsg('Un-Quarantined by name ' + umsg3 + ' Index [' + userIndex + '] '
            + 'and now reads [' + userSilencedArray[userIndex] + ']',false,uname);
        }
        
      } else if (Number(umsg3) >= 0) {
      
        //Get the Username from the userArray
        getUser = userArray[umsg3];
        
        //Get the Index of the user in the SilencedArray
        let userIndex = userSilencedArray.indexOf(getUser);

        if (userIndex > 0) {
          userSilencedArray[userIndex] = 'Unsilenced ' + getUser;
      	  sendBroadcasterMsg('Unsilenced by Index [' + getUser + '] Index [' + umsg3 + '] '
            + 'and now reads [' + userSilencedArray[userIndex] + ']',false,uname);
      	}

        //Get the Index of the user in the QuarantineArray
        userIndex = userQuarantineArray.indexOf(getUser);

        if (userIndex > 0) {
          userQuarantineArray[userIndex] = 'Unsilenced ' + getUser;
          sendBroadcasterMsg('Un-Quarantined by Index [' + getUser + '] Index [' + umsg3 + '] '
            + 'and now reads [' + userSilencedArray[userIndex] + ']',false,uname);
        }
      
      } else {
      
        sendBroadcasterMsg('Unsilence Failure on [' + umsg3 + '] because '
          + 'Number check came up [' + (Number(umsg3)) + ']',false,uname);
      
      }  //End if userUnsilence == Nan

}  //End function unSilenceUser

//*************************************************************************
//******************  PRINT SESSION INFO **********************************

function printSessionInfo() {
//Print session information into the chat for Broadcaster and Bot-Admins
//Usually invoked by command lbinfo followed by a username

      
      //Calculate session duration
      let currTime = new Date();
      let duration = currTime - startTime;

      sendBroadcasterMsg('SESSION TIME INFO:  '
        + 'Session Duration = [' + millisecsToTime(duration) + '] '
        + 'Current Time [' + currTime.toTimeString() + '] '
        + 'Session Start Time [' + startTime.toTimeString() + ']');
      
      sendBroadcasterMsg('SESSION USER INFO:  '
        + 'There have been ' + userArray.length + ' vistors to this chatroom during this session.  '
        + 'Quarantined users: ' + userQuarantineArray.length + ' '
        + 'Silenced users: ' + userSilencedArray.length);
        
      sendBroadcasterMsg('MESSAGE INFO:  '
        + 'There have been ' + lastMessagedUsers.length + ' messages sent.  '
        + 'This does not include notices nor Admin command messages.');

}  //End function printSessionInfo

//*************************************************************************
//******************  PRINT USER INFO *************************************
function printUserInfo(umsg) {
//Print user information into the chat for Broadcaster and Bot-Admins
//Usually invoked by command usrinfo followed by a username
      
    const unames = umsg.split(' ');
      
    //Was just debug message
    //sendBroadcasterMsg('In usrinfo block and unames.length = ' + unames.length);
      
    if (unames.length > 1) {
      userIndex = userArray.indexOf(unames[1]);
      if (userIndex >= 0) {
        userIndexOutput = userIndex;
      } else {
        userIndexOutput = 'User Not Found';
      }  //End if userIndex >= 0
      sendBroadcasterMsg('Index for username ' + unames[1] + ' is ' + userIndexOutput);
    } else {
      sendBroadcasterMsg('Was not able to find a result for command [' + umsg + ']');
    }  //End if unames.length > 1
}  //End function printUserInfo

//*************************************************************************
//******************  SET LAST MESSAGED VARIABLES *************************
function setLastMessagedVariables(uname,umsg) {
//Keep a running list of the most recent usernames that sent a message to ease Broadcasters
  //ability to take action on them if needed.  This will save their name and the message.
//Should we let this build throughout the show?  Could be interesting to use later for things.
  
  //Check if the user is already in the array and delete the entry if so to keep the order correct
  if (lastMessagedUsers.indexOf(uname) < 0) {
    //Not found - Do Nothing
  } else {
    delete lastMessagedUsers[lastMessagedUsers.indexOf(uname)];
  }
  
  if (lastMessagedUsers.length == 1 && lastMessagedUsers[0] == '') {
    lastMessagedUsers[0] = uname + ':: ' + umsg;
  } else {
    lastMessagedUsers.push(uname + ':: ' + umsg);
  }
}  //End function setLastMessagedVariables

//*************************************************************************
//******************  PRINT USER MESSAGE **********************************
function printUserMessage(uname) {
  sendBroadcasterMsg(uname);
}  //End function printUserMessage

//*************************************************************************
//******************  FILTER USER MESSAGES ********************************
function filterUserMessages(uname) {
//This is used as the argument for the .filter method in outputUserMessages
  //and every element that starts with the username will be kept in the
  //filtered array
  return (uname.startsWith(userNameToFilter) == true);
}  //End function filterUserMessages

//*************************************************************************
//******************  OUTPUT USER MESSAGES ********************************
function outputUserMessages(uname) {
//Output all the saved messages for a given username
  
  //Set global userNameToFilter for use in special function
  userNameToFilter = uname;
  
  //This will create a new array from the original filtered by username
  userMsgsFiltered = lastMessagedUsers.filter(filterUserMessages);
  
  sendDebugMsg('In outputUserMessages there were ' + userMsgsFiltered.length + ' found!');
  
  //This will iterate through all elements to print them
  userMsgsFiltered.forEach(printUserMessage);
  
  return userMsgsFiltered.length;

}  //End function output UserMessages

//*************************************************************************
//******************  PRINT MOST RECENT MESSAGERS *************************

function printMostRecentMessagers(umsg3) {
//Print a list of the messages that have been saved.  By default only the 
  //3 most recent messages are displayed but user can specify more than that
  //if they want to or pass a username to see their messages instead
  
  msgCount = 3;
  
  userNameToFilter = umsg3;
  
  sendDebugMsg('In start of printMostRecentMessagers '
    + 'and umsg3 = ['+umsg3+'] and userArray.indexOf = ['+userArray.indexOf(umsg3)+'] '
    + 'and lastMessagedUsers.length = ['+lastMessagedUsers.length+'] '
    + 'and filtered by umsg3 length = ['+lastMessagedUsers.filter(filterUserMessages).length+'] ');
  
    //initial array length will be 1 because of how I initialize it
  if (lastMessagedUsers.length == 0 || 
      (lastMessagedUsers.length == 1 && lastMessagedUsers[0] == '')) {
    sendBroadcasterMsg('There have been no recent messages saved yet.');
    return;
  } else if (umsg3.length == 0) {
    msgCount = 3;
  } else if (isNaN(umsg3) == true && userArray.indexOf(umsg3) >= 0) {

      //If username was passed that has messages print them
    if (outputUserMessages(umsg3) <= 0) {
      sendBroadcasterMsg('User ' + umsg3 + ' has no saved messages.');}
    return;
    
  } else {
    msgCount = parseInt(umsg3);
  }
  
  sendDebugMsg('1) In printMostRecentMessagers and umsg3 = ['+umsg3+'] '
    + 'and lastMessagedUsers array length is ['+lastMessagedUsers.length+'] '
    + 'and msgCount = ['+msgCount+'] ');
  
  sendBroadcasterMsg('Sending the ' + msgCount + ' most recent chat messages:');
  
  //if msgCount > number of messages then reduce msgCount
  if (msgCount > lastMessagedUsers.length) {msgCount = lastMessagedUsers.length;}
  
  //Initialize variable
  currMsg = '';
  
  for (let i=lastMessagedUsers.length - 1;
    i > lastMessagedUsers.length - msgCount - 1;
    i--) {
  
    currMsg = lastMessagedUsers[i] + '';
      
    //Print a message to Broadcaster and botAdmins for each of the last messagers
    if (currMsg.length > 0) {
      
      //Isolate just the username from the current element
      userStuff = currMsg.split(':: ');
    
      sendBroadcasterMsg(
        '['+ userArray.indexOf(userStuff[0]) +'] << USER INDEX for '
          + userStuff[0] + ' message: [' + userStuff[1] + ']');
          //+ 'Past-Msg#' + i
          //+ ' User ' + userStuff[0] + ' & message: [' + userStuff[1] + ']');
    
    }  //End if lastMessagedUsers[i].length > 0
  }  //End for loop
  
}  //End function printMostRecentMessagers

//*************************************************************************
//******************  ON MESSAGE ******************************************
cb.onMessage(function (msg) {

  let uname = msg['user'];
  let umsg = msg['m'];
  let umsg3 = umsg.substr(3);
  
  //Message below will print for every message for debugging purposes
  //cb.sendNotice('In onMessage:  uname = [' + uname + '] and bname = [' + bname + '] and m = [' + msg['m'] + ']',bname);
  sendDebugMsg('In onMessage:  uname = [' + uname + '] and bname = [' + bname + '] '
    + 'and m = [' + msg['m'] + '] and umsg3 = ['+umsg3+']',bname);
  
  if (uname == bname || uname == 'lucky_larry') {

    umsg3 = myTrim(umsg3);
    
    //Much of what broadcaster or Bot-Admins will type will be a command that should be suppressed.
      //Adding X-Spam false here will save alot of lines of code under all the commands that follow.
    msg['X-Spam'] = true;
  
    //Code to execute if the message sender is the Broadcaster or Bot-Admin
      
      //****** FFF FOLLOWER COUNT ******
      //Check for Broadcaster code to request Follower count
    if (umsg == 'fff') {
    
      sendFollowerCount();
      
      //****** SSS SILENCE SOMEONE ******      
      //Check for silence code from Broadcaster
    } else if (umsg.startsWith('sss') == true) {
      
      silenceUser(uname,umsg,umsg3);
      
      //****** SHH PRINT USER ARRAY OR USER INDEX ******
      //Output either an individual user's index number or the entire user array    
    } else if (umsg.startsWith('shh') == true) {
      
      if (umsg == 'shh') {
    
        //Implement code to show the user that belongs to a given index
        outputArray(userArray.sort(),uname);
      
      } else {
        
        //Output user at a specific number
        let chkUser = umsg3;
        
        sendBroadcasterMsg('User #' + chkUser + ' is ' + userArray[chkUser] + '.',false,uname);
      
      }  //End if umsg == 'shh'
      
      //****** SHU PRINT SILENCED USERS LIST ******     
    } else if (umsg.startsWith('shu') == true && umsg.length == 3) {
    
      outputArray(userSilencedArray,uname); 
      
      //****** SHQ PRINT QUARANTINED USERS LIST ******
    } else if (umsg.startsWith('shq') == true && umsg.length == 3) {
    
      outputArray(userQuarantineArray,uname); 
    
      //****** SHQ PRINT ASSHOLED USERS LIST ******
    } else if (umsg.startsWith('sha') == true && umsg.length == 3) {
    
      outputArray(userAssholeArray,uname); 
      
      //****** UUU UNSILENCE USER ******
    } else if (umsg.startsWith('uuu')){

      unSilenceUser(uname,umsg,umsg3);
    
      //****** AAA Add user to asshole list ******
    } else if (umsg.startsWith('aaa')) {
    
      addUserToAssholeList(uname,umsg,umsg3);
      
    } else if (umsg.startsWith('bbb')) {
    
      removeUserFromAssholeList(uname,umsg,umsg3);
      
      //****** LBLINFO PRINT SESSION INFO ******
    } else if (umsg == 'lbinf' || umsg == 'lbinfo') {
    
      printSessionInfo();

    } else if (umsg.startsWith('usrinf') == true 
        || umsg.startsWith('userinfo') == true 
        || umsg.startsWith('usrinfo') == true
        || umsg.startsWith('uif') == true) {
    
      printUserInfo(umsg);
    
    } else if (umsg.startsWith('rrr') == true || umsg.startsWith('RRR') == true) {
    
      printMostRecentMessagers(umsg3);
      
    } else {

      //Note the username of the most recent user that sent a message
      setLastMessagedVariables(uname,umsg);
    
      //Since there was no command match we want to show the message
      msg['X-Spam'] = false
    
    }  //End if for special Broadcaster codes
    
    return msg;
   
    //User sending message is not the Broadcaster or a Bot-Admin
  } else {

    //Note the username of the most recent user that sent a message
    setLastMessagedVariables(uname,umsg);
  
    //Check if user is already in the userArray and add if not return the index number for the user
    //This call will not be needed once function to add all existing room users is implemented
    //This is only here to make sure that if someone sends a message that is not already contained in
        //userArray that they are put there.  This will not consider if user is a female or grey or any of that.
    indexAdded = addToUserArray(uname);
    
    if (wasUserAdded() == true) {
      
      addUserToArrays(uname,(msg['has_tokens'] == false),msg['gender']);

/*      sendBroadcasterMsg('In Message Event user ['+uname+'] was added to userArray '
        + 'and this MAY NOT CHECK Gender or Greyness.  '
        + 'Their User-Index number is ['+indexAdded+'].');
      sendBroadcasterMsg('Use sss' + indexAdded + ' if you need to silence ' + uname + '!');
*/
    }  //End if wasUserAdded
    
    //Code to execute if the message sender is not the Broadcaster  
    msg['X-Spam'] = should_block_msg(msg);
    
    return msg;

  } // End IF uname = bname block
  
  return msg;
  
}  //End cb.onMessge event function
);  //End cb.onMessage event code