Chaturbate

Bots Home | Create an App
V8.1.5 Luckys Bot TEST VERSION!
Author: lucky_larry
You are viewing version 1583017. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch Bot Current Users
There are 32 other versions of this script.
/* Lucky_Larry User-Filter-Chat bot 
   Development started 27Sep21
   Latest update 26Sep22
*/

var botVersion = 'Luckys User-Filter Bot Version R8.1.5b';

//R9 User Object Implementation
//R8.1.5 Msg Queue
//R8.1.4c Implemented horizontal lists
//R8.1.4 In onEnter check if the user is a mod before checking for any user-filter or
  //quarantines that may apply
//R8.1.3g  Color Codes can be set for Admin Messages & New Follower Messages
//R8.1.3 Added toggle on / off on settings screen for New Follower Notifications
//R8.1.2 New follower Notifications & Suppress quarantined user entered room messages
//R8 Message Queue Implementation to get ordering of messages more correct
//R7.3.1 Does not save messages from grey users when grey chat is not turned on
//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.

//***************************************************************************************
//******************  UTILITY VARIABLES *************************************************

const emptyString = '';

//***************************************************************************************
//******************  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;

//8.1.4 Bot Admin Constants
const botAdminBC = 1;
const botAdminSuper = 2;
const botAdminBasic = 3;
const botAdminEveryone = 4;

//***************************************************************************************
//******************  FOLLOWER MANAGEMENT SESSION VARIABLES *****************************
//Hold number of followers at session start
var startFollowers = -1;
//Hold value determined by SendFollowerCount in each call
var nowFollowers = -1;
//Total Followers Goal value
var totalFollowersGoal = -1;
//New Followers Goal for cam session
var newFollowersGoal = -1;
//Used in cb.onFollow to determine if we should send a chat message
var wasFollowerAdded = false;
//Store if the New-Follower notifications should be on or not
var doShowNewFollowNotifications = false;
//Store what level of user does the broadcaster wish to receive a private notification for
var doNotifyBCPurpleFollow = '';

//***************************************************************************************
//******************  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
var doIgnoreGreyFemales = true;
var doSilenceGreyFemales = true;
var doQuarantineGreyFemales = true;
var chatAllowedBy = 'all';

//Arrays that hold information on users for various purposes
const userArray = [];
const userSilencedArray = [];
const userQuarantineArray = [];
const userAssholesArray = [];
const userAssholesMsgRepCount = [];
const wasAdded = [false];
const newFollowers = [];
const modsArray = [];
//const helpCommands = [{command:"",name:"",description:""}];
var allowedFemalesArray = [];

//Set in putInArray function
var putInArrayElementAlreadyExisted = 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;

//***************************************************************************************
//******************  MOTIVATIONAL MESSAGE VARIABLES ************************************
//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;

//***************************************************************************************
//******************  MESSAGE Q VARIABLES ***********************************************
//Hold the list of messages that need to be published to the chatroom and establish
  //a first message to initialize the array and allow for new elements
const msgQ = [{msg:'init',showtime:false,reqBy:'',copyLarry:false}];

//Reference if there is a timer currently running for printing the next message
var isMsgQ_TimerActive = false;

//Interval in Milliseconds for sending the next message from msgQ
  //125 seemed too short messages not in order so trying 250
var msgQInterval = 250;

//How many characters wide should messages be when printing horizontal?
var msgWidth = 512;

//***************************************************************************************
//******************  COLOR CODE VARIABLES **********************************************
//Color Codes
var colorCodeDarkPink = '#DA1DBE';
var colorCodeWhite = '#FFFFFF';
var colorCodeBlack = '#000000';
var colorCodeAqua = '#52FFFF';
var colorCodePink = '#FFBDDE';
var colorCodeHotPink = '#FF1A8C';
var colorCodeLightPurple = '#FF24FF';
var colorCodeRed = '#FF0000';
var colorCodeDarkGreen = '#008000';
var colorCodeLightGreen = '#00FF00';
var colorCodeOffWhite = '#E8E8E8';
var colorCodeLightGray = '#D4D4D4';
var colorCodeChloePurple = '#DA1DBE';

//Colors for Chat Notices
var colorCodeForeground = colorCodeChloePurple;
var colorCodeBackground = colorCodeOffWhite;

//Colors for New-Follower Notifications
var newFollowerMsgBackground = colorCodeDarkGreen;
var newFollowerMsgForeground = colorCodeWhite;

//Colors for Admin-Messages
var modMsgForeground = colorCodeRed;
var modMsgBackground = colorCodeLightGray;

//Colors for Motivation-Messages
var motvMsgBackground = colorCodePink;
var motvMsgForeground = colorCodeLightGreen;

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

//***************************************************************************************
//*************  HELP FUNCTIONS *********************************************************

//***************************************************************************************
//******************  SET HELP COMMAND INFO 8.1.5 ***************************************
//Populate the array that displays help messages

const helpCommands = [
  {command:"sss",name:"Silence",useby:botAdminBasic
    ,description:"Prevent a user from being able to type any"
      + " messages for the duration of the session."},        
  {command:"fff",name:"Show Followers",useby:botAdminEveryone
    ,description:"Print into the public chat the current value of the Broadcasters"
      + " followers."},
  {command:"aaa",name:"Asshole User",useby:botAdminSuper
    ,description:"Assign a user to Asshole status which will replace anything the user"
      + " types with the Asshole-Substitution-Text you specified at the start of the"
      + " bot session.  Your current Asshole-Substitution-Text is: "
      + "[" + assholeSubText + "]"},
  {command:"shnf",name:"Show New Followers List",useby:botAdminSuper
    ,description:"Print into the public chat a list of the usernames that have"
      + " followed the Broadcaster during this session."}
  ]

//***************************************************************************************
//******************  PRINT HELP ********************************************************
function printHelp(reqBy,userBotAdminLevel,umsg,umsg3){
//Output to the requestor all of the functions

  sendDebugMsg("In printHelp and"
    + " reqBy = ["+reqBy+"]"
    + " userBotAdminLevel = ["+userBotAdminLevel+"]"
    + " umsg = ["+umsg+"]"
    + " umsg3 = ["+umsg3+"]"
  );    

  for (let i = 0; i<helpCommands.length; i++) {
    
    if (userBotAdminLevel <= helpCommands[i]["useby"]) {

      sendNotice("Command ["+helpCommands[i]["command"]+"]"
          + " " + helpCommands[i]["name"] + ": " 
          + helpCommands[i]["description"]
        ,reqBy
      );
    } 
  }
}

//***************************************************************************************
//*************  UTILITY FUNCTIONS ******************************************************
//***************************************************************************************
//******************  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

//***************************************************************************************
//******************  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

//*************************************************************************
//******************  BOT ADMIN LEVEL *************************************
function botAdminLevel(uname,isMod = false) {
//Determine Bot-Admin privileges level 0 to ?

  //Level 1 = Broadcaster level privileges
  //Level 2 = Super-Admin privileges
  //Level 3 = Basic-Admin privileges
  //Level 4 = no privileges
  
  var modIndex = -1;

  if (uname != bname && uname != 'lucky_larry' && isMod == false) {
    popOutOfArray(modsArray,uname);
    return botAdminEveryone;
  } else if (uname == bname || uname == 'lucky_larry') {
    return botAdminBC;
  } else {
    modIndex = putInArray(modsArray,uname);
    return botAdminBasic;
  }
  
  //Write code here to determine if the user is a Bot-Admin
  
}

//***************************************************************************************
//*************  MESSAGING FUNCTIONS ****************************************************

//***************************************************************************************
//******************  SEND NEXT MESSAGE FROM QUEUE **************************************
function sendMsgFromQ() {
//This is called by the Message Queue Timer function.
//Only sends broadcaster messages

  let currTime = new Date();
  
  //Set index for the length of the array - 1 to get the last element
  let msgs = msgQ.length - 1;
  
  //sendDebugMsg(
    //'START IN sendMsgFromQ now is [' + currTime.toTimeString() + ']'
      //+ ' and msgQ.length = [' + msgs + 1 + ']');

  if (msgs <= 1) {
    //sendDebugMsg('Exiting sendMsgFromQ Early because msgQ.length <= 1');
    isMsgQ_TimerActive = false;
    return;
  }

  //Get the next message in the Queue and send it
  //cb.sendNotice(msgQ[0],'','white','black',msgBCWeight);
  sendBroadcasterMsgFromQ( 
    msgQ[msgs]["msg"],
    msgQ[msgs]["showTime"],
    msgQ[msgs]["reqBy"],
    msgQ[msgs]["copyLarry"]
  );

  //Remove that index from msgQ
  //msgQ.splice(msgs,1);
  msgQ.pop(msgs);

  //If there are more elements in msgQ then invoke next msgQ timer
  if ( msgQ.length > 1 ) {
  
    //sendDebugMsg(
      //'ENDING sendMsgFromQ about to call setTimeout again and msgQ.length = [' + msgQ.length + ']');
  
    isMsgQ_TimerActive = true;
      
    cb.setTimeout(sendMsgFromQ, msgQInterval);

  }
}

//***************************************************************************************
//******************  SEND BROADCASTER MESSAGE ******************************************
function sendBroadcasterMsg(msgForBroadcaster,showTime = false,reqBy = 'BC',copyLarry = true) {
//Add message to the msgQ and if there is then only one element in the queue call the 
  //sendMsgFromQ function to send it out.  Otherwise it can be assumed the msgQ timer
  //is already active.
  
  //sendDebugMsg(
    //'START IN sendBroadcasterMsg and msgQ.length = ['+ msgQ.length +']');
  
  msgToAdd = {msg:msgForBroadcaster,showTime:showTime,reqBy:reqBy,copyLarry:copyLarry}
  
  //sendDebugMsg(
    //'IN SendBroadcasterMsg and msgQ.length = ['+ msgQ.length +'] and Sending message [' + msgToAdd.msg + ']');
  
  //sendDebugMsg(
    //'IN sendBroadcasterMsg and msgQ.length = ['+ msgQ.length +']'
      //+ ' and msgToAdd-msg = [' + msgToAdd["msg"] + ']'
      //+ ' and isMsgQ_TimerActive = [' + isMsgQ_TimerActive + ']');
  
  //putInArray(msgQ,msgElement[0]);
  
  msgQ.push(msgToAdd);
  
  if ( ( msgQ.length == 2 && isMsgQ_TimerActive == false )
        || ( msgQ.length > 2 && isMsgQ_TimerActive == false ) ) {
    
    //sendDebugMsg('msgQ Array length was [' + msgQ.length + ']'
      //+ ' and msgQ.length was [' + msgQ.length + ']'
      //+ ' now Calling sendMsgFromQ');  
    
    sendMsgFromQ(); 
  
  } 
  
  //sendDebugMsg(
    //'EXITING sendBroadcasterMsg and msgQ.length = ['+ msgQ.length +']');

}


//***************************************************************************************
//******************  SEND BROADCASTER MESSAGE FROM QUEUE *******************************
function sendBroadcasterMsgFromQ(msgForBroadcaster,showTime = false,reqBy = 'BC',copyLarry = true) {
//Send a message to broadcaster & bot-admins only

  //Preface message so they know its not public to whole chat room
  let message = 'Admn-Msg:  ' + msgForBroadcaster;
  if (showTime == true) {message = getCurrentTime() + ' ' + message;}
  
  if (reqBy == 'BC' || reqBy == bname) {
    cb.sendNotice(message,bname,modMsgBackground,modMsgForeground,msgBCWeight);
  }
  
  if (bname != 'lucky_larry' 
      && (copyLarry == true || reqBy == 'lucky_larry')
    ) {
    cb.sendNotice(message,'lucky_larry',modMsgBackground,modMsgForeground,msgBCWeight);
  }
}  //End sendBroadcasterMsg


//***************************************************************************************
//******************  SEND NOTICE aka SEND ROOM MESSAGE *********************************
function sendNotice(msgToSend,toUser = '',showTime = false,
  bkg = colorCodeBackground,foreg = colorCodeForeground) {
//Send a message to chatroom with formatting options

  if (showTime == true) {msgToSend = getCurrentTime() + ' ' + msgToSend;}
  
  cb.sendNotice(msgToSend, toUser, bkg, foreg, msgBCWeight);

} //End sendRoomNotice

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

  if (debugMode == false) {
    return;
  } else {
    //Set to empty string for reqBy so only Lucky_Larry sees these.
    sendBroadcasterMsgFromQ('DEBUG: ' + msgForBroadcaster,showTime,'',copyLarry);
  }

}  //End sendDebugMessage

//***************************************************************************************
//*************  ARRAY HANDLING SECTION *************************************************

//***************************************************************************************
//******************  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'
  ,elementTitle = 'Processing array element'
  ,startIndex = 0
  ,includeElementLength = false
  ,outputHorizontal = true) {
// Send a message to broadcaster for each element in the Array starting at the index
  // indicated with the startIndex parameter.  Added startIndex parameter for calls to
  // arrays where there is an intentional zeroth element created as a placeholder
  // to make the arrays one-based for the data population.
// Returns the number of elements in the requested array
  
  var debugThis = true;
  
  if (debugThis == true) {sendDebugMsg("Start outputArray and"
    + " elementTitle = ["+elementTitle+"]"
    + " x.length = ["+x.length+"]"
    + " outputHorizontal = ["+outputHorizontal+"]" 
  )}
  
  //If there are no elements to output ... Write a notice to that effect
  if (x.length == 0 || x.length - startIndex == 0) {
    sendBroadcasterMsg('There were no elements available to show in the requested list.');
    return 0;
  }
  
  var thisElement = '';
  var sendQueue = '';
  var joinChars = " || ";
  
  for (let i = startIndex; i<x.length; i++) {
    
    thisElement = elementTitle + ' [' + i + '] which has a value of [' + x[i] + ']';
    
    if (includeElementLength == true) {
      thisElement = thisElement + 'and length of [' + x[i].length + ']';
    }
    
    if (debugThis == true) {
      sendDebugMsg("In outputArray and i = ["+i+"]"
        + " processing = ["+x[i]+"]"
        + " length of thisElement = ["+thisElement.length+"]"
        + " length of sendQueue = ["+sendQueue.length+"]"
    )}
      
    if (outputHorizontal == true && thisElement.length <= msgWidth) {    
      //Continue to build the string to output if its shorter than msgWidth
      
      //Check if the string already queued length plus the new string length will be longer
        //than msgWidth.
      if (thisElement.length + sendQueue.length >= msgWidth) {
        
        //If the length of the current value of sendQueue plus the length of the new element
          //will be longer than msgWidth then output what is already queued 
          //and set the queue empty because it will be set to itself + thisElement next
        if (sendQueue.endsWith(joinChars) == true) {
          sendQueue = sendQueue.substr(0,sendQueue.length - joinChars.length);
        }
        
        if (debugThis == true) {
          sendDebugMsg("Sending sendQueue with length ["+sendQueue.length+"]"
        );}
        
        sendBroadcasterMsg(sendQueue,false,reqBy);
        sendQueue = emptyString;
      }
      
      //Increment the sendQueue with the current element
      sendQueue = sendQueue + thisElement + joinChars;
      
    } else if (thisElement.length > msgWidth) {      
      //If current element exceeds the msgWidth then output the sendQueue
        //then output the current element by itself
      
      if (debugThis == true) {
        sendDebugMsg("Sending sendQueue with length ["+sendQueue.length+"]"
          + " and then thisElement with length ["+thisElement.length+"]"
      );}
  
      if (sendQueue.endsWith(joinChars) == true) {
        sendQueue = sendQueue.substr(0,sendQueue.length - joinChars.length);
      }
      
      sendBroadcasterMsg(sendQueue,fase,reqBy);
      sendBroadcasterMsg(thisElement,false,reqBy);
      
    } else {
      
      //Do Nothing here.  Should not reach this point
      sendDebugMsg("Reached improbable else in outputArray and i = ["+i+"]"
        + " processing = ["+x[i]+"]"
        + " length of thisElement = ["+thisElement.length+"]"
        + " length of sendQueue = ["+sendQueue.length+"]");
      
    }
  }
  
  //If anything in sendQueue then output it
  if (sendQueue.length > 0) {
    
    if (sendQueue.endsWith(joinChars) == true) {
      sendQueue = sendQueue.substr(0,sendQueue.length - joinChars.length);
    }
    
    sendBroadcasterMsg(sendQueue,false,reqBy);
  
  }
  
  return x.length;
  
}  //End outputArray

//***************************************************************************************
//******************  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

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

  var indexElement = userArray.indexOf(newUser);
  var debugThis = true;
  
  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
  
  //Initialize Global Variable that will be set true if the 
    //element to-be-added already existed.
  putinArrayElementAlreadyExisted = false;
  
  var indexElement = arrayToPutInto.indexOf(elementToPut);

  //Control availability of debug messages for just this section only
  var 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 + '] ');}
    
    putInArrayElementAlreadyExisted = true;
        
    return indexElement;
    
  } else {
    
    var 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;

  }  //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

//**********************************************************************************
//******************  MOTIVATION MESSAGES SECTION **********************************
//***************************************************************************************
//******************  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
cb.settings_choices = [
    {name:'botversion', type:'choice', choice1: botVersion, defaultValue: botVersion,
      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:'totalFollowersGoal', type:'int', minValue:0, maxValue:999999999, defaultValue:0,
        label: 'What is your next Total Followers Goal?  Leave at zero to not use this feature.'},
    {name:'newFollowersGoal', type:'int', minValue:0, maxValue:999999999, defaultValue:0,
        label: 'What is your New-Followers Goal for this show?'
          + '  Leave at zero to not use this feature.'},
    {name:'doShowNewFollowNotifications', type:'choice', 
        choice1: 'Yes - Notify', choice2: 'No - Do Not Notify',
        defaultValue:'Yes - Notify',
        label: 'Would you like Luckys Bot to notify you when someone follows you?'},
    {name:'doNotifyBCPurpleFollow', type:'choice',
        choice1:'0-Do Not Notify', choice2:'1-Notify if Light Purple or higher',
        choice3:'2-Notify if Dark Purple or higher',
        defaultValue: '2-Notify if Dark Purple or higher',
        label: 'Regardless of previous setting to show Follower notifications Luckys bot can also'
          + ' send you a private message if the new follower is of a certain color level.'
          + '  So you can give your light or dark Purple followers a little extra attention.'},
    {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:'approvedFemalesList', type:'str', minLength:0,maxLength:512, required:false,
      defaultvalue:'',label:"Put usernames of females that are allowed to chat in your room"
        + " here separated by commas."},
    {name:'showQuarantineUserEntryNotice', type:'choice', choice1:'Show', choice2:'Hide',
      defaultValue: 'Show',
      label: 'Luckys Bot can display a private notification to you and your Bot-Admins for'
        + ' females that will be Quarantined along with their Index number so you can easily'
        + ' silence or give them full chat privilege.  Do you want to Show or Hide these'
        + ' Notifications?'},
    {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 Reminder Messages feature?  '
        + 'These are messages that only the Broadcaster and Optionally the '
        + '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', required:false,
      minLength:1,maxLength:255,
      defaultValue:"YOU ARE GODDESS!  MAY THEY HEAR YOU ROAR!!", 
      label: "Motivational Money or Helper Message 1"},
    {name:'motvMsg2', type:'str', required:false,
      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', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"DO YOU NEED WATER?", 
      label: "Motivational Money or Helper Message 3"},
    {name:'motvMsg4', type:'str', required:false,
      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', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"HAVE YOU THANKED EVERYONE FOR VISITING YOU LATELY?", 
      label: "Motivational Money or Helper Message 5"},
    {name:'motvMsg6', type:'str', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"PLAY WITH BUBBLES??", 
      label: "Motivational Money or Helper Message 6"},
    {name:'motvMsg7', type:'str', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"HULA??", 
      label: "Motivational Money or Helper Message 7"},
    {name:'motvMsg8', type:'str', required:false,
      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', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"SHOUT OUT CLIP STORES & LINK!", 
      label: "Motivational Money or Helper Message 9"},
    {name:'motvMsg10', type:'str', required:false,
      minLength:1,maxLength:255, 
      defaultValue:"WHAT CAN YOU DO RIGHT NOW TO ENGAGE MORE WITH YOUR GUYS??", 
      label: "Motivational Money or Helper Message 10"},
//Commenting Message-timer Interval setting since default value is not working but really
  //this is not something the Broadcaster ever will need to adjust.  
//    {name:'msgTimerInterval', type:'str',
//        minlength:1,maxlength:4,defaultValue: '150',
//        label: "Message Queue Interval for bot messages:"},
    {name:'colorSettingsHelperMessage', type:'choice', defaultValue: 'Colors!!',
          choice1: 'Colors!!',
          label: "This section is for you to pick Color Choices for various types of"
            + " messages.  Not sure what color code you want?"
            + "  Look at site htmlcolorcodes.com to find colors codes you LOVE!!"},
    {name:'motvMsgBackground', type:'str', defaultValue: motvMsgBackground,
      label: "Enter a Hex-Color-Code for background-shading of Motivation & Reminder Messages."},
    {name:'motvMsgForeground', type:'str', defaultValue: motvMsgForeground,
      label: "Enter a Hex-Color-Code for Text-Color of Motivation & Reminder Messages."},            
    {name:'modMsgBackground', type:'str', defaultValue: modMsgBackground,
      label: "Enter a Hex-Color-Code for background-shading of Admin-Only-Messages."},
    {name:'modMsgForeground', type:'str', defaultValue: modMsgForeground,
      label: "Enter a Hex-Color-Code for Text-Color of Admin-Only-Messages"},
    {name:'msgColorBackground', type:'str', defaultValue: colorCodeBackground,
      label: "Enter a Hex-Color-Code for background-shading of Room-Messages."},
    {name:'msgColorForeground', type:'str', defaultValue: colorCodeForeground,
      label: "Enter a Hex-Color-Code for Text-Color of Room-Messages"},
    {name:'followMsgColorBackground', type:'str'
      , defaultValue: newFollowerMsgBackground
      , label: "Enter a Hex-Color-Code for background-shading of New-Follower-Messages."},
    {name:'followMsgColorForeground', type:'str'
      , defaultValue: newFollowerMsgForeground
      , label: "Enter a Hex-Color-Code for Text-Color of New-Follower-Messages"},
    {name:'msgWidth', type:'int', minValue:64, maxValue:4096
      , defaultValue: msgWidth
      , label: "How many characters wide should messages be for outputting lists in horizontal"
          + " format before the next message begins?"}, 
//Commenting the Debug Mode toggle in Bot-Start-Settings Page
    {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();

    //Sort the Help Commands Array to be sure when printed they come in alphabetical order
    helpCommands.sort();
    
    //Set if Debug Mode on
    debugMode = (cb.settings.debugMode == 'Debug On');
    
    //Note to Broadcaster if Debug Mode is on.  This message will not show if
      //debug mode is not on
    sendDebugMsg('DEBUG Mode is ON so expect more messages for troubleshooting the bot');
    
    //Set timer interval << This property will go away in live version this is to ease testing
    //msgQInterval = (cb.settings.msgTimerInterval);
    
    //sendBroadcasterMsg('Message Queue Interval is set to ['+msgQInterval+']');
    
    //Store the Broadcaster's preferences for new follower notifications
    doShowNewFollowNotifications = cb.settings.doShowNewFollowNotifications;
    
    //Get the purple level the broadcaster wants to get follow-notices for
    doNotifyBCPurpleFollow = cb.settings.doNotifyBCPurpleFollow;
    
    //Set the Motivational and Reminder messages colors
    motvMsgBackground = cb.settings.motvMsgBackground;
    motvMsgForeground = cb.settings.motvMsgForeground;
    
    //Set the Admin-Message colors
    modMsgBackground = cb.settings.modMsgBackground;
    modMsgForeground = cb.settings.modMsgForeground;
    
    //Set the Message-Character-Width
    msgWidth = cb.settings.msgWidth;
    
    //Set the message colors
    colorCodeBackground = cb.settings.msgColorBackground;
    colorCodeForeground = cb.settings.msgColorForeground;

    //Set the New Follower message colors
    newFollowerMsgBackground = cb.settings.followMsgColorBackground;
    newFollowerMsgForeground = cb.settings.followMsgColorForeground;
      
    sendNotice(bname + ' started bot Luckys_User_Filter_Flexible!'
        + ' Version ' + botVersion + ' At time [' + startTime + ']');
    
    //Store Broadcaster's Notice Name that was set
    bNoticeName = cb.settings.broadcasterNameInNotices;
    
    //Populate the approvedFemales array
    allowedFemalesArray = cb.settings.approvedFemalesList.split(',');
        
    //Store setting to show blocked messages
    showBlkdMsgs = cb.settings.showBlkdMsgs;
    
    //Notes if Broadcaster wants quarantined users entry notices to show
    showQuarantineUserEntryNotice = cb.settings.showQuarantineUserEntryNotice;

    //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';
    newFollowers[0] = 'New Followers Placeholder of Index 0';
    
    //Initialize the follower goal variables with bot-setup information
    totalFollowersGoal = cb.settings.totalFollowersGoal;
    newFollowersGoal = cb.settings.newFollowersGoal;
    
    //Send Follower Count to room
    sendFollowerCount();
    
    //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

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

  var usr = user['user'];
  var 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'] + ']'
    + ' || is_mod = [' + user['is_mod'] + ']'
    ,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'],user['is_mod']);
    
  } //End if user = bname (Broadcaster)
});

//*******************************************************************************
//*************  FOLLOWERS FUNCTIONS ********************************************

//*******************************************************************************
//******************  GAINED_FOLLOWERS ******************************************
function gainedFollowers() {
//Subtract the startFollowers from the nowFollowers and return the result
try {
  return nowFollowers - startFollowers;
} catch(err) {
  sendBroadcasterMessage('ERROR In function gained_followers: ' + err.message);
  return -1;
}
}

//*************************************************************************
//******************  SEND_FOLLOWER_COUNT *********************************
function sendFollowerCount(doSendMsg = true,sendToUser = '') {
  //This function is intended to create a notice in the chatroom indicating 
    //the current number of followers and pass back that value as well.
    //Parameter doSendMsg is used to turn off the notice if all the calling
    //function wanted to do was retrieve the current number of followers.
  
try {  
  
  //Toggle debug Messages for this section when overall debug active
  var debugMsgsHere = true;
  
  cb.getRoomOwnerData(ownerData => {
    
    if (debugMsgsHere == true ) { 
      sendDebugMsg(
        'START sendFollowerCount inside cb.getRoomOwnerData'
          + ' and ownerData[success] = [' + ownerData['success'] + ']'
          + ' and sendToUser = ['+sendToUser+']'
      );
    }  //End if debugMsgsHere
        
    if ( ownerData['success'] == true ) {
    
        if (debugMsgsHere == true ) { 
          sendDebugMsg('IN sendFollowerCount and inside the if ownerData[success] conditional');
        }  //End if debugMsg
        
        nowFollowers = ownerData['data']['followers'];
    
        //If startFollowers variable = -1 it needs to be set.  This should happen during
          //bot-startup   
        if ( startFollowers == -1 ) {startFollowers = nowFollowers;}

        if (debugMsgsHere == true ) {
          sendDebugMsg('IN sendFollowerCount'
            + ' and nowFollowers = ['+ nowFollowers +']'
            + ' and typeof nowFollowers = [' + typeof(nowFollowers) + ']'
            + ' and startFollowers now = [' + startFollowers + ']'
            + ' and gainedFollowers = [' + gainedFollowers() + ']'
            + ' and doSendMsg = [' + doSendMsg + ']');
        }  //end if debugMsgsHere
        
        //Output the follower notice if doSendMsg passed in as true
        if ( doSendMsg == true ) {
          sendNotice(bname + ' has ' + nowFollowers + ' followers!'
              + ' There were [' + startFollowers + '] followers at the start of this session'
              + ' which is a gain of [' + gainedFollowers() + ']'
            ,sendToUser
          );
        }  //end if debugMsgsHere
        
        //WHY Are we populating this?
        chatAllowedBy = ownerData['data']['chat_allowed_by'];
        
        if (debugMsgsHere == true ) {
          sendDebugMsg('IN sendFollowerCount about to exit by return nowFollowers'
            + ' which has a value of [' + nowFollowers + ']');
        }  //end if debugMsgsHere
        
    } else {
    
      cb.chatNotice('Follower count for ' + bname + ' was not able to be retrieved.');
    
    }
  });
  
  return nowFollowers;

} catch(err) {

  sendDebugMsg('IN sendFollowerCount error thrown [' + err.message + ']');

}

}  //End function SendFollowerCount

//*************************************************************************
//******************  ON_UN_FOLLOW *******************************************
cb.onUnFollow(user => {
  //popOutOfArray(newFollowers,user['user']);
});

//*************************************************************************
//******************  ON_FOLLOW *******************************************
cb.onFollow(user => {

  //Put the new follower in the newFollowers array and populate 
    //putInArrayElementAlreadyExisted variable to note
    //if there was already an entry for this new follower
  putInArray(newFollowers,user['user']);
  
  sendDebugMsg('IN onFollow #1a after call to putInArray'
    + ' and putInArrayElementAlreadyExisted = [' + putInArrayElementAlreadyExisted +']'
    + ' and startFollowers = ['+startFollowers+']'
    + ' and nowFollowers = ['+nowFollowers+']'
    + ' and newFollowersGoal = ['+newFollowersGoal+']'
    + ' and totalFollowersGoal = ['+totalFollowersGoal+']'
    + ' and doShowNewFollowNotifications = ['+doShowNewFollowNotifications+']'
    );

  sendDebugMsg('IN onFollow #1b after call to putInArray'
    + ' and doNotifyBCPurpleFollow = [' + doNotifyBCPurpleFollow +']'
    + ' and user[tipped_alot_recently] = ['+user['tipped_alot_recently']+']'
    + ' and user[tipped_tons_recently] = ['+user['tipped_tons_recently']+']'
//    + ' and newFollowersGoal = ['+newFollowersGoal+']'
//    + ' and totalFollowersGoal = ['+totalFollowersGoal+']'
//    + ' and doShowNewFollowNotifications = ['+doShowNewFollowNotifications+']'
    );
  
  //Check if there was already an entry for this new follower
  if ( putInArrayElementAlreadyExisted == true ) {
  
    sendDebugMsg('IN onFollow #2a putInArrayElementAlreadyExisted was true so'
      + ' now exiting onFollow with no further message.');
  
    putInArrayElementAlreadyExisted = false;
  
    //Exit function with no message
    return;
  }
  
  //Increment nowFollowers variable to account for new follower.  This could become inaccurate
    //if someone unfollows or if a cb.onFollowUser call gets missed or malfunctions but an
    //inaccuracy here will be of negligible consequence.  We will also eventually program
    //a timeout function to periodically run the full function to get accurate current 
    //followers count.
  nowFollowers++;
  
    //Notify chatroom of the new follower.
    var newFollowNotice = ('Thank you ' + user['user'] + ' for Following me!!  '
      //+ '  There have been ' + gainedFollowers() + ' New Followers during this session.'
      //+ '  Thank you so much for the love!!  '
      );
        
  sendDebugMsg('IN onFollow #2b newFollowNotice = ['+newFollowNotice+']');

  //If there is a Total-Followers goal active add a blurb stating how many more followers to go
    //to meet the goal!
  if (totalFollowersGoal > 0) {
    
    newFollowNotice = newFollowNotice + (totalFollowersGoal - nowFollowers) 
      + ' New Followers needed now to Goal of ' + totalFollowersGoal + '!';
  }
  
  sendDebugMsg('IN onFollow #3 newFollowNotice = ['+newFollowNotice+']');  
  
  //If there is a New-Followers-Count goal active add a blurb stating how many more followers to go
    //to meet the goal
  if (newFollowersGoal > 0 && totalFollowersGoal > 0) {
    
    newFollowNotice = newFollowNotice
      + ' AND we need ' + (newFollowersGoal - gainedFollowers()) + ' New Followers'
      + ' to reach my New-Followers goal of ' + newFollowersGoal + '!';
      
  } else if (newFollowersGoal > 0 && totalFollowersGoal == 0) {
    
    newFollowNotice = newFollowNotice
      + 'Need ' + (newFollowersGoal - gainedFollowers()) + ' New Followers'
      + ' to reach my New-Followers goal of ' + newFollowersGoal + '!';  
  }
  
  sendDebugMsg('IN onFollow #4 newFollowNotice = ['+newFollowNotice+']');

//Just a note to remind myself of parameters of sendNotice
//function sendNotice(msgToSend,toUser = '',showTime = false,
  //bkg = colorCodeBackground,foreg = colorCodeForeground) 
    
  if ( doShowNewFollowNotifications.startsWith('Yes') == true ) {
    sendNotice(newFollowNotice,'',false
      ,newFollowerMsgBackground,newFollowerMsgForeground);
  }
  
  if ( doNotifyBCPurpleFollow.startsWith('0') == true ) {return;}
  
  if ( (doNotifyBCPurpleFollow.startsWith('1') == true
         && (user.tipped_alot_recently == true || user.tipped_tons_recently == true )
        ) || (doNotifyBCPurpleFollow.startsWith('2') == true
              && user.tipped_tons_recently == true)
        ) {
    sendBroadcasterMsg('New Follower ' + user['user'] 
      + ' is Purple!  Thank them extra for Following You!');
    
  }
  
});  //End onFollow

//*******************************************************************************
//*************  USER HANDLING FUNCTIONS ****************************************

//*************************************************************************
//******************  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

//**********************************************************************************
//******************  HANDLE FEMALE VIEWERS ON ENTER *******************************
function handleFemViewersOnEnter(usr,isUserGrey,userIndex,isMod = false) {
//Handle females and Prompt Broadcaster in accordance with Broadcaster Preferences
  
  //If the user is a Moderator skip this function
  if (isMod == true) {
    return;
  
  //See if the female is in the approved list
  } else if (allowedFemalesArray.indexOf(usr) > -1) {
    return;
  }
  
  //Initialize variables that will accumulate what to do    
  var doSilence = false;
  var doQuarantine = false;
  var 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 && showQuarantineUserEntryNotice == 'Show') {
        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,isMod = false) {
//Auto-Silence or Quarantine users as appropriate

    var sendDebug = true;
    
    if (sendDebug == true) {
      sendDebugMsg('In addUserToArrays and'
        + ' usr = ['+usr+']'
        + ' || isUserGrey = ['+isUserGrey+']'
        + ' || gender = ['+gender+']'
        + ' || isMod = ['+isMod+']'
    );}
    
    //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.
      //Returns the index number for the user
    userIndex = addToUserArray(usr);
    
    //Add to Mods array if applicable
    if (isMod == true) {
      putInArray(modsArray,usr);
    } else {
      //In case user was un-modded and was in mods array
      popOutOfArray(modsArray,usr);
    }
    
    //Debug message
    if (sendDebug == true) {
      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' && isMod == false) {
      handleFemViewersOnEnter(usr,isUserGrey,userIndex);
    }
}  //End addUserToArrays

//*******************************************************************************
//******************  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('To Lucky_Larry Only:'
          + '  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

//*************************************************************************
//******************  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);
  
  var userToSilence = '';
  
  if (isNaN(umsg3) == true) {  
    userToSilence = umsg3;  
  } else {
    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

  var userIndex = userArray.indexOf(umsg3);
        
  sendDebugMsg('Start unSilenceUser and'
      + ' umsg = [' + umsg + '] and'
      + ' umsg3 = ['+umsg3+']'
      + ' userIndex = ['+userIndex+']'
//      + ' userUnsilence value = [' + userUnsilence + '].'
//      + ' and typeof(userUnsilence) is ['+typeof(userUnsilence)+']'
    ,false,uname);
    
  //This will be true if a valid username was passed in umsg3  
  if (userIndex > 0) {

    var userSilenceIndex = userSilencedArray.indexOf(umsg3);
    var userQuarantineIndex = userQuarantineArray.indexOf(umsg3);
    
    if (userSilenceIndex > 0) {
      //Remove the element from the Silenced array
      userSilencedArray.pop(userSilenceIndex);
               
      //Pass confirmation message to broadcaster & bot-admin
      sendBroadcasterMsg(umsg3 + ' has been Un-Silenced.');
    
    } else if (userQuarantineIndex > 0) {
      //Remove the element from the Silenced array
      userQuarantineArray.pop(userSilenceIndex);
               
      //Pass confirmation message to broadcaster & bot-admin
      sendBroadcasterMsg(umsg3 + ' has been Un-Quarantined.');
    
    } else {
    
      //Return information that the user was valid but was
        //neither Silenced nor Quarantined.
      sendBroadcasterMsg('User ' + umsg3 + ' was neither Silenced nor Quarantined.'
        ,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 USER INFO *************************************
function printUserInfo(umsg,uname) {
//Print user information into the chat for Broadcaster and Bot-Admins
//Usually invoked by command usrinfo followed by a username

try {
    const unames = umsg.split(' ');
      
    //Was just debug message
    sendDebugMsg('In usrinfo block and umsg = ['+umsg+']'
        + ' and unames.length = ' + unames.length);
      
    if (unames.length > 1) {
    
      //Search userArray for the last portion of the passed in message
      userIndex = userArray.indexOf(unames[1]);
      
      if (userIndex >= 0) {
        userIndexOutput = userIndex;
      
      } else if (userArray[unames[1]].length > 0) {
        sendBroadcasterMsg('Username for User Index Value ['+unames[1]+']'
            + ' is ['+userArray[unames[1]]+']'
          ,false,uname);
      
      } else {
        userIndexOutput = 'User Not Found';
      
      }  //End if userIndex >= 0
      sendBroadcasterMsg('Index for username ' + unames[1] + ' is ' + userIndexOutput
        ,false,uname);
    
    } else {
      sendBroadcasterMsg('Was not able to find a result for command [' + umsg + ']'
        ,false,uname);
    }  //End if unames.length > 1

} catch(err) {
  sendBroadcasterMsg('Was not able to find a result for command [' + umsg + ']'
    ,false,uname);
}
}  //End function printUserInfo

//*************************************************************************
//******************  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
      var currTime = new Date();
      var duration = currTime - startTime;
      var currFollowers = 0;
      var newFollowers = 0;
      
      currFollowers = sendFollowerCount(false);
      newFollowers = currFollowers - startFollowers;
      
      sendDebugMsg('IN printSessionInfo and'
        + ' sendFollowerCount(false) = ['+ sendFollowerCount(false) + ']'
        + ' currFollowers = [' + currFollowers + ']');

      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 - 1) + ' || '
        + 'Silenced users: ' + (userSilencedArray.length - 1) + ' || '
        + 'Asshole users: ' + (userAssholesArray.length - 1) + ' || '
        + 'Current Followers: ' + currFollowers + ' || '
        + 'New Followers: ' + newFollowers);
        
      sendBroadcasterMsg('MESSAGE INFO:  '
        + 'There have been ' + lastMessagedUsers.length + ' messages sent.  '
        + 'This does not include notices nor Admin command messages '
        + 'nor messages from grey users if grey chat is turned off for the room.');

}  //End function printSessionInfo

//*******************************************************************************
//*************  MESSAGING FUNCTIONS ********************************************

//*************************************************************************
//******************  SET LAST MESSAGED VARIABLES *************************
function setLastMessagedVariables(uname,umsg,isGreyUser = false) {
//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.

/* Commenting this because now that we are maintaining data of all messages for the
  //entire show this no longer would do anything

  //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)];
  }
*/  
    //Do not save grey-user messages in chat log unless greys are allowed to talk here
  if (chatAllowedBy != 'all' && isGreyUser == true) {
    return;
  } else 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,uname) {
//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
  //8.1.4h added uname parameter to suppress display of messages to other admins
  
  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.',false,uname);
    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.',false,uname);}
    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:',false,uname);
  
  //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] + ']'
        ,false,uname);
          //+ 'Past-Msg#' + i
          //+ ' User ' + userStuff[0] + ' & message: [' + userStuff[1] + ']'
        //,false,uname);
    
    }  //End if lastMessagedUsers[i].length > 0
  }  //End for loop
  
}  //End function printMostRecentMessagers

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

  var uname = msg['user'];
  var umsg = msg['m'];
  var umsg3 = myTrim(umsg.replace('@','').substr(3));
  var isUserGrey = !msg['has_tokens'];
  var userBotAdminLevel = botAdminLevel(uname,msg["is_mod"]);
  
  sendDebugMsg('In onMessage Start:  uname = [' + uname + '] and bname = [' + bname + ']'
    + ' and m = [' + msg['m'] + '] and umsg3 = ['+umsg3+']',bname);

        
  //8.1.5 Moving X-Spam true to here since some commands may now be executable by room users
    //and this is set at the bottom with a call to shouldBlockMsg anyways      
  //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;
      
  //8.1.4 Creating function botAdminLevel to determine functions available to user
  //if (uname == bname || uname == 'lucky_larry') {
  //if (botAdminLevel(uname,msg['is_mod']) > 0) {
  if (userBotAdminLevel >= botAdminBC 
      && userBotAdminLevel < botAdminEveryone) {

    //If a bot-admin used the mention feature to drop a users name in there will be an @
      //symbol that is not needed.
    umsg = umsg.replace('@','');

    umsg3 = myTrim(umsg3);

    //Save the first 3 characters into a variable to reduce processing for the many
      //if-statements to follow
    var first3 = umsg.substr(0,3).toLowerCase();

    sendDebugMsg('In onMessage for Bot-Admins:'
      + ' uname = [' + uname + '] and bname = [' + bname + '] '
      + ' and m = [' + msg['m'] + '] and umsg3 = ['+umsg3+']'
      + ' and first3 = ['+first3+']');
  
    //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' || umsg == 'FFF') {
    
      sendFollowerCount();
      
      //****** SSS SILENCE SOMEONE ******      
      //Check for silence code from Broadcaster
    //} else if (umsg.startsWith('sss') == true || umsg.startsWith('SSS') == true) {
    } else if (first3 == 'sss') {  
      
      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) {
    } else if (first3 == 'shh') {
      
      if (umsg == 'shh') {
    
        sendBroadcasterMsg('Printing the full User List:');   
      
        //Implement code to show the user that belongs to a given index
        outputArray(userArray.sort(),uname,"User #",0);

        //Print a message describing what that was if user list was over 20 elements long
        if (userArray.length > 20) {
          sendBroadcasterMsg('This was a print-out of the full User List.');
        }
      
      } 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) {
    } else if (umsg == 'shu') {
    
      outputArray(userSilencedArray,uname,"Silenced User #",1); 
      
      //****** SHQ PRINT QUARANTINED USERS LIST ******
    //} else if (umsg.startsWith('shq') == true && umsg.length == 3) {
    } else if (umsg == 'shq') {
    
      outputArray(userQuarantineArray,uname,"Quarantined User #",1); 
    
      //****** SHA PRINT ASSHOLED USERS LIST ******
    //} else if (umsg.startsWith('sha') == true && umsg.length == 3) {
    } else if (umsg == 'sha') {
        
      sendBroadcasterMsg('Printing the list of Asshole Users:',false,uname);
    
      outputArray(userAssholesArray,uname,"Asshole #",1); 
      
      //****** UUU UNSILENCE USER ******
    //} else if (umsg.startsWith('uuu')){
    } else if (first3 == 'uuu') {

      unSilenceUser(uname,umsg,umsg3);
    
      //****** AAA Add user to asshole list ******
    //} else if (umsg.startsWith('aaa')) {
    } else if (first3 == 'aaa') {
        
      addUserToAssholeList(uname,umsg,umsg3);
      
    //} else if (umsg.startsWith('bbb')) {
    } else if (first3 == '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,uname);
    
    //} else if (umsg.startsWith('rrr') == true || umsg.startsWith('RRR') == true) {
    } else if (first3 == 'rrr') {
        
      printMostRecentMessagers(umsg3,uname);
      
    } else if (umsg.startsWith('debug') == true) {
    
      debugMode = !debugMode;
      
      sendBroadcasterMsg('Debug Mode is now [' + debugMode + ']');
    
    //8.1.2 Output list of new follower names
    } else if (umsg.startsWith('shnf') == true) {
    
      sendBroadcasterMsg('Outputting the new followers list:',false,uname);
      
      outputArray(newFollowers,uname,"New Follower #",1);
    
    } else if (umsg.startsWith('???') == true) {
    
      printHelp(uname,userBotAdminLevel,umsg,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 {
    
    //Check for input of commands that any user can execute
    if (umsg.startsWith('???') == true) {
    
      printHelp(uname,userBotAdminLevel,umsg,umsg3);

      return msg;

    //****** FFF FOLLOWER COUNT ******
    //Check for code to request Follower count
    } else if (umsg == 'fff' || umsg == 'FFF') {
    
      //Send Follower Count but only to the user requesting it
      sendFollowerCount(true,uname);
      
      return msg;
          
    }
    
    //Note the username of the most recent user that sent a message
    setLastMessagedVariables(uname,umsg,isUserGrey);
  
    //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,isUserGrey,msg['gender']);

    }  //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