Chaturbate

Bots Home | Create an App
Sammy's Castle
Author: hello_im_mark
Description Source Code Launch Bot Current Users
/*************************************************************
 **
 ** Title: Sammy's Castle
 ** By: Mark
 ** Version: 1.4.2 November 1st 2021
 ** First Version: May 30th 2021
 ** Description: Chat bot for use by skinnytinyy2 - chaturbate.com/skinnytinyy2/
 ** Thank you to rickrickson, 4science, aety and adbadbubba for their code and/or inspiration.
 **
 *************************************************************/

/*
	
	Features:
		- Sammy's-Castle members can use color and view level commands
		- model and mods can paint users with colors
		- allow mods/broadcaster to change foreground and background colors can use color names or hashcodes
		- Keeps track of all tips
		- Show tip scoreboard (all tips)
		- Announce top X tippers (public)
		- Send tippers lists to self (private)
		- Manage users in groups: Donkeys, Slaves, Princes, Lovers, Husbands, Lords
		- Allow Mods to use commands
		- Special user greetings
		- Greetings for group members
		- Gender Emotes (male, female, couple, trans) or custom icon for special users
		- User timeouts (forever or specified time)
		- Spam blocker, blocks advertisments from grey users
		- Auto timeout for grey that demand, ask for pm, ask to view cam, etc
		- Emote blocker for grey users
		- Select background colors for group users
		- Thank you note for tippers, custom message for certain tip amounts
		- Automatically add user to group for specific tip amounts and send reminder to model to add them in config
		- Flood control to stop timeout users from flooding the room with notices
		- 2 custom notifications with selectable time delay
		- Send public room notice
		- Send notice to all mods
		- Send private notice to broadcaster
		- If used by another model sends exclusive notice to them at startup, also tells each user as they enter
		- Ghost function lets silenced or banned users type through chat notices
    - Tip menu with custom colors, separator and settings
    - Roll the dice game
    - Rotating notifier

 */

/*
 * Setup vars
 */

var botVersion = "1.4.2";
var botDate = "November 1st, 2021";
var lastMessgeTime = 0;
var lastMessageName = "";
var tippers = new Array();
var timeoutMessages = new Array();
var timeoutUsersArray = new Array();
var timeoutReleaseArray = new Array();
var slaveUsersArray = new Array();
var donkeyUsersArray = new Array();
var princeUsersArray = new Array();
var loverUsersArray = new Array();
var husbandUsersArray = new Array();
var lordUsersArray = new Array();
var ghostUsersArray = new Array();
var userColors = new Array();
var specialNames = new Array();
var tempString = "";
var tempNum = 0;
var tempArray = new Array();
var modelName = cb.room_slug;
var msgNotify = "";
var msgPublic = "";
var msgPrivate = "";
var msgModel = "";
var msgMod = "";
var markArrayColorD = "#0C2ED6";
var markArrayColor = markArrayColorD;
var markArrayBackgroundD = "#FFFFFF";
var markArrayBackground = markArrayBackgroundD;
var markArrayTag = 'Slave';
var sammyArrayColorD = "#0C2ED6";
var sammyArrayColor = sammyArrayColorD;
var sammyArrayBackgroundD = "#FFFFFF";
var sammyrrayBackground = sammyArrayBackgroundD;
var sammyArrayTag = 'Princesa';
var groupColor = "#FFFFFF";
var kumpekjekkenArrayColor = "#838181";
//var autoNotice1Text = "";
//var autoNotice2Text = "";
//var autoNotice3Text = "";
//var autoNotice4Text = "";
var botTrigger = "/sammybot";
var botTrigger2 = "/sb";
var timeoutReleaseInterval = 1;

var modCommands = true;
var userGreets = true;
var genderEmotes = true;
var allowGreyEmotes = true;
var unmaskTimeout = false;

// ALT --> var botMsgBg = '#BDDEDC';
var botMsgBg = '#FF00B4';
var botAlertBg = '#D32B2B';
var botNoteBg = '#99FF66';
var botGhostBg = '#EDEDED';
var botMsgText = '#FFF300';

// START VARIABLES FOR TIP MENU

var COLOR = {
	DEFAULT: '#FFF300',
	BACKGROUND: '#FF00B4',
	WARNDARK: '#FFFFFF',
	WARNLIGHT: "#FF0000",
	HELP: "#35454F",
};

var TIPMENU = {
	enable: true,
	size: 30,
	//enable: cb.settings.menu_enable === "Yes",
	onEntry: cb.settings.menuNoticeOnEntry === "Yes",
	short: cb.settings.chatNotice === 'Only display the short notice',
	timer: 0,
	sepChar: "| ",
	full: "",
	part1: "",
	part2: "",
	partToken: 1,
	prices: [],
	backupPrices: [],
	items: [],
	initToken: false,
	txtColor1: "",
	bgColor1: "",
	txtColor2: "",
	bgColor2: "",
	lenght: 0,
	requesters: [],
	request: [],
	sale: false,
	discount: 0,
	noticeView: ["hello_im_mark"],
	noticeViewLength: 2,
	help: "*** The command for the Tip Menu is: /sammybot tipmenu or /sb tipmenu ***",
};

// END VARIABLES FOR TIP MENU

// START VARIABLES FOR ROLL THE DICE GAME

var rollprice = parseInt(cb.settings.tokens);
var prizeCount = 13;
var equalOdds = cb.settings.equal_odds == 'Yes';
var numberOfDie = equalOdds?1:2;
var die = [
	{
		die: 1,
		label: "One",
		sides: Math.floor((equalOdds? ((cb.settings.last_prize_rare == 'Yes')?prizeCount-1:prizeCount) : ((cb.settings.last_prize_rare == 'Yes')?prizeCount:prizeCount+1)/2))
	},
	{
		die: 2,
		label: "Two",
		sides: Math.ceil((equalOdds? ((cb.settings.last_prize_rare == 'Yes')?prizeCount-1:prizeCount) : ((cb.settings.last_prize_rare == 'Yes')?prizeCount:prizeCount+1)/2))
	}
];
var perfectMults = cb.settings.perfect_multi == 'Yes';
var maxRollsPerTip = parseInt(cb.settings.max_rolls_at_once);
var usingRares = cb.settings.last_prize_rare == 'Yes';
var minRollsForRare = parseInt(cb.settings.minimum_rolls);

var rareChance = 1;

//var message = msg.m.split(" ");

// END VARIABLES FOR ROLL THE DICE GAME

// START VARIABLES FOR THE ROTATING NOTIFIER

var irotating = 0;
var MAXITEMS = 10;

// END VARIABLES FOR THE ROTATING NOTIFIER

// var sendEmailMsg = 'If you didn\'t send your email address in the tip note, tip 1 token with your email address so your videos can be sent to you!';

// specialNames[0] = new Array('abigailstwart1',':hello88');
// specialNames[1] = new Array('abigailstwart1',':hello88');

timeoutMessages[1]= '[TIMEOUT] You\'re in timeout, other\'s can\'t see what you\'re typing.';
timeoutMessages[2]= '[TIMEOUT] Give it up no one can read what you\'re typing...';
timeoutMessages[3]= '[TIMEOUT] Keep typing no one can read it!';
timeoutMessages[4]= '[TIMEOUT] Why do you keeping typing? No one can see it!';
timeoutMessages[5]= '[TIMEOUT] Can\'t you read? You\'re in timeout, you can\'t type!';	

/*
 * Settings
 */
cb.settings_choices = [
		{		name: 'allowGreyEmotes', 
				type: 'choice', 
				label: 'Allow GREY Graphics?',
        		choice1: 'Yes',
        		choice2: 'No', 
        		defaultValue: 'Yes'
        },
		{		name: 'genderEmotes', 
				type: 'choice', 
				label: 'Show gender of users in chat?',
        		choice1: 'Yes',
        		choice2: 'No', 
        		defaultValue: 'Yes'
        },
//        {		name: 'autoNotice1',
//				label: 'Notification Message 1, use text and emotes',
//				type: 'str',
//				minLength: 0,
//				maxLength: 512,
//				required: false,
//				defaultValue: 'Do you want to be my slave? Or prince? Or lover? Or husband? Or lord? Tip the respective amounts and you can be mine!'
//		},
//		{		name: 'autoNotice1Interval',
//				label: 'Show Notification 1 Every x Minutes',
//				type: 'choice',
//        		choice1: 2,
//        		choice2: 5,
//        		choice3: 8,
//        		choice4: 10,
//        		choice5: 12,				
//				choice6: 15,
//				choice7: 20,
//				choice8: 25,
//				choice9: 30,
//				choice10: 45,
//				choice11: 60,
//        		defaultValue: 25
//		},
//        {		name: 'autoNotice2',
//				label: 'Notification Message 2, use text and emotes',
//				type: 'str',
//				minLength: 0,
//				maxLength: 512,
//				required: false,
//				defaultValue: 'Welcome to my room, don\'t forget to follow!'
//		},
//		{		name: 'autoNotice2Interval',
//				label: 'Show Notification 2 Every x Minutes',
//				type: 'choice',
//        		choice1: 2,
//        		choice2: 5,
//        		choice3: 8,
//        		choice4: 10,
//        		choice5: 12,				
//				choice6: 15,
//				choice7: 20,
//				choice8: 25,
//				choice9: 30,
//				choice10: 45,
//				choice11: 60,
//        		defaultValue: 8
//    },	
//    {		name: 'autoNotice3',
//    label: 'Notification Message 3, use text and emotes',
//    type: 'str',
//    minLength: 0,
//    maxLength: 512,
//    required: false,
//    defaultValue: 'I now have an Onlyfans-Account: https://onlyfans.com/sammyreu Follow me and subscribe to my content to see sexy photos and videos!'
//},
//{		name: 'autoNotice3Interval',
//    label: 'Show Notification 3 Every x Minutes',
//    type: 'choice',
//        choice1: 2,
//        choice2: 5,
//        choice3: 8,
//        choice4: 10,
//        choice5: 12,				
//    choice6: 15,
//    choice7: 20,
//    choice8: 25,
//    choice9: 30,
//    choice10: 45,
//    choice11: 60,
//        defaultValue: 15
//},
//{		name: 'autoNotice4',
//label: 'Notification Message 4, use text and emotes',
//type: 'str',
//minLength: 0,
//maxLength: 512,
//required: false,
//defaultValue: 'Miss me a lot when I am offline? Join my fan club and you can stay in contact with me every day via WhatsApp!'
//},
//{		name: 'autoNotice4Interval',
//label: 'Show Notification 4 Every x Minutes',
//type: 'choice',
//    choice1: 2,
//    choice2: 5,
//    choice3: 8,
//    choice4: 10,
//    choice5: 12,				
//choice6: 15,
//choice7: 20,
//choice8: 25,
//choice9: 30,
//choice10: 45,
//choice11: 60,
//    defaultValue: 30
//},
		{		name: 'modCommands', 
				type: 'choice', 
				label: 'Allow Moderators to use commands?',
        		choice1: 'Yes',
        		choice2: 'No', 
        		defaultValue: 'Yes'
        },
		{		name: 'userGreets', 
				type: 'choice', 
				label: 'Make special user announcements and emotes when they enter?',
        		choice1: 'Yes',
        		choice2: 'No', 
        		defaultValue: 'Yes'
        },
        {		name: 'slaveTag',
				label: '*** SLAVES *** *** *** Tag for Slave (non-tippers) users',
				type: 'str',
				minLength: 0,
				maxLength: 25,
				required: true,
				defaultValue: '[Slave]'
		},
		{		name: 'slaveList',
				label: 'List of Slave users, separated by space (their CB usernames exactly)',
				type: 'str',
				minLength: 0,
				maxLength: 10240,
				required: false,
				defaultValue: 'wanaplay55 cumin3 kumpekjekken_v2'
		},
		{		name: 'slaveColor',
				label: 'Highlight color to use for Slave users',
				type: 'choice',
        		choice1: 'White FFFFFF',
        		choice2: 'Blue 0C2ED6',
        		choice3: 'Red FF1F1F',
        		choice4: 'Cyan E0FFFF',
        		choice5: 'Gold EEE8AA', 
        		choice6: 'Yellow FFF68F',
				choice7: 'Slate C6E2FF',
				choice8: 'Rosa FF9FBF',
				choice9: 'Orange FFD39B',
				choice10: 'Mint BDFCC9',
				choice11: 'Grey F2F2F2',
				choice12: 'Plum CD96CD',
        		defaultValue: 'Blue 0C2ED6'
    },	
    {		name: 'donkeyTag',
    label: '*** DONKEYS *** *** *** Tag for Donkey (non-tippers) users',
    type: 'str',
    minLength: 0,
    maxLength: 25,
    required: true,
    defaultValue: '[Donkey]'
},
{		name: 'donkeyList',
    label: 'List of Donkey users, separated by space (their CB usernames exactly)',
    type: 'str',
    minLength: 0,
    maxLength: 10240,
    required: false,
    defaultValue: 'hi_mum_it_is_me_jxxxy crazyjempy'
},
{		name: 'donkeyColor',
    label: 'Highlight color to use for Donkey users',
    type: 'choice',
        choice1: 'White FFFFFF',
        choice2: 'Blue 0C2ED6',
        choice3: 'Red FF1F1F',
        choice4: 'Cyan E0FFFF',
        choice5: 'Gold EEE8AA', 
        choice6: 'Yellow FFF68F',
    choice7: 'Slate C6E2FF',
    choice8: 'Rosa FF9FBF',
    choice9: 'Orange FFD39B',
    choice10: 'Mint BDFCC9',
    choice11: 'Grey F2F2F2',
    choice12: 'Plum CD96CD',
        defaultValue: 'Orange FFD39B'
},		
        {		name: 'princeTag',
				label: '*** PRINCE *** *** *** Tag for Prince users',
				type: 'str',
				minLength: 0,
				maxLength: 25,
				required: true,
				defaultValue: '[Prince]'
		},
		{		name: 'princeList',
				label: 'List of Prince users, separated by space (their CB usernames exactly)',
				type: 'str',
				minLength: 0,
				maxLength: 10240,
				required: false,
				defaultValue: ''
		},
		{		name: 'princeColor',
				label: 'Highlight color to use for Prince users',
				type: 'choice',
        		choice1: 'White FFFFFF',
        		choice2: 'Blue 0C2ED6',
        		choice3: 'Red FF1F1F',
        		choice4: 'Cyan E0FFFF',
        		choice5: 'Gold EEE8AA', 
        		choice6: 'Yellow FFF68F',
				choice7: 'Slate C6E2FF',
				choice8: 'Rosa FF9FBF',
				choice9: 'Orange FFD39B',
				choice10: 'Mint BDFCC9',
				choice11: 'Grey F2F2F2',
				choice12: 'Plum CD96CD',
        		defaultValue: 'Red FF1F1F'
		},		
        {		name: 'loverTag',
				label: '*** LOVERS *** *** *** Tag for Lovers users',
				type: 'str',
				minLength: 0,
				maxLength: 25,
				required: true,
				defaultValue: '[Lover]'
		},
		{		name: 'loverList',
				label: 'List of Lovers useres, separated by space (their CB usernames exactly)',
				type: 'str',
				minLength: 0,
				maxLength: 10240,
				required: false,
				defaultValue: 'hello_im_mark'
		},		
		{		name: 'loverColor',
				label: 'Highlight color to use for Lover users',
				type: 'choice',
        		choice1: 'White FFFFFF',
        		choice2: 'Blue 0C2ED6',
        		choice3: 'Red FF1F1F',
        		choice4: 'Cyan E0FFFF',
        		choice5: 'Gold EEE8AA', 
        		choice6: 'Yellow FFF68F',
				choice7: 'Slate C6E2FF',
				choice8: 'Rosa FF9FBF',
				choice9: 'Orange FFD39B',
				choice10: 'Mint BDFCC9',
				choice11: 'Grey F2F2F2',
				choice12: 'Plum CD96CD',
        		defaultValue: 'Rosa FF9FBF'
		},	        		
        {		name: 'husbandTag',
				label: '*** HUSBANDS *** *** *** Tag for Husband users',
				type: 'str',
				minLength: 0,
				maxLength: 25,
				required: true,
				defaultValue: '[Husband]'
		},
		{		name: 'husbandList',
				label: 'List of Husband useres, separated by space (their CB usernames exactly)',
				type: 'str',
				minLength: 0,
				maxLength: 10240,
				required: false,
				defaultValue: 'dunnowhou'
		},		
		{		name: 'husbandColor',
				label: 'Highlight color to use for Husband users',
				type: 'choice',
        		choice1: 'White FFFFFF',
        		choice2: 'Blue 0C2ED6',
        		choice3: 'Red FF1F1F',
        		choice4: 'Cyan E0FFFF',
        		choice5: 'Gold EEE8AA', 
        		choice6: 'Yellow FFF68F',
				choice7: 'Slate C6E2FF',
				choice8: 'Rosa FF9FBF',
				choice9: 'Orange FFD39B',
				choice10: 'Mint BDFCC9',
				choice11: 'Grey F2F2F2',
				choice12: 'Plum CD96CD',
        		defaultValue: 'Gold WEEE8AA'
    },
    {		name: 'lordTag',
    label: '*** LORDS *** *** *** Tag for Lord users',
    type: 'str',
    minLength: 0,
    maxLength: 25,
    required: true,
    defaultValue: '[Lord]'
},
{		name: 'lordList',
    label: 'List of Lord useres, separated by space (their CB usernames exactly)',
    type: 'str',
    minLength: 0,
    maxLength: 10240,
    required: false,
    defaultValue: ''
},		
{		name: 'lordColor',
    label: 'Highlight color to use for Lord users',
    type: 'choice',
        choice1: 'White FFFFFF',
        choice2: 'Blue 0C2ED6',
        choice3: 'Red FF1F1F',
        choice4: 'Cyan E0FFFF',
        choice5: 'Gold EEE8AA', 
        choice6: 'Yellow FFF68F',
    choice7: 'Slate C6E2FF',
    choice8: 'Rosa FF9FBF',
    choice9: 'Orange FFD39B',
    choice10: 'Mint BDFCC9',
    choice11: 'Grey F2F2F2',
    choice12: 'Plum CD96CD',
        defaultValue: 'Cyan E0FFFF'
},		

// START ROTATING NOTIFIER CHOICES

    {
      name: 'NOTIFIERMENU',
      label: '------------------------------>  ROTATING NOTIFIERS  <---------------------------- ',
      required: false,
      type: 'choice'
    },

    {name: 'msgonentry', type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'Yes', label: "Display Message 1 privately on entry - set to No for busy rooms"},
    {name:'msg1', type:'str', required: true, label:'Message 1', defaultValue: 'Hello and welcome to my room, don\'t forget to follow and to say hello!'},
    {name:'msg2', type:'str', required: false, label:'Message 2', defaultValue: 'Do you want to be my slave? Or prince? Or lover? Or husband? Or lord? Tip the respective amounts and you can be mine!'},
    {name:'msg3', type:'str', required: false, label:'Message 3', defaultValue: 'I now have an Onlyfans-Account: https://onlyfans.com/sammyreu Follow me and subscribe to my content to see sexy photos and videos!'},
    {name:'msg4', type:'str', required: false, label:'Message 4', defaultValue: 'Miss me a lot when I am offline? Join my fan club and you can stay in contact with me every day via WhatsApp!'},
    {name:'msg5', type:'str', required: false, label:'Message 5', defaultValue: 'Want to make me vibrate with my new toy, the Ferri? I also have Lush, Domi and Nora! Go ahead and tip, I can\'t wait! :)'},
    {name:'msg6', type:'str', required: false, label:'Message 6', defaultValue: ''},
    {name:'msg7', type:'str', required: false, label:'Message 7', defaultValue: ''},
    {name:'msg8', type:'str', required: false, label:'Message 8', defaultValue: ''},
    {name:'msg9', type:'str', required: false, label:'Message 9', defaultValue: ''},
    {name:'msg10', type:'str', required: false, label:'Message 10', defaultValue: ''},
    {name:'msgcolor', type:'str', label:'Notice background color (default is green (standard of this bot) #99FF66)', defaultValue: '#99FF66'},
    {name: 'chat_ad', type:'int', minValue: 1, maxValue: 999, defaultValue: 9, label: 'Delay in minutes between notices being displayed (minimum 1)'},

// END ROTATING NOTIFIER CHOICES

// START TIP MENU CHOICES

    {
      name: 'MENU',
      label: '------------------------------>  TIP MENU  <---------------------------- ',
      required: false,
      type: 'choice'
    },
    {
      name: 'sepchar',
      type: 'choice',
      choice1: 'Vertical Bar',
      choice2: 'Hearts',
      choice3: 'Glitter',
      choice4: 'Flowers',
      choice5: 'Pixelheart',
      choice6: 'Hearts2',
      choice7: 'Smiley',
      choice8: 'Text Heart',
      choice9: 'Text Diamond',
      choice10: 'Text Star',
      choice11: 'Custom',
      defaultValue: 'Pixelheart',
      label: "Separator character"
    },
    {
      name: 'sepcharcustom',
      type: 'str',
      defaultValue: ':heart2',
      required: false,
      label: 'Custom Separator. It can be a GIF (Don\'t forget the ":") or a string of characters (&!&).'
    },
    {
      name: 'menutxtcolor1',
      type: 'str',
      label: 'Text color (default gold #FFF300)',
      required: false,
      defaultValue: '#FFF300'
    },
    {
      name: 'menubgcolor1',
      type: 'str',
      label: 'Background color (default pink #FF00B4)',
      required: false,
      defaultValue: '#FF00B4'
    },
    {
      name: 'menuTimer',
      type: 'str',
      defaultValue: 13,
      label: 'How often the menu (or each part) will appear in chat. Can do decimals, e.g. 2.5 = 2 minutes 30 seconds.'
    },
    {
      name: 'chatNotice',
      type: 'choice',
      choice1: 'Display the full menu',
      choice2: 'Only display the short notice',
      defaultValue: 'Display the full menu',
      label: "Do you want the notice to display the full menu or only the short notice ( i.e. Type '/sammybot tipmenu' or '/sb tipmenu' to see the menu)"
    },
    {
      name: 'menuNoticeOnEntry',
      type: 'choice',
      choice1: 'Yes',
      choice2: 'No',
      defaultValue: 'Yes',
      label: "Display the full menu to users who enter the room?"
    },
    {
      name: 'listSort',
      type: 'choice',
      choice1: 'Do not sort the list',
      choice2: 'Ascending',
      choice3: 'Descending',
      defaultValue: 'Ascending',
      label: "Do you want the list to be sorted by price?"
    },
    {
      name: 'listSplit',
      type: 'choice',
      choice1: 'Do not split the list',
      choice2: 'Split the list in 2',
      defaultValue: 'Do not split the list',
      label: "If you have a very long list, Do you want the list to be split in 2?"
    },
    {
      name: 'menutxtcolor2',
      type: 'str',
      required: false,
      label: 'You can pick the color for the split menu',
      defaultValue: '#FFF300'
    },
    {
      name: 'menubgcolor2',
      type: 'str',
      required: false,
      label: 'Split menu background color',
      defaultValue: '#FF00B4'
    },
    {
      name: 'item1',
      label: 'Item 1',
      type: 'str',
      defaultValue: 'kiss',
      required: false
    },
    {
      name: 'itemprice1',
      label: 'Item 1 price',
      type: 'int',
      defaultValue: 1,
      required: false
    },
    {
      name: 'item2',
      label: 'Item 2',
      type: 'str',
      defaultValue: 'middle finger',
      required: false
    },
    {
      name: 'itemprice2',
      label: 'Item 2 price',
      type: 'int',
      defaultValue: 15,
      required: false
    },
    {
      name: 'item3',
      label: 'Item 3',
      type: 'str',
      defaultValue: 'keep going',
      required: false
    },
    {
      name: 'itemprice3',
      label: 'Item 3 price',
      type: 'int',
      defaultValue: 16,
      required: false
    },
    {
      name: 'item4',
      label: 'Item 4',
      type: 'str',
      defaultValue: 'spank x5',
      required: false
    },
    {
      name: 'itemprice4',
      label: 'Item 4 price',
      type: 'int',
      defaultValue: 17,
      required: false
    },
    {
      name: 'item5',
      label: 'Item 5',
      type: 'str',
      defaultValue: 'if you like what you see',
      required: false
    },
    {
      name: 'itemprice5',
      label: 'Item 5 price',
      type: 'int',
      defaultValue: 20,
      required: false
    },
    {
      name: 'item6',
      label: 'Item 6',
      type: 'str',
      defaultValue: 'kiss close to the camera',
      required: false
    },
    {
      name: 'itemprice6',
      label: 'Item 6 price',
      type: 'int',
      defaultValue: 24,
      required: false
    },
    {
      name: 'item7',
      label: 'Item 7',
      type: 'str',
      defaultValue: 'dance sexy',
      required: false
    },
    {
      name: 'itemprice7',
      label: 'Item 7 price',
      type: 'int',
      defaultValue: 35,
      required: false
    },
    {
      name: 'item8',
      label: 'Item 8',
      type: 'str',
      defaultValue: 'your name on my body',
      required: false
    },
    {
      name: 'itemprice8',
      label: 'Item 8 price',
      type: 'int',
      defaultValue: 40,
      required: false
    },
    {
      name: 'item9',
      label: 'Item 9',
      type: 'str',
      defaultValue: 'flash boobs',
      required: false
    },
    {
      name: 'itemprice9',
      label: 'Item 9 price',
      type: 'int',
      defaultValue: 49,
      required: false
    },
    {
      name: 'item10',
      label: 'Item 10',
      type: 'str',
      defaultValue: 'play ass',
      required: false
    },
    {
      name: 'itemprice10',
      label: 'Item 10 price',
      type: 'int',
      defaultValue: 50,
      required: false
    },
    {
      name: 'item11',
      label: 'Item 11',
      type: 'str',
      defaultValue: 'play nipples',
      required: false
    },
    {
      name: 'itemprice11',
      label: 'Item 11 price',
      type: 'int',
      defaultValue: 55,
      required: false
    },
    {
      name: 'item12',
      label: 'Item 12',
      type: 'str',
      defaultValue: 'if you wanna be my daddy',
      required: false
    },
    {
      name: 'itemprice12',
      label: 'Item 12 price',
      type: 'int',
      defaultValue: 65,
      required: false
    },
    {
      name: 'item13',
      label: 'Item 13',
      type: 'str',
      defaultValue: 'show pussy',
      required: false
    },
    {
      name: 'itemprice13',
      label: 'Item 13 price',
      type: 'int',
      defaultValue: 80,
      required: false
    },
    {
      name: 'item14',
      label: 'Item 14',
      type: 'str',
      defaultValue: 'spank x30',
      required: false
    },
    {
      name: 'itemprice14',
      label: 'Item 14 price',
      type: 'int',
      defaultValue: 100,
      required: false
    },
    {
      name: 'item15',
      label: 'Item 15',
      type: 'str',
      defaultValue: 'strip',
      required: false
    },
    {
      name: 'itemprice15',
      label: 'Item 15 price',
      type: 'int',
      defaultValue: 120,
      required: false
    },
    {
      name: 'item16',
      label: 'Item 16',
      type: 'str',
      defaultValue: 'instant naked',
      required: false
    },
    {
      name: 'itemprice16',
      label: 'Item 16 price',
      type: 'int',
      defaultValue: 150,
      required: false
    },
    {
      name: 'item17',
      label: 'Item 17',
      type: 'str',
      defaultValue: 'fuck dildo in pvt',
      required: false
    },
    {
      name: 'itemprice17',
      label: 'Item 17 price',
      type: 'int',
      defaultValue: 200,
      required: false
    },
    {
      name: 'item18',
      label: 'Item 18',
      type: 'str',
      defaultValue: 'cum show in pvt',
      required: false
    },
    {
      name: 'itemprice18',
      label: 'Item 18 price',
      type: 'int',
      defaultValue: 201,
      required: false
    },
    {
      name: 'item19',
      label: 'Item 19',
      type: 'str',
      defaultValue: 'control lush, domi or nora in public (10 min.)',
      required: false
    },
    {
      name: 'itemprice19',
      label: 'Item 19 price',
      type: 'int',
      defaultValue: 400,
      required: false
    },
    {
      name: 'item20',
      label: 'Item 20',
      type: 'str',
      defaultValue: 'squirt in pvt',
      required: false
    },
    {
      name: 'itemprice20',
      label: 'Item 20 price',
      type: 'int',
      defaultValue: 450,
      required: false
    },
    {
      name: 'item21',
      label: 'Item 21',
      type: 'str',
      defaultValue: 'if you love me',
      required: false
    },
    {
      name: 'itemprice21',
      label: 'Item 21 price',
      type: 'int',
      defaultValue: 1000,
      required: false
    },
    {
      name: 'item22',
      label: 'Item 22',
      type: 'str',
      defaultValue: 'for the university',
      required: false
    },
    {
      name: 'itemprice22',
      label: 'Item 22 price',
      type: 'int',
      defaultValue: 1111,
      required: false
    },
    {
      name: 'item23',
      label: 'Item 23',
      type: 'str',
      defaultValue: 'off-day',
      required: false
    },
    {
      name: 'itemprice23',
      label: 'Item 23 price',
      type: 'int',
      defaultValue: 5000,
      required: false
    },
    {
      name: 'item24',
      label: 'Item 24',
      type: 'str',
      defaultValue: 'dream-tip... will never happen',
      required: false
    },
    {
      name: 'itemprice24',
      label: 'Item 24 price',
      type: 'int',
      defaultValue: 15000,
      required: false
    },
    {
      name: 'item25',
      label: 'Item 25',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice25',
      label: 'Item 25 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },
    {
      name: 'item26',
      label: 'Item 26',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice26',
      label: 'Item 26 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },
    {
      name: 'item27',
      label: 'Item 27',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice27',
      label: 'Item 27 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },
    {
      name: 'item28',
      label: 'Item 28',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice28',
      label: 'Item 28 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },
    {
      name: 'item29',
      label: 'Item 29',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice29',
      label: 'Item 29 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },
    {
      name: 'item30',
      label: 'Item 30',
      type: 'str',
      defaultValue: '',
      required: false
    },
    {
      name: 'itemprice30',
      label: 'Item 30 price',
      type: 'int',
      defaultValue: 0,
      required: false
    },

// END TIP MENU CHOICES

// START ROLL THE DICE GAME CHOICES

{
  name: 'DICEMENU',
  label: '------------------------------>  ROLL THE DICE GAME  <---------------------------- ',
  required: false,
  type: 'choice'
},

{name: 'settings_section_label', type:'choice', label:'################# Basic Settings #################', required: false},
{
  name: 'tokens', type: 'int', minValue: 1,
  label: 'How much do you want to charge per roll?',
  defaultValue: 43
},
{
  name: 'notice_wait_time',
  type: 'int',
  label: 'In minutes, how often should the bot advertise itself? (choosing 0 will never show the timer bot notices)',
  minValue: 0,
  defaultValue: 37
},
{
  name: 'blurb_size',
  type: 'choice',
  label: 'Size of the timed bot advertisement blurb.',
  choice1: 'Minimal Blurb',
  choice2: 'Short Blurb',
  choice3: 'Without "all" or Bot Name',
  choice4: 'Full Blurb',
  choice5: 'Off',
  defaultValue: 'Without "all" or Bot Name'
},
{
  name: 'entry_blurb_size',
  type: 'choice',
  label: 'Size of the user entry advertisement blurb.',
  choice1: 'Minimal Blurb',
  choice2: 'Short Blurb',
  choice3: 'Without "all" or Bot Name',
  choice4: 'Full Blurb',
  choice5: 'Off',
  defaultValue: 'Full Blurb'
},
{
  name: 'change_room_subject', type: 'choice', label: 'Change room subject when using this bot?',
  choice1: 'Yes', choice2: 'No', defaultValue: 'No'
},
{name: 'multirolls_subsection_label', type:'choice', label:'######### Multi Rolls #########', required: false},
{
  name: 'max_rolls_at_once', type: 'int', minValue: 1,
  label: 'Maximum number of rolls that can be tipped for in a single tip.',
  defaultValue: 3
},
{
  name: 'perfect_multi', type: 'choice',
  label: 'Require exact multiples of tip amount to roll the die? (if you charge 33 per roll, 66 will roll 2x but 69 won\'t)',
  choice1: 'Yes', choice2: 'No',
  defaultValue: 'Yes'
},
{name: 'prizeodds_subsection_label', type:'choice', label:'######### Prize Odds #########', required: false},
{
  name: 'equal_odds', type: 'choice',
  label: 'Should all non-rare prizes have equal odds of being rolled? ("No" simulates rolling a pair of dice and "Yes" rolls a single die)',
  choice1: 'Yes', choice2: 'No',
  defaultValue: 'No'
},
{
  name: 'last_prize_rare', type: 'choice',
  label: 'Should the last prize in the list be RARE? (RARE prizes will only show up after a minimum number of rolls have been rolled and should be significantly less likely than other prizes)',
  choice1: 'Yes', choice2: 'No',
  defaultValue: 'Yes'
},
{
  name: 'minimum_rolls', type: 'int', minValue: 0,
  label: 'Minimum number of rolls that must be rolled before RARE prizes can be won.',
  defaultValue: 10
},
{
  name: 'rare_chance_mult', type: 'choice',
  label: 'Multiplier for the chance of rolling rare prizes. Increase if rare prizes are too uncommon, Decrease if they\'re too common',
  choice1: '1/2x', choice2: '3/4x', choice3: '1x', choice4: '1.5x', choice5: '2x', choice6: '4x', choice7: '8x',
  defaultValue: '1/2x'
},
{name: 'prize_section_label', type:'choice', label:'#################### Prizes ####################', required: false},
{name: 'prize_1', type: 'str', label: '(List possible prizes from most common to least.) Prize 1'},
{name: 'prize_2', type: 'str', label: '(if equal odds option is \'Yes\' order doesn\'t matter.) Prize 2'},
{name: 'prize_3', type: 'str', label: '(Fill prize spots in order from top to bottom.) Prize 3', required: false},
{name: 'prize_4', type: 'str', label: '(Leave the remaining fields blank to not use them.) Prize 4', required: false}

// END ROLL THE DICE GAME CHOICES
];

/*
 * handle tips from users
 */
var totalTipped = 0;
cb.onTip(function (tip) {
	var divStr = "";
	var msgText = "";
	var msgNotify = "";
	var tipAmount = parseInt(tip['amount']);
	var name = tip['from_user'];
	var modelName = cb.room_slug;	
	
	// is user in tipper array? 
	if (!tippers[name]) {
		//nope add them
		tippers[name] = {username: name, tips: 0};
	}
	if (!tippers[name].tips) {
		tippers[name].tips = 0;
	}
	
	tippers[name].tips += tipAmount;
	
	switch(tipAmount) {

    case 7500:
			result = addUser(lordUsersArray, name);
			if (result instanceof Array) {
				lordUsersArray = result;
				msgPublic = name + ' is now ' + modelName + '\'s Lord!!! Thank you for your tip!';
				msgModel = modelName + ', don\'t forget to add ' + name + ' to Lords in the bot config!';

			}
			else {
				if (result == 'duplicate') {
					msgPublic = name + ' is already ' + modelName + '\'s Lord!!! Thank you for your tip!';;
				}
				else {
					msgPublic = 'Failed to add user ' + name + ' to Lords. Something went wrong!';
				}
			}		
		break;

		case 5000:
      if (!userInArray (lordUsersArray, name)) {
        result = addUser(husbandUsersArray, name);
        if (result instanceof Array) {
          husbandUsersArray = result;
          msgPublic = name + ' is now ' + modelName + '\'s Husband!!! Thank you for your tip!';
          msgModel = modelName + ', don\'t forget to add ' + name + ' to Husbands in the bot config!';

        }
        else {
          if (result == 'duplicate') {
            msgPublic = name + ' is already ' + modelName + '\'s Husband!!! Thank you for your tip!';;
          }
          else {
            msgPublic = 'Failed to add user ' + name + ' to Husbands. Something went wrong!';
          }
        }
      }	
      else {	
        msgPublic = name + ' already has a higher status than Husband! Status not changed. Thank you for your tip!';
      }
		break;

		case 2000:
      if (!userInArray (lordUsersArray, name) && !userInArray (husbandUsersArray, name)) {	
				result = addUser(loverUsersArray, name);
				if (result instanceof Array) {
					loverUsersArray = result;
					msgPublic = name + ' is now ' + modelName + '\'s Lover!!! Thank you for your tip!';
					msgModel = modelName + ', don\'t forget to add ' + name + ' to Lovers in the bot config!';
				}
				else {
					if (result == 'duplicate') {
						msgPublic = name + ' is already ' + modelName + '\'s Lover!!! Thank you for your tip!';;
					}
					else {
						msgPublic = 'Failed to add user ' + name + ' to Lovers. Something went wrong!';
					}
				}
			}
			else {
				msgPublic = name + ' already has a higher status than Lover! Status not changed. Thank you for your tip!';
			}			
		break;

		case 1000:
			if (!userInArray (lordUsersArray, name) && !userInArray (husbandUsersArray, name) && !userInArray (loverUsersArray, name)) {			
				result = addUser(princeUsersArray, name);
				if (result instanceof Array) {
					princeUsersArray = result;
					msgPublic = name + ' is now ' + modelName + '\'s Prince!!! Thank you for your tip!';
					msgModel = modelName + ', don\'t forget to add ' + name + ' as a Prince in the bot config!';
				}
				else {
					if (result == 'duplicate') {
						msgPublic = name + ' is already ' + modelName + '\'s Prince!!! Thank you for your tip!';;
					}
					else {
						msgPublic = 'Failed to add user ' + name + ' as a Prince. Something went wrong!';
					}
				}
			}
			else {
				msgPublic = name + ' already has a higher status than Prince! Status not changed. Thank you for your tip!';
			}
		break;

		// case 222:
		// 	msgPublic = name + ' tipped 222 tokens for ALL videos!!! Thank you! Video links will be emailed to you shortly!';
		// 	msgPrivate = sendEmailMsg;
		// break;

		// case 60:
		// 	msgPublic = name + ' tipped 60 tokens for one video (choose)! Thank you!';
		// 	msgPrivate = sendEmailMsg;
		// break;

		default:
			msgPublic = 'Thank you ' + name + ' for your tip of ' + tipAmount;
			if (tipAmount == 1) {
				msgPublic += ' token!';
			} else {
				msgPublic += ' tokens!';
			}
		break;
	}

	// Output any notices or command results to user
	if (msgPrivate.length > 0) {
		cb.sendNotice(msgPrivate, name, botMsgBg, botMsgText,'bold');
		msgPrivate = "";
	}
	
	// Output any public notices or command results
	if (msgPublic.length > 0) {
		cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
		msgPublic = "";
	}		
	
	// Output any messages to the model
	if (msgModel.length > 0) {
		cb.sendNotice(msgModel, modelName, botMsgBg, botMsgText,'bold');
		msgModel = "";
  }	
  // START ONTIP TIP MENU

  let u = tip.from_user;
	if (tip.is_anon_tip){
		u = "anonymous user";
	}
	let tipAmt = parseInt(tip.amount);
	if (TIPMENU.enable) {
		for (let i = 0; i < TIPMENU.lenght; i++) {
			if (tipAmt === TIPMENU.prices[i]) {
				TIPMENU.requesters.push(u);
				TIPMENU.request.push(TIPMENU.items[i]);
				cb.sendNotice(u + ' tipped for ***** ' + TIPMENU.items[i] + ' *****', '', TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
			}
		}
	}

  // END ONTIP TIP MENU

  // START ONTIP ROLL THE DICE GAME MENU

 	stats.tipCounter += tipAmount;
	if(tipAmount >= rollprice && (!perfectMults || ((tipAmount <= (maxRollsPerTip*rollprice)) && (tipAmount % rollprice === 0)))) {
		var rolls = Math.floor(tipAmount/rollprice);
		for(var i = 0; i < rolls; i++) {
			var username = "anonymous";
			if(!tip.is_anon_tip) {
				username = tip.from_user;
			}
			roll(username, true);
			lastRoller = username;
		}
	} else {
		// not rolling the dice
		// var textColor = '#000000';
		// var bgColor = '#D9FAD7';
		cb.drawPanel();
	} 

  // END ONTIP ROLL THE DICE GAME MENU
});

/*
 * handle user entrance messages
 */
cb.onEnter(function(user) {
	var lenOfSpecialNames = 0;
	var nameFound = false;
	var greeting = '';
	var modelName = cb.room_slug;
	var name = user['user'];
	var isMod = user['is_mod'];
	var isFan = user['in_fanclub'];
  var isMark = (name == 'hello_im_mark');	
	var isReal = (cb.room_slug == 'skinnytinyy2');	
	var isModel = (name == cb.room_slug);
	var hasTokens = user['has_tokens'];
	var hasTipped = user['tipped_recently'];	
	var isGrey = !(hasTokens || isMod || isModel || isFan);
	lenOfSpecialNames = specialNames.length;

	for(i=0; i < lenOfSpecialNames; i++) {
		if (specialNames[i][0] == name) {
			greeting = specialNames[i][1];
			nameFound = true;
			break;
		}
	}
	
	if (nameFound && userGreets) {
		cb.sendNotice(greeting,'','#FFFFFF');
	}	
	else {
	
		if (userGreets) {
			if ( userInArray (princeUsersArray, user['user']) ) {
				cb.sendNotice('Welcome Prince ' + user['user'] + ' to the room!','',princeColor,'','bold');
			}
			else {
				if ( userInArray (slaveUsersArray, user['user']) ) {
					cb.sendNotice('Welcome Slave ' + user['user'] + ' to the room!','',slaveColor,'','bold');
				}
				else 					{
					if (userInArray(loverUsersArray, user['user'])) {
						cb.sendNotice('Welcome Lover ' + user['user'] + ' to the room!','',loverColor,'','bold');			
					}
					else {
						if (userInArray(husbandUsersArray, user['user'])) {
							cb.sendNotice('Welcome Husband ' + user['user'] + ' to the room!','',husbandColor,'','bold');
            }
            else {
              if (userInArray(donkeyUsersArray, user['user'])) {
                cb.sendNotice('Welcome Donkey ' + user['user'] + ' to the room!','',donkeyColor,'','bold');
              }
              else {
                if (userInArray(lordUsersArray, user['user'])) {
                  cb.sendNotice('Welcome Lord ' + user['user'] + ' to the room!','',lordColor,'','bold');
                }
              }
            }
					}
				}
			}
			// show notice if user is in timeout
//			if ( userInArray(timeoutUsersArray, user['user']) ) {
//				cb.sendNotice(user['user'] + ' is back, but still in timeout!','',botMsgBg, botMsgText,'bold');
//			}
		}
	}
	
	if (isMod) {
		cb.sendNotice(modWelcome(),user['user'],botAlertBg,'','bold');
	}
	else {
		cb.sendNotice('\nWelcome! Sammy\'s Castle Bot is running - Tip 1000 to be a Prince, 2000 to be my Lover, 5000 to be my Husband, or 7500 to be my Lord!\n\n',user['user'],botMsgBg, botMsgText,'bold');
		
		if (genderEmotes) {
		
			cb.sendNotice('Gender Emotes are enabled: :avatar_gen_male = Male User :avatar_gen_female = Female User\n :avatar_gen_couple = Couple User :avatar_gen_trans = Transgender User\n :avatar_gen_unknown = Gender Unknown\n\n',user['user'],'#ffffff','','bold');
		
		}
		
		if (modelName != 'skinnytinyy2') {
			cb.sendNotice('\nThis is NOT Sammy\'s room!\nThis bot was created for Sammy chaturbate.com/skinnytinyy2\nVisit her room on CB!\n\n\n',user['user'],botAlertBg,'','bold');
		}
		
		if (!allowGreyEmotes && isGrey) {
			cb.sendNotice('\nYou don\'t have any tokens. Use of emoticons for users without tokens and not part of the castle is not allowed at this time.\n\n\n',user['user'],botAlertBg,'','bold');
		}
  }
// START ONENTER TIP MENU

  let isModtm = (cb.room_slug === user.user || user.is_mod);
	if (TIPMENU.enable) {
		cb.sendNotice('Tip Menu Active! See the full menu at anytime by typing: /sammybot tipmenu or /sb tipmenu', user.user, TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
		if (TIPMENU.onEntry) {
			cb.sendNotice(TIPMENU.full, user.user, TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
		}
	}

// END ONENTER TIP MENU

// START ONENTER ROTATING NOTIFIER

  if (cb.settings['msgonentry'] == 'Yes') {
    cb.sendNotice('I\'m happy to see you, ' + user['user'] + '! ',user['user'],cb.settings['msgcolor'],'','bold');
    cb.sendNotice(cb.settings['msg1'],user['user'],cb.settings['msgcolor'],'','bold');
  }

// END ONENTER ROTATING NOTIFIER

 }); 


/*
 * handle messages from users
 */
cb.onMessage(function(message) {
	
	var msg = message['m'];
	var groupTag = '';
	var name = message['user'];
	var commandProcessed = false;
	var gender = message['gender'];
	var modelName = cb.room_slug;
	var isMod = message['is_mod'];
	var isFan = message['in_fanclub'];
  var isMark = (name == 'hello_im_mark');	
	var isReal = (cb.room_slug == 'skinnytinyy2');	
	var isModel = (name == cb.room_slug);
	var hasTokens = message['has_tokens'];
	var hasTipped = message['tipped_recently'];
	var isGrey = !(hasTokens || isMod || isModel || isFan);	
	var divStr = "";
	var tempAllowMsg = tempAllowMsg = "Only " + modelName;	
	var userArray = new Array();
	var userList = "";	
	var showOutput = true;
	var genderStr = "";
	var isInGroup = false;

	if (modCommands) {
		tempAllowMsg = modelName + " and mods";
	}
	
	helpMsg = tempAllowMsg + " may use the following commands (* needs to be enabled for mods):\n"
//			+ botTrigger + " view [prince] = list of level users\n"
			+ botTrigger + " useradd [prince] [username] = add username to level*\n"
			+ botTrigger + " userdel [prince] [username] = delete username from level*\n"
//			+ botTrigger + " check [username] = show what level a user is in\n"
//			+ botTrigger + " mods [on/off] = turns on/off mod commands*\n"
//			+ botTrigger + " greyemotes [on/off] = turns on/off grey emotes*\n"			
//			+ botTrigger + " note [message] = send a public message to chat\n"
//			+ botTrigger + " sammyote [message] = send a private message to Sammy\n"			
//			+ botTrigger + " modnote [message] = send a private message to mods\n"			
//			+ botTrigger + " greets [on/off] = turns on/off level user greetings*\n"
			+ botTrigger + " tips = shows all tippers since the latest bot-restart to all users\n"
			+ botTrigger + " tips # = shows the top # tippers since the latest bot-restart to all users\n"			
			+ botTrigger + " tippers = shows all tippers since the latest bot-restart to yourself\n"
			+ botTrigger + " tippers # = show top # tippers since the latest bot-restart to yourself\n"	
//			+ botTrigger + " colors [text] [bg] = change text and bg color\n"				
//			+ botTrigger + " colors reset = reset colors to b/w\n"	
//			+ botTrigger + " text [color] = change text color\n"				
//			+ botTrigger + " bg [color] = change background color\n"					
      + botTrigger + " status = shows the bot status\n"
      + botTrigger + " tipmenu = shows the tipmenu to all users\n"
      + botTrigger + " prizes = shows all prizes to all users\n"
//      + botTrigger + " prizes all = shows all prizes to all users\n"
      + botTrigger + " winners = shows all winners to all users\n"
//      + botTrigger + " winners all = shows all winners to all users\n"
      + botTrigger + " dicestats = shows the dicestats to all users\n"
//      + botTrigger + " dicestats all = shows the dicestats to all users\n"
      + botTrigger + " diceroll = the broadcaster and the creator can roll the dice without tipping*\n"
			+ "*** NOTE to the boradcaster: To make names stick in user groups, add them in the bot config.";

	// if user is in a group, add the group tag to their message
	// and change the background color
	if ( userInArray (princeUsersArray, name) ) {
		message['c'] = princeColor;
		groupTag = princeTag;
		groupColor = princeColor;
		isInGroup = true;
	}
	else {
		if ( userInArray (slaveUsersArray, name) ) {
			message['c'] = slaveColor;
			groupTag = slaveTag;
			groupColor = slaveColor;
			isInGroup = true;
		}
		else 					{
			if (userInArray(loverUsersArray, name)) {
				message['c'] = loverColor;
				groupTag = loverTag;
				groupColor = loverColor;
				isInGroup = true;
			}
			else {
				if (userInArray(husbandUsersArray, name)) {
					message['c'] = husbandColor;
					groupTag = husbandTag;
					groupColor = husbandColor;
					isInGroup = true;
        }
        else {
          if (userInArray(donkeyUsersArray, name)) {
            message['c'] = donkeyColor;
            groupTag = donkeyTag;
            groupColor = donkeyColor;
            isInGroup = true;
          }
          else {
            if (userInArray(lordUsersArray, name)) {
              message['c'] = lordColor;
              groupTag = lordTag;
              groupColor = lordColor;
              isInGroup = true;
            }
          }
        }
			}
		}
	}			
				
// handle commands 
	if ( isModel || (isMod && (modCommands === true)) || isMark || isInGroup) {
		var activeBotTrigger = botTrigger;
		if (msg.indexOf(botTrigger2) > -1) {
			activeBotTrigger = botTrigger2;
		}
		if ((msg.indexOf(botTrigger) > -1) || (msg.indexOf(botTrigger2) > -1)) {
			msgParam1 = getParam(msg,' ',1);	
			msgParam2 = getParam(msg,' ',2);
			msgParam3 = getParam(msg,' ',3);
			msgParam4 = getParam(msg,' ',4);	
			
			var regexCommandSplit	= '^' + activeBotTrigger + ' (\\S+)(?:\\b\\s*)(.*)?'; 
			var regexListSplit		= /[,\s]+/;
			var reCmdSplit = new RegExp(regexCommandSplit);
			var cmdSplit = msg.match(reCmdSplit);
			var cmd;
			var cmdval;
			var cmdValArray; 	
			
			switch(msgParam1) {
			
				case 'help':
					message['X-Spam'] = true;
					divStr = makeDiv('_',50,50);
					
					msgPrivate = divStr + '\nSammy\'s Castle Bot ver ' + botVersion + '\nCreated by Mark\n' + divStr + '\n';
					msgPrivate += helpMsg + '\n' + divStr;
				break;

        case 'tips':
					if (isMark || isModel || isMod) {
						message['X-Spam'] = true;				
						if (!msgParam2) {
							msgParam2 = 0;
						}
						msgPublic = getTippers(msgParam2);
					}
					else {
						msgPrivate = 'Only the broadcaster, mods and the creator can display the tips!';
					}
        break;
        
//				case 'tips':
//					message['X-Spam'] = true;				
//					if (!msgParam2) {
//						msgParam2 = 0;
//					}
//					msgPublic = getTippers(msgParam2);
//				break;
  
        case 'tippers':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;				
            if (!msgParam2) {
              msgParam2 = 0;
            }
            msgPrivate = getTippers(msgParam2);
          }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the tippers!';
          }
        break;

//				case 'tippers':
//					message['X-Spam'] = true;				
//					if (!msgParam2) {
//						msgParam2 = 0;
//					}
//					msgPrivate = getTippers(msgParam2);
//				break;
				
//				case 'notice':
//				case 'note':
//				case 'modnote':
//				case 'modnotice':
//				case 'sammynote':
//				case 'sammynotice':
//				case 'n':
//				case 'markArrayTag':
//        case 'sammyArrayTag':
//					message['X-Spam'] = true;
//					
//					if ( cmdSplit ) {
//						cmdval = cmdSplit[2];
//						if ( cmdval != null ) {
//							cmdval = cmdval.replace(/^\s+|\s+$/g,'');
//						}
//						// contains message. who do we send it to?
//						switch(msgParam1) {
//						
//						case 'markArraytag':
//							if (isMark) {
//								markArrayTag = cmdval;
//							}
//            break;
//            
//						case 'sammyArraytag':
//							if (isModel) {
//								sammyArrayTag = cmdval;
//							}
//						break;
//						
//						case 'notice':
//						case 'note':
//						case 'n':
//							msgPublic = '*** ' + name + ' says: ' + cmdval + ' ***';
//						break;
//						
//						case 'sammynote':
//						case 'sammynotice':
//							msgModel = '*** Private notice from ' + name + ': ' + cmdval + ' ***';
//							msgPrivate = 'Your message was sent to ' + modelName + '...';
//						break;
//						
//						case 'modnote':
//						case 'modnotice':
//							msgMod = '*** Moderator notice from ' + name + ': ' + cmdval + ' ***';
//							msgPrivate = 'Your message was sent to the moderators...';
//						break;
//						
//						}
//					}				
//        break;
  // START ONMESSAGE TIP MENU


        case 'tipmenu':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;				
            // is user color array 
            msgPublic = TIPMENU.full;
          }
          else {
            msgPrivate = 'Only the broadcaster, mods, and the creator can display the tipmenu!';
          }
        break;
//    case 'tipmenu':
//        message['X-Spam'] = true;
//        for (let i = 0; i < TIPMENU.noticeViewLength; i++) {
//          if (name !== TIPMENU.noticeView[i]) {
//            msgPublic = name + ' requested the tip menu.' + TIPMENU.noticeView[i];
//           cb.sendNotice(name + " requested the tip menu.", TIPMENU.noticeView[i]);
//          }
//        }
//          if (isMod && msg[0] === "/tipmenu" || isMod && msg[0] === "/menu") {
//            name = '';
//          }
//        msgPublic = TIPMENU.full;
//  +  TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold'
//        break;
//          return message;

  // END ONMESSAGE TIP MENU

  // START ONMESSAGE ROLL THE DICE GAME MENU

        case 'dicehelp':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;
            msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
            adBlurb('Full Blurb', msg.user);
          }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the info for roll the dice!';
          }
        break;

//		case 'dicehelp':
//			msg["X-Spam"] = true;  // Don't print command messages to chat.
//			msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
//			if(message[1] == 'all' && isPrivileged(msg))adBlurb('Full Blurb');
//			else adBlurb('Full Blurb', msg.user);
//    break;
    
        case 'winners':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;
            msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
            winnersBlurb(msg.user);
          }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the winners!';
          }
        break;

//		case 'winners':
//			msg["X-Spam"] = true;
//			msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
//			if(message[1] == 'all' && isPrivileged(msg))winnersBlurb();
//			else winnersBlurb(msg.user);
//    break;

        case 'prizes':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;
            msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
            prizesBlurb(msg.user);
          }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the prizes!';
          }
        break;

//		case 'prizes':
//			msg["X-Spam"] = true;
//			msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
//			if(message[1] == 'all' && isPrivileged(msg))prizesBlurb();
//			else prizesBlurb(msg.user);
//    break;
 
        case 'dicestats':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;
            msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
            statsBlurb(msg.user);
          }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the dicestats!';
          }
        break;

//		case 'dicestats':
//			msg["X-Spam"] = true;
//			msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
//			if(message[1] == 'all' && isPrivileged(msg))statsBlurb();
//			else statsBlurb(msg.user);
//    break;

//		case 'diceroll':
//			if(msg.user == cb.room_slug || (allow_mod_rolls && isPrivileged(msg))) {
//				msg["X-Spam"] = true;
//				msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";
//
//				var times_to_roll = 1;
//				if(message.length > 1) {
//					times_to_roll = Math.min(parseInt(message[1]), maxRollsPerTip);
//				}
//
//				while(times_to_roll > 0) {
//					roll(msg.user, false);
//					--times_to_roll;
//				}
//			} else if(msg.is_mod === true && !allow_mod_rolls) {
//				msg["X-Spam"] = true;
//				msg.background = "linear-gradient(to right, #FF6666, #FFFFFF)";
//				cb.sendNotice('This model has not allowed mods to use /diceroll.\nThe setting "Allow mods to use the /diceroll command?" needs to be set to "Yes".', msg.user, 'linear-gradient(to right, #FF6666, #FFFFFF)', '#000000', 'bold');
//			}
//    break;

        case 'diceroll':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;
            msg.background = "linear-gradient(to right, #CCCCCC, #FFFFFF)";				
            var times_to_roll = 1;
            if(message.length > 1) {
              times_to_roll = Math.min(parseInt(message[1]), maxRollsPerTip);
            }

            while(times_to_roll > 0) {
              roll(msg.user, false);
              --times_to_roll;
            }
          }
          else {
            msgPrivate = 'Only the broadcaster and the creator can roll the dice without tipping!';
          }
        break;

		default:
		break;

  // END ONMESSAGE ROLL THE DICE GAME MENU
				
				case 'checktimeouts':
					releaseTimeouts();
				break;
					
				case 'paint':
					if (isMark || isModel || isMod) {
						message['X-Spam'] = true;				
						// is user color array 
						if (!userColors[msgParam2]) {
							//nope add them
							userColors[msgParam2] = {username: msgParam2, fbColor: '#333333', bgColor: '#ffffff' };
						}
						if (!userColors[msgParam2].fgColor) {
							userColors[msgParam2].fgColor = '#333333';
						}					
						if (!userColors[msgParam2].bgColor) {
							userColors[msgParam2].bgColor = '#ffffff';
						}
						
						if (msgParam3 == 'reset' || msgParam3 == 'default') {
							delete userColors[msgParam2];
						}
						else {
							userColors[msgParam2].fgColor = msgParam3;
							
							if (msgParam4) {
								userColors[msgParam2].bgColor = msgParam4;
							}
						}
						msgPrivate = "Changed color for user " + msgParam2 + "!";
						cb.sendNotice(name + ' changed your colors!',msgParam2,botAlertBg,'','bold');
					}
					else {
						msgPrivate = 'Only the broadcaster, mods, and the creator can paint other users!';
					}
				break;
				
//				case 'colors':
//					message['X-Spam'] = true;				
//					// is user color array 
//					if (!userColors[name]) {
//						//nope add them
//						userColors[name] = {username: name, fbColor: '#333333', bgColor: '#ffffff' };
//					}
//					if (!userColors[name].fgColor) {
//						userColors[name].fgColor = '#333333';
//					}					
//					if (!userColors[name].bgColor) {
//						userColors[name].bgColor = '#ffffff';
//					}
//					
//					if (msgParam2 == 'reset' || msgParam2 == 'default') {
//						delete userColors[name];
//					}
//					else {
//						userColors[name].fgColor = msgParam2;
//						
//						if (msgParam3) {
//							userColors[name].bgColor = msgParam3;
//						}
//					}
//					msgPrivate = "Your Colors have been changed!";
//				break;
				
//				case 'color':
//				case 'text':
//				case 'fgcolor':
//				case 'fg':
//					message['X-Spam'] = true;				
//					// is user color array 
//					if (!userColors[name]) {
//						//nope add them
//						userColors[name] = {username: name, fbColor: '#333333', bgColor: '#ffffff' };
//					}
//					if (!userColors[name].fgColor) {
//						userColors[name].fgColor = '#333333';
//					}					
//					if (!userColors[name].bgColor) {
//						userColors[name].bgColor = '#ffffff';
//					}
//					
//					if (msgParam2 == 'reset' || msgParam2 == 'default') {
//						delete userColors[name];
//					}
//					else {
//						userColors[name].fgColor = msgParam2;
//					}
//					msgPrivate = "Your text color has been changed!";
//				break;
				
//				case 'background':
//				case 'bg':
//				case 'bgcolor':
//					message['X-Spam'] = true;				
//					// is user color array 
//					if (!userColors[name]) {
//						//nope add them
//						userColors[name] = {username: name, fbColor: '#333333', bgColor: '#ffffff' };
//					}
//					if (!userColors[name].fgColor) {
//						userColors[name].fgColor = '#333333';
//					}					
//					if (!userColors[name].bgColor) {
//						userColors[name].bgColor = '#ffffff';
//					}
//					
//					if (msgParam2 == 'reset' || msgParam2 == 'default') {
//						delete userColors[name];
//					}
//					else {
//						userColors[name].bgColor = msgParam2;
//					}	
//					msgPrivate = "Your background color has been changed!";
//				break;
				
				case 'view':
				case 'show':
				case 'list':
					// which user array do we need to display?
					var showOutput = true;
					message['X-Spam'] = true;
					
					switch(msgParam2) {
	
						case "ghost":
							userArray = ghostUsersArray;
						break;
						
						case "timeout":
							userArray = timeoutUsersArray;
						break;
						
						case "princes":
						case "prince":
							userArray = princeUsersArray;
						break;
						
						case "slaves":
						case "slave":
							userArray = slaveUsersArray;
            break;
            
						case "donkeys":
						case "donkey":
							userArray = donkeyUsersArray;
						break;
						
						case "lovers":
						case "lover":
							userArray = loverUsersArray;
						break;

						case "husband":
						case "husbands":
							userArray = husbandUsersArray;
            break;
            
            case "lord":
            case "lords":
              userArray = lordUsersArray;
            break;
						
						default:
							showOutput = false;
							msgPrivate = "You must provide a group name to list: donkeys princes slaves lovers husbands lords";
						break;

					}
					if (showOutput === true) {
						userList = getUsers(userArray);
						arrayProperName = msgParam2.charAt(0).toUpperCase() + msgParam2.substring(1);
						
						if (userList.length > 1) {
							divStr = makeDiv('_',userList.length,50);
							msgPrivate = divStr + '\n' + arrayProperName + ' Users\n';
							msgPrivate += userList;
							msgPrivate += '\n' + divStr;
						}
						else {
							msgPrivate = 'No ' + arrayProperName + ' users found!';
						}
						
						if (!isModel) {
							msgModel = name + ' viewed the list ' + arrayProperName + ' Users.';
						}
					}					
				break;
				
				case 'useradd':
				case 'adduser':
				case 'add':
				case 'a':
				if (isMark || isModel || isMod) {
          message['X-Spam'] = true;
					var validSyntax = true;
					// check that we got 3 parameters
					if (msgParam3) {
						// which user array are we updating?
						switch(msgParam2) {

							case "timeout":
							case "t":
							case "to":
								result = addUser(timeoutUsersArray, msgParam3);
								if (result instanceof Array) {
									timeoutUsersArray = result;
									msgPublic = name + ' put ' + msgParam3 + ' in timeout!!! They will not be able to type until released!';
									if (msgParam4 ) {
										// command has number of minutes
										result2 = addReleaseTime(timeoutReleaseArray, msgParam3, msgParam4);
										if (result2 instanceof Array) {
											timeoutReleaseArray = result2;
											minutes = 'minutes';
											if (msgParam4 == '1') minutes = 'minute';
											msgPublic = name + ' put ' + msgParam3 + ' in timeout for ' + msgParam4 + ' ' + minutes + '!!! They will not be able to type until released!';
										}
										else {
											if (result == 'duplicate') {
												msgPrivate = 'Failed to put user ' + msgParam3 + ' in timeout they are already scheduled for release!';
											}
											else {
												msgPrivate = 'Failed to add user ' + msgParam3 + ' to release schedule. Something went wrong!';
											}										
										}
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to put user ' + msgParam3 + ' in timeout they are already in timeout!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to timeout. Something went wrong!';
									}
								}
							break;

							case "ghost":
								result = addUser(ghostUsersArray, msgParam3);
								if (result instanceof Array) {
									ghostUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Ghosts!';
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Ghosts!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to Ghosts. Something went wrong!';
									}
								}
							break;
							
							case "princes":
							case "prince":
								result = addUser(princeUsersArray, msgParam3);
								if (result instanceof Array) {
									princeUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Princes!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to the Prince list in the bot config!';
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already a Prince!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' as a Prince. Something went wrong!';
									}
								}
							break;
							
							case "slaves":
							case "slave":
								result = addUser(slaveUsersArray, msgParam3);
								if (result instanceof Array) {
									slaveUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Slaves!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to Slaves in the bot config!';
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Slaves!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to Slaves. Something went wrong!';
									}
								}							
              break;
              
							case "donkeys":
							case "donkey":
								result = addUser(donkeyUsersArray, msgParam3);
								if (result instanceof Array) {
									donkeyUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Donkeys!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to Donkeys in the bot config!';
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Donkeys!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to Donkeys. Something went wrong!';
									}
								}							
							break;
							
							case "lovers":
							case "lover":
								result = addUser(loverUsersArray, msgParam3);
								if (result instanceof Array) {
									loverUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Lovers!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to Lovers in the bot config!';
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Lovers!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to Lovers. Something went wrong!';
									}
								}								
							break;
							
							case "husband":
							case "husbands":
								result = addUser(husbandUsersArray, msgParam3);
								if (result instanceof Array) {
									husbandUsersArray = result;
									msgPublic = name + ' added ' + msgParam3 + ' to the list of Husbands!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to Husbands in the bot config!';
									}
								}
								else {
									if (result == 'duplicate') {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Husbands!';
									}
									else {
										msgPrivate = 'Failed to add user ' + msgParam3 + ' to Husbands. Something went wrong!';
									}
								}							
              break;
              
              case "lord":
              case "lords":
                result = addUser(lordUsersArray, msgParam3);
                if (result instanceof Array) {
                  lordUsersArray = result;
                  msgPublic = name + ' added ' + msgParam3 + ' to the list of Lords!';
                  // if model didn't issue command remind model to update the bot
                  if (!isModel) {
                    msgModel = modelName + ', don\'t forget to add ' + msgParam3 + ' to Lords in the bot config!';
                  }
                }
                else {
                  if (result == 'duplicate') {
                    msgPrivate = 'Failed to add user ' + msgParam3 + ' because they are already in Lords!';
                  }
                  else {
                    msgPrivate = 'Failed to add user ' + msgParam3 + ' to Lords. Something went wrong!';
                  }
                }							
              break;
							
							default:
								validSyntax = false;
								msgPrivate = 'You didn\'t supply a valid group to add the user to. Valid groups are:\n';
								msgPrivate += 'donkey prince slave lover husband lord ... choose only one.';
							break;
						}
					}
					else {
						validSyntax = false;
						msgPrivate = 'You must provide the group and the username you wish to add. For example,\n' + botTrigger + ' adduser prince someusername\n';
						msgPrivate += 'or ' + botTrigger + ' adduser husband someuser';
					}
				}
				else {
					msgPrivate = 'Only the brodcaster, mods, and the creator can add users to groups!';
				}
				if (validSyntax === true) {
					message['X-Spam'] = true;
				}				
				break;
				
				case 'userdel':
				case 'deluser':
				case 'delete':
				case 'remove':
				case 'd':
				case 'del':
				if (isMark || isModel || isMod) {	
          message['X-Spam'] = true;
					var validSyntax = true;
					// check that we got 3 parameters
					if (msgParam3) {
						// which user array are we updating?
						switch(msgParam2) {
							
							case "timeout":
							case "t":
							case "to":
								result = delUser(timeoutUsersArray, msgParam3);
								if (result instanceof Array) {
									timeoutUsersArray = result;
									msgPublic = name + ' released ' + msgParam3 + ' from timeout!!';
									
									// delete any release time
									result2  = delReleaseTime(timeoutReleaseArray, msgParam3);
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from timeout because they are not in timeout!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from timeout. Something went wrong!';
									}
								}
							break;
							
							case "princes":
							case "prince":
								result = delUser(princeUsersArray, msgParam3);
								if (result instanceof Array) {
									princeUsersArray = result;
									msgPublic = name + ' removed ' + msgParam3 + ' from the Prince list!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from the Prince list in the bot config!';
									}
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not a Prince!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' as a Prince. Something went wrong!';
									}
								}
							break;

							case "ghost":
								result = delUser(ghostUsersArray, msgParam3);
								if (result instanceof Array) {
									ghostUsersArray = result;
									msgPublic = name + ' removed ' + msgParam3 + ' from the Ghost list!';
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Ghosts!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Ghosts. Something went wrong!';
									}
								}
							break;
							
							case "slaves":
							case "slave":
								result = delUser(slaveUsersArray, msgParam3);
								if (result instanceof Array) {
									slaveUsersArray = result;
									msgPublic = name + ' removed ' + msgParam3 + ' from the list of Slaves!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from Slaves in the bot config!';
									}
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Slaves!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Slaves. Something went wrong!';
									}
								}							
              break;
              
              case "donkeys":
              case "donkey":
                result = delUser(donkeyUsersArray, msgParam3);
                if (result instanceof Array) {
                  donkeyUsersArray = result;
                  msgPublic = name + ' removed ' + msgParam3 + ' from the list of Donkeys!';
                  // if model didn't issue command remind model to update the bot
                  if (!isModel) {
                    msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from Donkeys in the bot config!';
                  }
                }
                else {
                  if (result == 'notfound') {
                    msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Donkeys!';
                  }
                   else {
                    msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Donkeys. Something went wrong!';
                  }
                 }							
              break;
							
							case "lovers":
							case "lover":
								result = delUser(loverUsersArray, msgParam3);
								if (result instanceof Array) {
									loverUsersArray = result;
									msgPublic = name + ' removed ' + msgParam3 + ' from the list of Lovers!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from Lovers in the bot config!';
									}
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Lovers!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Lovers. Something went wrong!';
									}
								}								
							break;

							case "husband":
							case "husbands":
								result = delUser(husbandUsersArray, msgParam3);
								if (result instanceof Array) {
									husbandUsersArray = result;
									msgPublic = name + ' removed ' + msgParam3 + ' from the list of Husbands!';
									// if model didn't issue command remind model to update the bot
									if (!isModel) {
										msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from Husbands in the bot config!';
									}
								}
								else {
									if (result == 'notfound') {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Husbands!';
									}
									else {
										msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Husbands. Something went wrong!';
									}
								}							
              break;
              
              case "lord":
              case "lords":
                result = delUser(lordUsersArray, msgParam3);
                if (result instanceof Array) {
                  lordUsersArray = result;
                  msgPublic = name + ' removed ' + msgParam3 + ' from the list of Lords!';
                  // if model didn't issue command remind model to update the bot
                  if (!isModel) {
                    msgModel = modelName + ', don\'t forget to remove ' + msgParam3 + ' from Lords in the bot config!';
                  }
                }
                else {
                  if (result == 'notfound') {
                    msgPrivate = 'Failed to remove user ' + msgParam3 + ' because they are not in Lords!';
                  }
                  else {
                    msgPrivate = 'Failed to remove user ' + msgParam3 + ' from Lords. Something went wrong!';
                  }
                }							
              break;
							
							default:
								validSyntax = false;
								msgPrivate = 'You didn\'t supply a valid group to remove the user from. Valid groups are:\n';
								msgPrivate += 'donkey prince slave lover husband lord ... choose only one.';
							break;
						}
					}
					else {
						validSyntax = false;
						msgPrivate = 'You must provide the group and the username you wish to remove. For example,\n' + botTrigger + ' deluser prince someusername\n';
						msgPrivate += 'or ' + botTrigger + ' deluser husband someuser';
					}
				}
				else {
					msgPrivate = 'Only the broadcaster, mods, and the creator can remove users from groups!';
				}
				
				if (validSyntax === true) {
					message['X-Spam'] = true;
				}
				break;
				
				case 'check':
          message['X-Spam'] = true;
					if (msgParam2) {
						message['X-Spam'] = true;
						groupList = checkUser(msgParam2);
						
						msgPrivate = 'User ' + msgParam2 + ' found in: ' + groupList;
					}
				break;
				
				case 'modcommands':
				case 'mods':
					if(isModel || isMark) {
            message['X-Spam'] = true;
						if (msgParam2) {
							message['X-Spam'] = true;
							switch(msgParam2) {
								case "on":
									modCommands = true;
									msgPublic = name + ' has enabled Moderator commands!';
								break;
								
								case "off":
									modCommands = false;
									msgPublic = name + ' has disabled Moderator commands!';							
								break;
								
								default:
									// invalid option
									msgPrivate = 'Invalid option, you must use on or off. Example: ' + botTrigger + ' modcommands off';
								break;
							}
						}
						else {
							// missing on/off value
							msgPrivate = 'Missing option, you must use on or off. Example: ' + botTrigger + ' modcommands on';
						}
					}
					else {
						msgPrivate = 'Only the broadcaster and the creator can enable or disable mod commands!';
					}
				break;

				case 'unmask':
				case 'unmasktimeout':
					if(isMark) {
            message['X-Spam'] = true;
						if (msgParam2) {
							message['X-Spam'] = true;
							switch(msgParam2) {
								case "on":
									unmaskTimeout = true;
									msgPrivate = 'Timeout messages will be sent to you for debugging...';
								break;
								
								case "off":
									unmaskTimeout = false;
									msgPrivate = 'Timeout unmasking disabled...';							
								break;
								
								default:
									// invalid option
									msgPrivate = 'Invalid option, you must use on or off. Example: ' + botTrigger + ' unmask off';
								break;
							}
						}
						else {
							// missing on/off value
							msgPrivate = 'Missing option, you must use on or off. Example: ' + botTrigger + ' unmask on';
						}
					}
					else {
						msgPrivate = 'Only the creator can use the unmask command!';
					}
				break;				
				
				case 'greyemote':
				case 'greyemotes':
				case 'grayemote':
				case 'grayemotes':				
				case 'emotes':
				case 'emote':
				if (isMark || isModel || isMod) {
          message['X-Spam'] = true;
					if (msgParam2) {
						message['X-Spam'] = true;
						switch(msgParam2) {
							case "on":
								allowGreyEmotes = true;
								msgPublic = name + ' has enabled grey emotes!';
							break;
							
							case "off":
								allowGreyEmotes = false;
								msgPublic = name + ' has disabled grey emotes!';							
							break;
							
							default:
								// invalid option
								msgPrivate = 'Invalid option, you must use on or off. Example: ' + botTrigger + ' greyemotes off';
							break;
						}
					}
					else {
						// missing on/off value
						msgPrivate = 'Missing option, you must use on or off. Example: ' + botTrigger + ' greyemotes on';
					}
				}
				else {
					msgPrivate = 'Only the broadcaster, mods and the creator can disable or enable grey emotes!';
				}
				break;
				
				case 'greets':
				case 'greetings':
					if(isModel || isMark) {
            message['X-Spam'] = true;
						if (msgParam2) {
							message['X-Spam'] = true;
							switch(msgParam2) {
								case "on":
									userGreets = true;
									msgPublic = name + ' has enabled User Greetings!';
								break;
								
								case "off":
									userGreets = false;
									msgPublic = name + ' has disabled User Greetings!';							
								break;
								
								default:
									// invalid option
									msgPrivate = 'Invalid option, you must use on or off. Example: ' + botTrigger + ' greets off';
								break;
							}
						}
						else {
							// missing on/off value
							msgPrivate = 'Missing option, you must use on or off. Example: ' + botTrigger + ' greets on';
						}
					}
					else {
						msgPrivate = 'Only the broadcaster and the creator can enable or disable user greetings!';
					}
				break;

        case 'status':
        case 'announce':
          if (isMark || isModel || isMod) {
            message['X-Spam'] = true;				
            msgPrivate = announceBot();
            }
          else {
            msgPrivate = 'Only the broadcaster, mods and the creator can display the bot status!';
          }
        break;

//				case "status":
//				case "announce":
//					message['X-Spam'] = true;
//					msgPrivate = announceBot();
//				break;
				
//				default:
//					message['X-Spam'] = true;
//					msgPrivate = 'You must provide a command. Type ' + botTrigger + ' help\n ...to get a list of options.';
//				break;
			}

			// Output any notices or command results to user
			if (msgPrivate.length > 0) {
				cb.sendNotice(msgPrivate, name, botMsgBg, botMsgText,'bold');
				msgPrivate = "";
			}
			
			// Output any public notices or command results
			if (msgPublic.length > 0) {
				cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
				msgPublic = "";
			}		

			// Output any messages to the mods
			if (msgMod.length > 0) {
				cb.sendNotice(msgMod,'', botMsgBg, botMsgText,'bold','red');
				msgMod = "";
			}
			
			// Output any messages to the model
			if (msgModel.length > 0) {
				cb.sendNotice(msgModel, modelName, botMsgBg, botMsgText,'bold');
				msgModel = "";
			}
		}
	}
	
	// see if user envoked emotes that should be removed (no grey emotes)
	if (!isInGroup && !isMark && !isModel && !allowGreyEmotes && isGrey) {
		//user is grey, is not in a group, not Mark, not model and grey emotes are not allowed
		if (msg.indexOf(':') > -1) {
			//colon found, replace all with _
			msg = msg.replace(/:([^\s]+)/g,"[blocked emote]");
		}
	}

	var inTimeout = userInArray(timeoutUsersArray, name);
	
	if (!isInGroup && !isMark && !isModel && isGrey && !inTimeout) {	
		// check for specific known advertisements
		
		if (isWordInString("premium cheat",msg) || 
			isWordInString("tokens generator",msg) ||
			isWordInString("token generator",msg) ||			
			isWordInString("premiumcheat",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
							
			message['X-Spam'] = true;
			msg = '[blocked advertisement]';
			result = addUser(timeoutUsersArray, name);
			msgPublic = 'SammyBot put ' + name + ' in timeout for advertising web sites!!! They will not be able to type until released!';
			cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
			msgPublic = "";
		}
		else {
			if (isWordInString("erotimo",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
					
			
				message['X-Spam'] = true;
				msg = '[blocked advertisement]';
				result = addUser(timeoutUsersArray, name);
				msgPublic = 'SammyBot put ' + name + ' in timeout for advertising web sites!!! They will not be able to type until released!';
				cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
				msgPublic = "";
			}
			else {
  // PROTECTION FROM ADVERTISEMENT-BOTS!
				if (isWordInString("freelive",msg) || 
					isWordInString("freewebcam",msg) ||
					isWordInString("net.au",msg) ||	
					isWordInString("xtoy24",msg) ||	
					isWordInString("jerk off with random lady",msg) ||	
					isWordInString("Boys go to 𝖿𝘢p",msg) ||	
					isWordInString("𝖼2𝖼𝚜ex.𝘭ive",msg) ||	
					isWordInString("xtease",msg) ||	
					isWordInString("xtease",msg) ||	
					isWordInString("mastu𝑟bate a𝑙one",msg) ||	
					isWordInString("c𝑢ms𝗁ow.o𝗇li𝗇e",msg) ||	
					isWordInString("his kink",msg) ||	
					isWordInString("𝘩orny.s𝘩ow",msg) ||	
					isWordInString("s𝑙ave.𝑐hat",msg) ||	
          isWordInString("EllaGoCam",msg) ||
          isWordInString("my cam",msg) ||
          isWordInString("watch me c",msg) ||
          isWordInString("c2c",msg) ||
          isWordInString("open cam",msg) ||
          isWordInString(".com ",msg) ||
          isWordInString("dot com",msg) ||
          isWordInString("dot net",msg) ||
          isWordInString(".net",msg) ||
          isWordInString(".net",msg) ||
          isWordInString("wa𝗇𝗇a meet",msg) ||
          isWordInString("daddysgirl",msg) ||
          isWordInString("M𝖾𝖾t hot",msg) ||
          isWordInString("hot 𝘭ady",msg) ||
          isWordInString("𝑐umming",msg) ||
					isWordInString("livecams",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
										
					message['X-Spam'] = true;
					msg = '[blocked advertisement]';
					result = addUser(timeoutUsersArray, name);
					msgPublic = 'SammyBot put ' + name + ' in timeout for advertising web sites!!! They will not be able to type until released!';
					cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
					msgPublic = "";
				}			
			}
		}
		
		// check for message that contain ".com " "dot com" " com " - Update: Used above, just left here in case it is needed again in the future.
		if (isWordInString("jhgkjhfkjfkf6fjhf",msg) || 
				isWordInString("f76ifkuzfiuzfuzfufz",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
								
			message['X-Spam'] = true;
			msg = '[blocked website]';
			result = addUser(timeoutUsersArray, name);
			msgPublic = 'SammyBot put ' + name + ' in timeout for posting a web address! Don\'t put web sites in chat!';
			cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
			msgPublic = "";
		}
		else {
			// check for demands
			if (isWordInString("show ",msg) || 
				isWordInString("open tits",msg) ||
				isWordInString("open bobs",msg) ||
				isWordInString("open tits",msg) ||
				isWordInString("fuck pussy",msg) ||
				isWordInString("open pussy",msg) ||
				isWordInString("pussy baby",msg) ||
				isWordInString("open ass",msg) ||
				isWordInString("fuck your",msg) ||
				isWordInString("fuck ur",msg) ||
				isWordInString("open you ",msg) ||
				isWordInString("open your ",msg) ||
				isWordInString("open ur",msg) ||
				isWordInString("spread",msg) ||
				isWordInString("stick",msg) ||
				isWordInString("fart",msg) ||
				isWordInString("poo",msg) ||
				isWordInString("pee",msg) ||
				isWordInString("peeing",msg) ||
				isWordInString("lick",msg) ||
				isWordInString("asshole",msg) ||
				isWordInString("cunt",msg) ||
				isWordInString("bb",msg) ||
				isWordInString("bby",msg) ||
				isWordInString("mami",msg) ||
				isWordInString("babby",msg) ||
				isWordInString("wide",msg) ||
				isWordInString("tiny tits",msg) ||
				isWordInString("tiny boobs",msg) ||
				isWordInString("tiny titties",msg) ||
				isWordInString("tiny breasts",msg) ||
				isWordInString("small tits",msg) ||
				isWordInString("small boobs",msg) ||
				isWordInString("small titties",msg) ||
				isWordInString("small breasts",msg) ||
				isWordInString("flat",msg) ||
				isWordInString("prvt",msg) ||
				isWordInString("fuck u",msg) ||
				isWordInString("fuck you",msg) ||
				isWordInString("skinnytinyy2",msg) ||
				isWordInString("zoom",msg) ||
				isWordInString("vagina",msg) ||
				isWordInString("cock",msg) ||
				isWordInString("inch",msg) ||
				isWordInString("penis",msg) ||
				isWordInString("bitch",msg) ||
				isWordInString("slut",msg) ||
				isWordInString("whore",msg) ||
				isWordInString("ugly",msg) ||
				isWordInString("fist",msg) ||
				isWordInString("squirt",msg) ||
				isWordInString("twerk",msg) ||
				isWordInString("stand up",msg) ||
				isWordInString("mmmmm",msg) ||
        isWordInString("open bust",msg) ||
        isWordInString("pm me",msg) ||
        isWordInString("open pm",msg) ||
        isWordInString("to pm",msg) ||
        isWordInString("pm?",msg) ||
        isWordInString("pm bb",msg) ||
        isWordInString("pm bby",msg) ||
        isWordInString("send pm",msg) ||
        isWordInString("cum",msg) ||
				isWordInString("open boobs",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
									
				message['X-Spam'] = true;
				msg = '[blocked message]';
				result = addUser(timeoutUsersArray, name);
				result2 = addReleaseTime(timeoutReleaseArray, name, 2);				
				msgPublic = 'SammyBot put ' + name + ' in timeout for 2 minutes for demanding or being disrespectful! This behaviour is not tolerated here!';
				cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
				msgPublic = "";
			}
			else {
				// check for PM requests - Update: Used above, just left here in case it is needed again in the future.
				if (isWordInString("jfd65djzthdjthd",msg) || 
					isWordInString("rdu65dgzdjd",msg)) {
					
					if (unmaskTimeout) {
						cb.sendNotice('*Time Out ' + name + ' said ' + msg,'hello_im_mark',botAlertBg,'','bold');
					}		
					
					message['X-Spam'] = true;
					msg = '[blocked message]';
					result = addUser(timeoutUsersArray, name);
					result2 = addReleaseTime(timeoutReleaseArray, name, 1);				
					msgPublic = 'SammyBot put ' + name + ' in timeout for 1 minute for requesting a private message! NO PM! Type in chat!';
					cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
					msgPublic = "";
				}
				else {
					// check for view cam requests - Update: Used above, just left here in case it is needed again in the future.
					if (isWordInString("kjfkjgfkgffkghfkhgf6",msg) || 
						isWordInString("6ff67zfkfk",msg)) {
						
						if (unmaskTimeout) {
							cb.sendNotice('[UNMASKED] ' + name + ' said: ' + msg,'hello_im_mark',botAlertBg,'','bold');
						}
						message['X-Spam'] = true;
						msg = '[blocked message]';
						result = addUser(timeoutUsersArray, name);
						result2 = addReleaseTime(timeoutReleaseArray, name, 1);				
						msgPublic = 'SammyBot put ' + name + ' in timeout for 1 minute for begging Sammy to view their cam! She doesn\'t want to see your tiny pula!';
						cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
						msgPublic = "";
					}
				}
			}
		}
	}
	else {
		if (inTimeout) {
			message['X-Spam'] = true;
			msg = '[blocked message]';
			msgPublic = "";			
		}
	}
	
	// apply group tags
	if (name == 'addusernameifnecessaryhere') {
		msg = '[Add Custom Group Tag Here]' + ' ' + msg;
	} else {
		if (groupTag) {
			msg = groupTag + ' ' + msg;
		}
	}
	
	// if gender emotes are enabled, prefix message with correct gender
	if (genderEmotes) {
		switch (gender) {
			case 'm':
				genderStr = ':avatar_gen_male';
			break;
			
			case 'f':
				genderStr = ':avatar_gen_female';
			break;
			
			case 's':
				genderStr = ':avatar_gen_trans';
			break;
			
			case 'c':
				genderStr = ':avatar_gen_couple';
			break;
			
			default:
				genderStr = ':avatar_gen_unknown';
			break;
		}
		
		// special user icons
//		if (isMark) {
//			genderStr= ':avatar_gen_male [' + markArrayTag + ']';
//			message['background'] = markArrayBackground;
//			message['c'] = markArrayColor;
//		}
		if (isMark) {
			genderStr= ':nomoneyicon';
			message['background'] = markArrayBackground;
			message['c'] = markArrayColor;
		}
		
//		if (isModel) {
//			genderStr = ':icon99';
//		}
		if (isModel) {
      genderStr = ':icon99 [Princesa]';
//      message['background'] = sammyArrayBackground;
//      message['c'] = sammyArrayColor;
		}

   	if (name == 'hi_mum_it_is_me_jxxxy') {
    	genderStr = ':donkeyicon1';
    }

    if (name == 'crazyjempy') {
      genderStr = ':donkeyicon1';
    }

    if (name == 'kumpekjekken_v2') {
//      genderStr = ':donkeyicon1';
    message['c'] = kumpekjekkenArrayColor;
    }

		msg = genderStr + ' ' + msg;
  }	

	// show notice if user is in timeout
	if ( userInArray(timeoutUsersArray, name) ) {
	
		thisMessageTime = (new Date).getTime();
		// simple trottle timeout message output to keep users from flooding room
		if ( (lastMessageName == name && (thisMessageTime > (lastMessgeTime + 4000))) || lastMessageName != name ) {
			selectedTimeoutMessage = Math.floor(Math.random() * 5) + 1;
			msg = timeoutMessages[selectedTimeoutMessage];
			lastMessgeTime = (new Date).getTime();
			lastMessageName = name;
		}
		else {
			message['X-Spam'] = true;
			msg = "";
			cb.sendNotice("Timeout Flood Protector Enabled! Message Blocked! Stop trying to flood the room! [only you are seeing this]", name, botMsgBg, botMsgText,'bold');
		}
	}
	else {
		if ( userInArray(ghostUsersArray, name) ) {
		
				message['X-Spam'] = true;
				msg = '[Ghost] ' + name + ' says: ' + message['m'];
				cb.sendNotice(msg,'', botGhostBg,'','bold');
		}
	}
	
	// does user have modified colors
	if (!userColors[name]) {
		// do nothing
	}
	else {
		// apply colors to message if in color array
		if (userColors[name].fgColor) {
			message['c'] = userColors[name].fgColor;
		}					
		if (userColors[name].bgColor) {
			message['background'] = userColors[name].bgColor;
		}
  }
  
	
	// return final altered message
	message['m'] = msg;
  return message;
  
}); //end onMessage

/*
 * bot functions
 */

/*
 * return string of tippers to display
 * can limit number of tippers returned to show only top 10, top 5 etc.
 */
function getTippers(topNumber) {

	var topTippers = new Array();
	var tempTippers = objectToArray(tippers);
	var output = '';
	
	tempTippers.sort(dynamicSort('-tips'));
	
	if (topNumber > 0) {
		topTippers = tempTippers.slice(0,topNumber);
		
		if (topTippers.length == 1) {
			output = '\nTop Tipper';  
		}
		else {
			output = '\nTop ' + topTippers.length + ' Tippers';
		}
	}
	else {
		topTippers = tempTippers;
		output = '\nAll Tippers';
	}
	
	if (topTippers.length > 0) {
		for (i = 0; i < topTippers.length; i++) {
			output += '\n' + topTippers[i].username + ': ' + topTippers[i].tips;
		}
	}
	else {
		output = '\nThere have been no tippers since the bot started!\n';
	}
	
	return output + '\n';
}
 
 /*
 * check if a word or phrase is in a string
 */
function isWordInString(word,str) {
    var re = new RegExp(word,"i");
    var n = str.search(re);
	if (n > -1) {
		return true;
	}
	else {
		return false;
	}
} 
 
/*
 * add a user to the release array
 */
function addReleaseTime(userArray, username, timeoutMinutes) {
	var userArrayLength = userArray.length;
	username = username.toLowerCase();
	
	// check if username is in userarray
	usernameExists = userInReleaseArray(userArray, username);
	
	if (usernameExists === true) {
		return "duplicate"; // username found in array, return duplicate
	}
	else {
		// add username to array
		currentEpoch = (new Date).getTime();
		userArray[userArrayLength] = new Array(username,currentEpoch + (timeoutMinutes * 60000)); 
		//userArray[userArrayLength][0] = username;
		//userArray[userArrayLength][1] = currentEpoch + timeoutMinutes * 60000;

		// check to see that addition of user worked
		usernameExists = userInReleaseArray(userArray, username);
		if (usernameExists === true) {
			return userArray; // it worked, return the array
		}
		else {
			return "failed"; // failed, return failed
		}
	}
}

function delReleaseTime(userArray, username) {
	var releaseArrayLength = userArray.length;
	var userElement = -1;

	username = username.toLowerCase();
	
	if (userInReleaseArray(userArray, username)) {
		userElement = getRelaseArrayElement(userArray, username);
		if (userElement > -1) {
			tempArray = removeArrayElement(userArray, userElement);
			if (!userInReleaseArray(userArray, username)) {
				// user was removed
				return tempArray;
			}
			else {
				// user was not removed, failed
				return "failed";
			}
		}
		else {
			//user element was not in array for some reason
			return "failed";
		}
	}
	else {
	  return 'notfound';
	}	
}
 
/*
 * remove users from timeout if their time has expired
 */ 
function releaseTimeouts() {
	// set current epoch time
	currentEpoch = (new Date).getTime();
	//loop through all elements in timeout release array
	for (i = 0; i < timeoutReleaseArray.length; i++) {
		if (timeoutReleaseArray[i][1] < currentEpoch) {
			username = timeoutReleaseArray[i][0];
			delUser(timeoutUsersArray, username);
			msgPublic += "User " + username + " has been released from timeout!\n";
			delReleaseTime(timeoutReleaseArray, username);
		}	
	}
	
	// setup next check call
	cb.setTimeout(releaseTimeouts, timeoutReleaseInterval * 60000);
	if (msgPublic) {
		cb.sendNotice(msgPublic, '', botMsgBg, botMsgText,'bold');
		msgPublic = "";
	}
}
 
/*
 * display notification message and start interval timer
 */ 
//function displayNotification1() {
//	cb.sendNotice(autoNotice1Text,'',botNoteBg,'','bold');
//	cb.setTimeout(displayNotification1, cb.settings.autoNotice1Interval * 60000);
//}
//
//function displayNotification2() {
//	cb.sendNotice(autoNotice2Text,'',botNoteBg,'','bold');
//	cb.setTimeout(displayNotification2, cb.settings.autoNotice2Interval * 60000);
//}
//
//function displayNotification3() {
//	cb.sendNotice(autoNotice3Text,'',botNoteBg,'','bold');
//	cb.setTimeout(displayNotification3, cb.settings.autoNotice3Interval * 60000);
//}
//
//function displayNotification4() {
//	cb.sendNotice(autoNotice4Text,'',botNoteBg,'','bold');
//	cb.setTimeout(displayNotification4, cb.settings.autoNotice4Interval * 60000);
//}

/*
 * return parameter value from a message string
 * Req: msgString = full message as string
 * Req: splitChr = character to split on (usually space)
 * Req: paramNumber = number of the parameter to return (first is 0)
 * Return: paramValue = value of the requested parameter
 */
function getParam(msgString,splitChr,paramNumber) {
	var tempArray = new Array();
	
	tempArray = msgString.split(splitChr);
	paramValue = tempArray[paramNumber];

	return paramValue;
}

/*
 * build a variable length divider from a character
 * Req: divChr = the character to use for the divier, ie: _ - *
 * Req: strLen = length of the data to be divided (lenth of a string, or fixed)
 * Req: maxDivLen = the max number of characters the div can grow to
 * Return: divStr = string of repeated character that make the divider
 */
function makeDiv(divChr, strLen, maxDivLen) {
	var divLen = 0;
	var divStr = "";
	
	if (strLen > maxDivLen) {
		divLen = maxDivLen; 
	}
	else {
		divLen = strLen;
	}
	
	while (divStr.length < divLen) {
        divStr = divChr + divStr;
    }
    return divStr;	
}

/*
 * return array of users with the new user added, duplicate,
 * or error string.
 * Req: userArray = array of users to add the new user to
 * Req: username = username of new user
 * Return: array of users with new users added
 * On error: return "duplicate" if username in user array already
 * On error: return "failed" if user no duplicate and wasn't added
 */
function addUser(userArray, username) {
	var userArrayLength = userArray.length;
	username = username.toLowerCase();
	
	// check if username is in userarray
	usernameExists = userInArray(userArray, username);
	if (usernameExists === true) {
		return "duplicate"; // username found in array, return duplicate
	}
	else {
		// remove user from all user arrays
		delUserFromAll(username);
		
		// add username to array
		userArray[userArrayLength] = username;

		// check to see that addition of user worked
		usernameExists = userInArray(userArray, username);
		if (usernameExists === true) {
			return userArray; // it worked, return the array
		}
		else {
			return "failed"; // failed, return failed
		}
	}
}


/*
 * return array of users with the new user removed, duplicate,
 * or error string.
 * Req: userArray = array of users to add the new user to
 * Req: username = username of new user
 * Return: array of users with user removed
 * On error: return "notfound" if username not in user array
 * On error: return "failed" if user no duplicate and wasn't added
 */
function delUser(userArray, username) {
	var userArrayLength = userArray.length;
	var userElement = -1;

	username = username.toLowerCase();
	
	if (userInArray(userArray, username)) {
		userElement = getArrayElement(userArray, username);
		if (userElement > -1) {
			tempArray = removeArrayElement(userArray, userElement);
		
			if (!userInArray(userArray, username)) {
				// user was removed
				return tempArray;
			}
			else {
				// user was not removed, failed
				return "failed";
			}
		}
		else {
			//user element was not in array for some reason
			return "failed";
		}
	}
	else {
	  return 'notfound';
	}	
}

/*
 * remove a user from all groups
 * Req: username = name over user to remove
 * Return: none
 */
function delUserFromAll(username) {
	
		if ( userInArray(slaveUsersArray, username) ) {
			result = delUser(slaveUsersArray, username);
			if (result instanceof Array) {
				slaveUsersArray = result;
			}
    }
		if ( userInArray(donkeyUsersArray, username) ) {
			result = delUser(donkeyUsersArray, username);
			if (result instanceof Array) {
				donkeyUsersArray = result;
			}
		}
		if ( userInArray(princeUsersArray, username) ) {
			result = delUser(princeUsersArray, username);
			if (result instanceof Array) {
				princeUsersArray = result;
			}
		}									
		if ( userInArray(loverUsersArray, username) ) {
			result = delUser(loverUsersArray, username);
			if (result instanceof Array) {
				loverUsersArray = result;
			}
		}
		if ( userInArray(husbandUsersArray, username) ) {
			result = delUser(husbandUsersArray, username);
			if (result instanceof Array) {
				husbandUsersArray = result;
      }
    }
    if ( userInArray(lordUsersArray, username) ) {
			result = delUser(lordUsersArray, username);
			if (result instanceof Array) {
				lordUsersArray = result;
      }
		}
}

/* retun group bg color
*/

function getGroupBgColor(username) {
	var bgc = "#ffffff";
	
	if ( userInArray (princeUsersArray, username) ) { bgc = princeColor; }
	else {
		if ( userInArray (slaveUsersArray, username) ) { bgc = slaveColor; }
		else {
			if (userInArray(loverUsersArray, username)) { bgc = loverColor; }
			else {
        if (userInArray(husbandUsersArray, username)) { bgc = husbandColor; }
        else {
          if (userInArray(donkeyUsersArray, username)) { bgc = donkeyColor; }
          else {
            if (userInArray(lordUsersArray, username)) { bgc = lordColor; }
          }
        }
			}
		}
	}
	
	return bgc;
}

/*
 * return the element or index number of an array value
 * Req: sourceArray =  array to parse
 * Req: value = value to find
 * Return: index of the element
 */
function getArrayElement(sourceArray, value) {
	var index = 0;
	
	for (i = 0; i < sourceArray.length; i++) {
		if (sourceArray[i] == value) {
			index = i;
		}	
	}
	return index;
}

/*
 * same as getArrayElement but for timeout release array
 */
function getRelaseArrayElement(sourceArray, value) {
	var index = 0;
	for (i = 0; i < sourceArray.length; i++) {
		if (sourceArray[i][0] == value) {
			index = i;
		}	
	}
	return index;
}

/*
 * dynamic sort function to sort array by a property
 * Borrowed from Asdfghjkl28
 */
function dynamicSort(property) {
    var sortOrder = 1;
    if (property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1, property.length - 1);
    }
    var sortfunc = function (a, b) {
        if (typeof a[property] === "undefined") {
            if (typeof b[property] === "undefined") {
                // both undef
                return 0;
            } else {
                // b ok, a undef
                return -1;
            }
        }
        if (typeof b[property] === "undefined") {
            if (typeof a[property] === "undefined") {
                // both undef
                return 0;
            } else {
                // a ok, b undef
                return 1;
            }
        }

        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    };
    return sortfunc;
}

/* 
 * convert object to an array
 * Borrowed from Asdfghjkl28
 */
function objectToArray(myObj) {
    var arr = [];
    for (var i in myObj) {
        if (myObj.hasOwnProperty(i)) {
            arr.push(myObj[i]);
        }
    }
    return arr;
} 

/*
 * return an array with the indicated element removed
 * Req: sourceArray = array to be modified
 * Req: element = element to be removed
 * Return: the modified array
 */
function removeArrayElement(sourceArray,element) {
	
	sourceArray.splice(element, 1);
	
	return sourceArray;
}

/*
 * return boolean if user is in user array
 * Req: userArray = array of users to parse
 * Req: userName = name of user to parse fr
 * Returns: userFound = true or false
 */
function userInArray(userArray, username) {
	var userFound = false;
	username = username.toLowerCase();
	
	if (userArray.length > 0) {
		for(i=0; i < userArray.length; i++) {
			if (userArray[i] == username) userFound = true;
		}
	}
	
	return userFound;
}



/*
 * return boolean if user is in user release array
 * Req: timeoutReleaseArray = array of users to parse
 * Req: username = name of user to parse fr
 * Returns: userFound = true or false
 */
function userInReleaseArray(userArray, username) {
	var userFound = false;
	username = username.toLowerCase();
	
	if (userArray.length > 0) {
		for(i=0; i < userArray.length; i++) {
			if (userArray[i][0] == username) userFound = true;
		}
	}
	
	return userFound;
}


/*
 * return a string of usernames from an array of users
 * Req: userArray = array of users
 * Return: string of of usersnames
 */
function getUsers(userArray) {
	var userList = "";
	
	for (i = 0; i < userArray.length; i++) {
		userList += userArray[i] + ' ';
	}
	
	return userList;
}

/*
 * return list of groups that a user is a member of
 * Req: username = username to find
 * Return: string with list of groups the user was found in
 */
function checkUser(username) {
	var groupList = "";
	username = username.toLowerCase();
	
	if (userInArray(princeUsersArray, username)) groupList += "Princes ";
  if (userInArray(slaveUsersArray, username)) groupList += "Slaves ";
  if (userInArray(donkeyUsersArray, username)) groupList += "Donkeys ";
	if (userInArray(loverUsersArray, username)) groupList += "Lovers ";
  if (userInArray(husbandUsersArray, username)) groupList += "Husbands";
  if (userInArray(lordUsersArray, username)) groupList += "Lords";
	
	return groupList;
}
function notModel() {
	var output = '\n\n' + modelName + '! This bot was created for ';
	output += 'Sammy, you are not her! Please consider having your own ';
	output += 'bot created.\n\n';
	return output;
}
function newStuff() {
	var output = '\nHola ' + modelName + '! ';
	output += 'Bienvenido de nuevo y diviértete!\n';
	return output;
}
function modWelcome() {
	var output = '\nGreetings Moderator...';
	output += 'Sammy\'s Castle Bot version ' + botVersion + ' is running! Please take good care of our favorite model!\n';
	return output;
}
/*
 * Builds user arrays and strings based on data provided by bot
 * config settings
 */
function loadSettings() {
	// grey graphics
	if (cb.settings.allowGreyEmotes == 'Yes') {
		allowGreyEmotes = true;
	}
	else {
		allowGreyEmotes = false;
	}

	// mod commands
	if (cb.settings.modCommands == 'Yes') {
		modCommands = true;
	}
	else {
		modCommands = false;
	}

	// greetings
	if (cb.settings.userGreets == 'Yes') {
		userGreets = true;
	}
	else {
		userGreets = false;
	}

	// gender emotes
	if (cb.settings.genderEmotes == 'Yes') {
		genderEmotes = true;
	}
	else {
		genderEmotes = false;
	}
	
	// load slaves into array and other variables
	if (cb.settings.slaveList) {
		tempStr = cb.settings.slaveList.toLowerCase(); //make names all lowercase
		cb.settings.slaveList = tempStr.trim(); // remove extra spaces
		slaveUsersArray = cb.settings.slaveList.split(' ');
	}
	if (cb.settings.slaveTag) {
		slaveTag = cb.settings.slaveTag.trim();
	}
	if (cb.settings.slaveColor) {
		tempArray = cb.settings.slaveColor.split(' ');
		slaveColor = '#' + tempArray[1];
  }
  
	// load donkeys into array and other variables
	if (cb.settings.donkeyList) {
		tempStr = cb.settings.donkeyList.toLowerCase(); //make names all lowercase
		cb.settings.donkeyList = tempStr.trim(); // remove extra spaces
		donkeyUsersArray = cb.settings.donkeyList.split(' ');
	}
	if (cb.settings.donkeyTag) {
		donkeyTag = cb.settings.donkeyTag.trim();
	}
	if (cb.settings.donkeyColor) {
		tempArray = cb.settings.donkeyColor.split(' ');
		donkeyColor = '#' + tempArray[1];
	}

	// load prince into array and other variables
	if (cb.settings.princeList) {
		tempStr = cb.settings.princeList.toLowerCase(); //make names all lowercase
		cb.settings.princeList = tempStr.trim(); // remove extra spaces
		princeUsersArray = cb.settings.princeList.split(' ');
	}
	if (cb.settings.princeTag) {
		princeTag = cb.settings.princeTag.trim();
	}
	if (cb.settings.princeColor) {
		tempArray = cb.settings.princeColor.split(' ');
		princeColor = '#' + tempArray[1];
	}

	// load lover into array and other variables
	if (cb.settings.loverList) {
		tempStr = cb.settings.loverList.toLowerCase(); //make names all lowercase
		cb.settings.loverList = tempStr.trim(); // remove extra spaces
		loverUsersArray = cb.settings.loverList.split(' ');
	}
	if (cb.settings.loverTag) {
		loverTag = cb.settings.loverTag.trim();
	}
	if (cb.settings.loverColor) {
		tempArray = cb.settings.loverColor.split(' ');
		loverColor = '#' + tempArray[1];
	}	

	// load husband into array and other variables
	if (cb.settings.husbandList) {
		tempStr = cb.settings.husbandList.toLowerCase(); //make names all lowercase
		cb.settings.husbandList = tempStr.trim(); // remove extra spaces
		husbandUsersArray = cb.settings.husbandList.split(' ');
	}
	if (cb.settings.husbandTag) {
		husbandTag = cb.settings.husbandTag.trim();
	}
	if (cb.settings.husbandColor) {
		tempArray = cb.settings.husbandColor.split(' ');
		husbandColor = '#' + tempArray[1];
  }	
  
  	// load lord into array and other variables
	if (cb.settings.lordList) {
		tempStr = cb.settings.lordList.toLowerCase(); //make names all lowercase
		cb.settings.lordList = tempStr.trim(); // remove extra spaces
		lordUsersArray = cb.settings.lordList.split(' ');
	}
	if (cb.settings.lordTag) {
		lordTag = cb.settings.lordTag.trim();
	}
	if (cb.settings.lordColor) {
		tempArray = cb.settings.lordColor.split(' ');
		lordColor = '#' + tempArray[1];
	}	
	
	// load notifications
//	if (cb.settings.autoNotice1) {
//		autoNotice1Text = cb.settings.autoNotice1.trim();
//	}
//	
//	if (cb.settings.autoNotice2) {
//		autoNotice2Text = cb.settings.autoNotice2.trim();	
//  }
//  
//  if (cb.settings.autoNotice3) {
//		autoNotice3Text = cb.settings.autoNotice3.trim();
//  }
//  
//  if (cb.settings.autoNotice4) {
//		autoNotice4Text = cb.settings.autoNotice4.trim();
//	}
}

function announceBot() {
	var divStr="";
	var statusMsg = "";
	divStr = makeDiv('*', 45, 45);
	statusMsg = divStr + '\nSammy\'s Castle Bot ver ' + botVersion + ' last updated ' + botDate + '\nCreated by Mark\n' + divStr + '\n';
	statusMsg += 'Gender Emotes: ';
	if (genderEmotes) {
		statusMsg += 'On';
	}
	else {
		statusMsg += 'Off';
	}
	statusMsg += '\n';
	statusMsg += 'Grey Emotes: ';
	if (allowGreyEmotes) {
		statusMsg += 'On';
	}
	else {
		statusMsg += 'Off';
	}
	statusMsg += '\n';		
	statusMsg += 'Mod Commands: ';
	if (modCommands) {
		statusMsg += 'On';
	}
	else {
		statusMsg += 'Off';
	}
	statusMsg += '\n';
	statusMsg += 'User Greetings: ';
	if (userGreets) {
		statusMsg += 'On';
	}
	else {
		statusMsg += 'Off';
	}
  statusMsg += '\n';
  statusMsg += 'Number of Donkeys: ' + donkeyUsersArray.length + '\n';
  statusMsg += 'Number of Slaves: ' + slaveUsersArray.length + '\n';
	statusMsg += 'Number of Princes: ' + princeUsersArray.length + ' (tip 1000)\n';
	statusMsg += 'Number of Lovers: ' + loverUsersArray.length + ' (tip 2000)\n';
  statusMsg += 'Number of Husbands: ' + husbandUsersArray.length + ' (tip 5000)\n';
  statusMsg += 'Number of Lords: ' + lordUsersArray.length + ' (tip 7500)\n';
	statusMsg += 'Type - ' + botTrigger + ' help - for a list of the commands\n';
	statusMsg += divStr;

	return statusMsg;

}

loadSettings();

cb.sendNotice(announceBot(),'', botMsgBg, botMsgText,'bold');
if (modelName !='skinnytinyy2') cb.sendNotice(notModel(),modelName,botAlertBg,'','bold');
if (modelName == 'skinnytinyy2') cb.sendNotice(newStuff(),modelName,'#000000','#FFFF00','bold');
//if (autoNotice1Text) cb.setTimeout(displayNotification1, cb.settings.autoNotice1Interval * 60000);
//if (autoNotice2Text) cb.setTimeout(displayNotification2, cb.settings.autoNotice2Interval * 60000);
//if (autoNotice3Text) cb.setTimeout(displayNotification3, cb.settings.autoNotice3Interval * 60000);
//if (autoNotice4Text) cb.setTimeout(displayNotification4, cb.settings.autoNotice4Interval * 60000);
// start timeout release event
cb.setTimeout(releaseTimeouts, timeoutReleaseInterval * 60000);

// START FUNCTIONS TIP MENU

function colorChecker(c, d, s) {
	if (typeof c !== "undefined") {
		if ((c.length == 3 || c.length == 6) && /^[0-9A-F]+$/i.test(c)) {
			return "#" + c;
		}
		else if ((c.length == 4 || c.length == 7) && /^#[0-9A-F]+$/i.test(c)) {
			return c;
		}
		else {
			cb.sendNotice("Tip Menu - Error while setting " + s + ". It has to be in a HEX-format. Using default value: " + d + ".", cb.room_slug, "#FFFFFF", "#FF0000", 'bold');
			return (d);
		}
	}
	return (d);
}

function timeLord(time, iden) {
	let timer = parseFloat(time);
	if (timer < 1) {
		cb.sendNotice("Tip Menu - Time lapse for " + iden + " is to short. Using default value.", cb.room_slug, "#FFFFFF", "#FF0000", 'bold');
		timer = 3;
	}
	timer *= 60000;
	timer = parseInt(timer);
	return timer;
}

function msg(t, u, m) {
	//overloading
	if (!m) {
		m = u;
	}
	switch (t) {
		//broadcaster
		case "b":
			cb.sendNotice("Tip Menu to Broadcaster - " + m, cb.room_slug, COLOR.WARNDARK, COLOR.WARNLIGHT, "bold");
			break;
			//to all fall to broadcaster and mod
		case "a":
			cb.sendNotice("Tip Menu - " + m, "", COLOR.BACKGROUND, COLOR.DEFAULT);
			/* falls through */
      //to bc and mod, will fall to mod,
      break;
		case "bm":
			cb.sendNotice("Tip Menu to Broadcaster - " + m, cb.room_slug, COLOR.WARNDARK, COLOR.WARNLIGHT, "bold");
			/* falls through */
      //to mod
      break;
		case "m":
			cb.sendNotice("Tip Menu to mods - " + m, "", COLOR.BACKGROUND, COLOR.DEFAULT, "bold", "red");
			break;
			//using command when not a mod
		case "nm":
			cb.sendNotice("Tip Menu - This command only works for broadcasters and mods", u, COLOR.WARNDARK, COLOR.WARNLIGHT, "bold");
			break;
			//sending a warning to a user
		case "w":
			cb.sendNotice("Tip Menu - " + m, u, COLOR.WARNDARK, COLOR.WARNLIGHT, "bold");
			break;
			//silent notice ( no app name) to a user
		case "s":
			cb.sendNotice(m, u, "#E6E6E6", "#737373");
			break;
			//notice with app name to user
		case "n":
			cb.sendNotice("Tip Menu - " + m, u, "#FFFFFF", "#0629AC");
			break;
			//dev
		case "d":
			cb.sendNotice("Tip Menu to Dev - " + m, "hello_im_mark", COLOR.DEFAULT, COLOR.BACKGROUND);
			break;
		default:
			cb.sendNotice("Tip Menu - " + m, u, COLOR.BACKGROUND, COLOR.DEFAULT);
			break;
	}
}

function chatAd() {
	if (TIPMENU.enable) {
		if (TIPMENU.short && TIPMENU.initToken) {
			cb.sendNotice('Tip menu is active. It will be shown regularly in the chat!', '', TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
		}
		else if (TIPMENU.part1 !== 'Tip Menu Part 1: \n' && TIPMENU.initToken) {
			if (TIPMENU.partToken === 1) {
				cb.sendNotice(TIPMENU.part1, '', TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
				TIPMENU.partToken = 2;
			}
			else if (TIPMENU.partToken === 2) {
				cb.sendNotice(TIPMENU.part2, '', TIPMENU.bgColor2, TIPMENU.txtColor2, 'bold');
				TIPMENU.partToken = 1;
			}
		}
		else if (TIPMENU.full !== 'Tip Menu: ') {
			cb.sendNotice(TIPMENU.full, '', TIPMENU.bgColor1, TIPMENU.txtColor1, 'bold');
			if (!TIPMENU.initToken) {
				TIPMENU.initToken = true;
			}
		}
		else {
			cb.sendNotice("Something went wrong with the menu.", '', "#FFFFFF", "#FF0000", 'bold');
		}
		cb.setTimeout(chatAd, TIPMENU.timer);
	}
}

function menuSanitize() {
	TIPMENU.full = 'Tip Menu: ';
	TIPMENU.part1 = 'Tip Menu Part 1: \n';
	TIPMENU.part2 = 'Tip Menu Part 2: \n';
	let menuArray = [];
	let menuArray1 = [];
	let menuArray2 = [];
	let sorted = [];
	let menuL = TIPMENU.prices.length;
	for (let i = 0; i < menuL; i++) {
		sorted.push({
			"prices": TIPMENU.prices[i],
			"id": i
		});
	}
	if (cb.settings.listSort !== 'Do not sort the list') {
		sorted.sort(function(a, b) {
			return a.prices - b.prices;
		});
		if (cb.settings.listSort === 'Descending') {
			sorted.reverse();
		}
	}
	for (let j = 0; j < sorted.length; j++) {
		if (TIPMENU.prices[sorted[j].id] !== 0) {
			menuArray.push(TIPMENU.items[sorted[j].id] + ' (' + TIPMENU.prices[sorted[j].id] + ') ');
		}
	}
	TIPMENU.full += menuArray.join(TIPMENU.sepChar);
	if (cb.settings.listSplit === 'Split the list in 2') {
		if (menuArray.length < 8) {
			cb.sendNotice("Tip Menu - Error - The menu has less than 8 items, it will not be split.", cb.room_slug, "#FFFFFF", "#FF0000", 'bold');
		}
		else {
			let msglength1 = 0;
			let msgHalf = (TIPMENU.full.length - 9) / 2;
			for (let k = 0; k < sorted.length; k++) {
				if (TIPMENU.prices[sorted[k].id] !== 0) {
					if (msglength1 < msgHalf) {
						menuArray1.push(TIPMENU.items[sorted[k].id] + '(' + TIPMENU.prices[sorted[k].id] + ') ');
						msglength1 = menuArray1.join(TIPMENU.sepChar).length;
					}
					else {
						menuArray2.push(TIPMENU.items[sorted[k].id] + '(' + TIPMENU.prices[sorted[k].id] + ') ');
					}
				}
			}
			TIPMENU.part1 += menuArray1.join(TIPMENU.sepChar) + '\n To see the full menu type: /sammybot tipmenu or /sb tipmenu';
			TIPMENU.part2 += menuArray2.join(TIPMENU.sepChar) + '\n To see the full menu type: /sammybot tipmenu or /sb tipmenu';
		}
	}
	TIPMENU.lenght = TIPMENU.prices.length;
	if (TIPMENU.full === 'Tip Menu: ') {
		cb.sendNotice('Error - No menu items found', '', '', TIPMENU.txtColor1, 'bold');
	}
}

function setSepChar() {
	let sepChars = {
		"Vertical Bar": "|",
		"Hearts": ':heart2',
		"Glitter": ':pixelglitter',
		"Flowers": ':tinyflower2',
		"Pixelheart": ':pixelheart',
		"Hearts2": ':Hearts2',
		"Smiley": ':smile',
		"Text Heart": '\u2665',
		"Text Diamond": '\u2666',
		"Text Star": '\u2605'
	};
	if (cb.settings.sepchar === "Custom" && cb.settings.sepcharcustom) {
		TIPMENU.sepChar = cb.settings.sepcharcustom;
	}
	else {
		TIPMENU.sepChar = sepChars[cb.settings.sepchar];
	}
	TIPMENU.sepChar += " ";
}

function initMenu() {
	if (TIPMENU.enable) {
		TIPMENU.txtColor1 = colorChecker(cb.settings.menutxtcolor1, '#F10060', "Tip Menu text color 1");
		TIPMENU.bgColor1 = colorChecker(cb.settings.menubgcolor1, '#FFFFFF', "Tip Menu background color 1");
		if (cb.settings.listSplit === 'Split the list in 2') {
			TIPMENU.txtColor2 = colorChecker(cb.settings.menutxtcolor2, '#F10060', "Tip Menu text color 2");
			TIPMENU.bgColor2 = colorChecker(cb.settings.menubgcolor2, '#FFFFFF', "Tip Menu background color 2");
		}
		TIPMENU.timer = timeLord(cb.settings.menuTimer, "Tip Menu");
		setSepChar();

		for (let j = 0; j <= TIPMENU.size; j++) {
			if (cb.settings['item' + j] !== '' && cb.settings['itemprice' + j] > 0) {
				if (cbjs.arrayContains(TIPMENU.prices, cb.settings['itemprice' + j])) {
					cb.sendNotice("Tip Menu - " + cb.settings['itemprice' + j] + " is already on the menu. It is recommended to have different prices for each item.", cb.room_slug, "#FFFFFF", "#FF0000");
				}
				TIPMENU.prices.push(cb.settings['itemprice' + j]);
				TIPMENU.items.push(cb.settings['item' + j]);
			}
		}
		menuSanitize();
		chatAd();
	}
}
initMenu();

// END FUNCTIONS TIP MENU

// START ROLL THE DICE GAME

// from: https://chaturbate.com/apps/app_details/a-bettter-dice-roller-by-aety/?version=&slot=1

// 25 because I got tired after uploading 25 gifs ;>_>
// if someone wants to get in touch with me about updating/improving
// or adding more dice gifs feel free to leave a comment etc
// I *should* see it
var maxPrizes = 25;

for(var i=5; i <= maxPrizes; i++) {
	cb.settings_choices.push({
		name: 'prize_' + i,
		type: 'str',
		label: 'Prize ' + i,
		required: false
	});
}

// We're pushing these so that we can put them after the prizes that we want to push with a loop
// there are better ways to deal with and organize this code
cb.settings_choices.push({name: 'miscellaneous_section_label', type:'choice', label:'################ Advanced Settings ################', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_desc_label', type:'choice', label:'##### (Safe to Ignore Everything Below this Point) #####', required: false});
cb.settings_choices.push({
		name: 'mod_rolls', type: 'choice',
		label: 'Allow mods to use the /diceroll command?',
		choice1: 'Yes', choice2: 'No',
		defaultValue: 'No'
	});
cb.settings_choices.push({name: 'cmd_prefix', type: 'str', minLength: 1, maxLength: 1, label: 'Prefix for bot commands. (Might want to change if you have other bots using the same commands.)', defaultValue: '/'});
cb.settings_choices.push({name: 'die_img_prefix', type: 'str', label: 'Prefix for die gifs ("prefix#" only change if you know what you\'re doing. :80ngenericdie_1 through :80ngenericdie_25)', defaultValue: ':80ngenericdie_'});
cb.settings_choices.push({name: 'miscellaneous_section_colors_label', type:'choice', label:'#################### Colors ####################', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_notice_label', type:'choice', label:'################ Notice ################', required: false});
cb.settings_choices.push({name: 'notice_fg_color', type: 'str', label: 'Bot advertisement text color (hex code for color make sure you include the # in front)', defaultValue: '#FFF300', required: false});
cb.settings_choices.push({name: 'notice_bg_color', type: 'str', label: 'Bot advertisement background color (hex code for color make sure you include the # in front)', defaultValue: '#FF00B4', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_prizes_label', type:'choice', label:'################ Prizes ################', required: false});
cb.settings_choices.push({name: 'prize_fg_color', type: 'str', label: 'Prize text color (hex code for color make sure you include the # in front)', defaultValue: '#FFF300', required: false});
cb.settings_choices.push({name: 'prize_bg_color', type: 'str', label: 'Prize background color (hex code for color make sure you include the # in front)', defaultValue: '#FF00B4', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_rare_label', type:'choice', label:'############### Rare Prize ##############', required: false});
cb.settings_choices.push({name: 'rare_fg_color', type: 'str', label: 'Rare Prize text color (hex code for color make sure you include the # in front)', defaultValue: '#FFF300', required: false});
cb.settings_choices.push({name: 'rare_bg_color', type: 'str', label: 'Rare Prize background color (hex code for color make sure you include the # in front)', defaultValue: '#FF00B4', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_info_label', type:'choice', label:'############## Stats and Info ##############', required: false});
cb.settings_choices.push({name: 'miscellaneous_section_info_desc_label', type:'choice', label:'(prizes list, winners, and dice stats etc)', required: false});
cb.settings_choices.push({name: 'info_fg_color', type: 'str', label: 'Prizes and Stats text color (hex code for color make sure you include the # in front)', defaultValue: '#FFF300', required: false});
cb.settings_choices.push({name: 'info_bg_color', type: 'str', label: 'Prizes and Stats background color (hex code for color make sure you include the # in front)', defaultValue: '#FF00B4', required: false});
cb.settings_choices.push({name: 'winners_fg_color', type: 'str', label: 'Winners text color (hex code for color make sure you include the # in front)', defaultValue: '#FFF300', required: false});
cb.settings_choices.push({name: 'winners_bg_color', type: 'str', label: 'Winners background color (hex code for color make sure you include the # in front)', defaultValue: '#FF00B4', required: false});

switch(cb.settings.rare_chance_mult) {
	case '1x':
		rareChance = 1;
		break;
	case '1/2x':
		rareChance = 0.5;
		break;
	case '3/4x':
		rareChance = 0.75;
		break;
	case '1.5x':
		rareChance = 1.5;
		break;
	case '2x':
		rareChance = 2;
		break;
	case '4x':
		rareChance = 4;
		break;
	case '8x':
		rareChance = 8;
		break;
	default:
		rareChance = 1;
		break;
}

var changeSubject = cb.settings.change_room_subject == 'Yes';
var allow_mod_rolls = cb.settings.mod_rolls == 'Yes';
//var cmdPrefix = cb.settings.cmd_prefix;
var diePrefix = cb.settings.die_img_prefix;
var notice_fg = cb.settings.notice_fg_color;
var notice_bg = cb.settings.notice_bg_color;
var lastRoller = '--';
var lastPrizeWon = '--';
var prizes = [];
var stats = {
	'tipCounter': 0,
	'winners': [],
	'rollCounter': 0,
	'rollResultCounts': {}
};

cb.onDrawPanel(function (user) {
	return {
		'template': '3_rows_12_22_31',
		'row1_label': 'Last prize won:',
		'row1_value': lastPrizeWon,
		'row2_label': 'Last player:',
		'row2_value': lastRoller,
		'row3_value': stats.tipCounter + ' ' + ((stats.tipCounter > 1)?'tokens':'token') + ' received / rolled ' + stats.rollCounter + ' time(s)'
	};
});

//cb.onEnter(function (user) {
//	adBlurb(cb.settings.entry_blurb_size, user.user);
//});

function getRandomIntInclusive(min, max) {
	min = Math.ceil(min);
	max = Math.floor(max);
	return Math.floor(Math.random() * (max - min + 1)) + min;
}

function getRandomFloatInclusive(min, max) {
	return Math.random() * (max - min + 1) + min;
}

//function isPrivileged(msg) {
//	return (msg.is_mod === true) || (msg.user == cb.room_slug) ||(msg.user == 'hello_im_mark');
//}

function roll(username, count_towards_rare, send_roll_notice_to) {
	var prize = 'A Thank You!';

	if(count_towards_rare)stats.rollCounter += 1;

	var dieResults = [];
	var total = -numberOfDie;
	for(var i = 0; i < numberOfDie; i++) {
		dieResults[i] = getRandomIntInclusive(1, die[i].sides);
		total += dieResults[i];
	}

	if(usingRares && (stats.rollCounter > minRollsForRare) && (getRandomFloatInclusive(0,100) <= rareChance)) {
		//RARE PRIZE WON!!!
		if(numberOfDie == 1) {
			dieResults[0] = die[0].sides+1;
			total = dieResults[0] - numberOfDie;
		} else {
			if(getRandomIntInclusive(0,1) === 0) {
				dieResults[0] = die[0].sides+1;
				dieResults[1] = die[1].sides;
				total = dieResults[0] + dieResults[1] - numberOfDie;
			} else {
				dieResults[0] = die[0].sides;
				dieResults[1] = die[1].sides+1;
				total = dieResults[0] + dieResults[1] - numberOfDie;
			}
		}
	}

	var winner = false;

	if (total >= 0 && total < prizeCount) {
		if((total+numberOfDie) in stats.rollResultCounts)stats.rollResultCounts[(total+numberOfDie)] += 1;
		else stats.rollResultCounts[(total+numberOfDie)] = 1;
		winner = true;
		prize = prizes[total];
	} else {
		winner = false;
	}

	var msg = ((numberOfDie == 1)?diePrefix + dieResults[0]: diePrefix + dieResults[0] + " " + diePrefix + dieResults[1]) + "\n";
		msg += username + " rolled " + (total+numberOfDie) + "! \n".toUpperCase();
		msg += "Roll #" + stats.rollCounter + " | Prize: " + prize;

	var textColor = '#000000';
	var bgColor = cb.settings.prize_bg_color; // '#D9FAD7';

	if (winner) textColor = cb.settings.prize_fg_color; // '#067D00';
	if (total == prizeCount-1) {
		bgColor = cb.settings.rare_bg_color; // '#FFDBF3';
		textColor = cb.settings.rare_fg_color; // '#A805A6';
	}

	cb.sendNotice(msg, send_roll_notice_to, bgColor, textColor, 'bold');
	lastPrizeWon = prize;
	stats.winners.push("Roll #" + stats.rollCounter + " (" + (total+numberOfDie) + "): " + username + " - " + prize);
	if(stats.winners.length > 20)stats.winners = stats.winners.slice(-21);
	cb.drawPanel();
}

function initPrizes() {
	for (var i = 1; i <= maxPrizes; i++) {
		if(!('prize_' + i in cb.settings) || cb.settings['prize_' + i] === '' || cb.settings['prize_' + i] == '.' || cb.settings['prize_' + i] == ' ')continue;
		if(i%2 == 1)prizes.push(cb.settings['prize_' + i]);
			else prizes.unshift(cb.settings['prize_' + i]);
	}

	prizeCount = prizes.length;
	if(usingRares) {
		if(prizeCount%2 === 0)prizes.push(prizes.shift());
		prizes[prizes.length-1] += " (RARE)";
	}

	for(var j = 0; j < prizeCount; j++) {
		stats.rollResultCounts[(j+numberOfDie)] = 0;
	}

	die[0].sides = Math.floor(((numberOfDie == 1)? ((cb.settings.last_prize_rare == 'Yes')?prizeCount-1:prizeCount) : ((cb.settings.last_prize_rare == 'Yes')?prizeCount:prizeCount+1)/2));
	die[1].sides = Math.ceil(((numberOfDie == 1)? ((cb.settings.last_prize_rare == 'Yes')?prizeCount-1:prizeCount) : ((cb.settings.last_prize_rare == 'Yes')?prizeCount:prizeCount+1)/2));
	cb.log(die[0].sides + " " + die[1].sides);

	// basically this is +2 because only using +1 for unequal dice odds consistently made the rare prize feel too close in likelyhood by default to just one of the least likely prizes
	rareChance *= equalOdds?100/(prizeCount*1.35):100/((die[0].sides+2)*die[1].sides);
	cb.log(rareChance);
}

function statsBlurb(username) {
	var msg = "##### Dice Roll Statistics #####\n";
	for(var rollval in stats.rollResultCounts) {
		msg += "Roll " + rollval + ": " + stats.rollResultCounts[rollval] + "\n";
	}

	msg += "Total Rolls: " + stats.rollCounter;

	cb.sendNotice(msg, username, cb.settings.info_bg_color, cb.settings.info_fg_color, 'bold'); // '#DBFBFF', '#008596'
}

function prizesBlurb(username) {
	var msg = "No Prizes!! D:";
	if (prizes.length) {
		msg = "##### POSSIBLE PRIZES #####";
		for (var i = 0; i < prizeCount; i++) {
			msg += "\nRoll " + (i+numberOfDie) + " - " + prizes[i];
		}
	}
	cb.sendNotice(msg, username, cb.settings.info_bg_color, cb.settings.info_fg_color, 'bold'); // '#DBFBFF', '#008596'
}

function winnersBlurb(username) {
	var msg = "##### LAST 20 WINNERS #####";
	msg += "\nList sorted in chronological order";
	if (stats.winners.length === 0) {
		cb.sendNotice('No one has won anything yet. Roll the dice to win a prize!', username, '', '', 'bold');
	} else {
		var recentWinners = stats.winners.slice(-21);
		for (var i = 0; i < recentWinners.length; i++) msg += "\n" + recentWinners[i];

		cb.sendNotice(msg, username, cb.settings.winners_bg_color, cb.settings.winners_fg_color, 'bold'); // '#FFF0DE', '#8A4900'
	}
}

function adBlurb(blurb_size, username) {
	var msg = "";

	switch(blurb_size) {
	case 'Off':
		break;
	case 'Without "all" or Bot Name':
		msg += "Tip " + rollprice + " " + ((rollprice>1)?'tokens':'token') + " to roll the dice. There are " + prizes.length + " possible prizes.\n";
		if(maxRollsPerTip>1) {
			msg += "You can roll up to " + maxRollsPerTip + " times with a single tip (" + (maxRollsPerTip*rollprice) + " tokens).\n";
			if(perfectMults && rollprice>1) msg += "You must tip exact amounts to roll the dice.\n(1 roll for " + rollprice + " tokens, 2 for " + rollprice*2 + " tokens, but " + Math.ceil(rollprice*1.5) + " tokens won't roll the dice).";
		}
//		msg += "Type /sb prizes to see the list of prizes. Type /sb winners to see a list of the last 20 winners.";
		break;

	case 'Short Blurb':
		msg += "Tip " + rollprice + " " + ((rollprice>1)?'tokens':'token') + " to roll the dice. There are " + prizes.length + " possible prizes.\n";
		if(maxRollsPerTip>1) {
			msg += "You can roll up to " + maxRollsPerTip + " times with a single tip (" + (maxRollsPerTip*rollprice) + " tokens).\n";
			if(perfectMults && rollprice>1) msg += "You must tip exact amounts to roll the dice.";
		}
//		msg += "Type /sb prizes to see the list of prizes. Type /sb winners to see a list of the last 20 winners.";
		break;

	case 'Minimal Blurb':
		msg += "Tip " + rollprice + " " + ((rollprice>1)?'tokens':'token') + " to roll the dice. ";
		break;

	case 'Full Blurb':
	default:
		msg += "Dice Roll Game for Sammy's Castle\n";
		msg += "Tip " + rollprice + " " + ((rollprice>1)?'tokens':'token') + " to roll the dice. There are " + prizes.length + " possible prizes.\n";
		if(maxRollsPerTip>1) {
			msg += "You can roll up to " + maxRollsPerTip + " times with a single tip (" + (maxRollsPerTip*rollprice) + " tokens).\n";
			if(perfectMults && rollprice>1) msg += "You must tip exact amounts to roll the dice.\n(1 roll for " + rollprice + " tokens, 2 for " + rollprice*2 + " tokens, but " + Math.ceil(rollprice*1.5) + " tokens won't roll the dice).";
		}
//		msg += "Type /sb prizes to see the list of prizes. Type /sb winners to see a list of the last 20 winners.";
		break;
	}

	if (msg !== "") {
		cb.sendNotice(msg, username, notice_bg, notice_fg, 'bold');
	}
}

function advertise() {
	adBlurb(cb.settings.blurb_size);
	if(cb.settings.notice_wait_time > 0)cb.setTimeout(advertise, parseInt(cb.settings.notice_wait_time) * 60 * 1000);
}

//function init() {
//	initPrizes();
//	advertise();
//	if (changeSubject) {
//		cb.changeRoomSubject('Tip ' + rollprice + ' ' + ((rollprice>1)?'tokens':'token') + ' to roll the dice and win a prize!');
//	}
//}
//
//init();

// END ROLL THE DICE GAME

// START ROTATING NOTIFIER

function RotatingAd() {
  var msgrotate;
  
      while (cb.settings['msg' + (irotating + 1)] == 0) {      //skip empty messages
           irotating++;
           irotating %= MAXITEMS;
      }
      
     msgrotate = cb.settings['msg' + (irotating + 1)];
     irotating++;
     irotating %= MAXITEMS;
         
      cb.sendNotice(msgrotate,'',cb.settings['msgcolor'],'','bold');
      cb.setTimeout(RotatingAd, (cb.settings.chat_ad * 60000));
}
cb.setTimeout(RotatingAd, (cb.settings.chat_ad * 60000));

function init() {
  initPrizes();
  advertise();
  }
init();

// END ROTATING NOTIFIER