Chaturbate

Apps Home | Create an App
Chinabebe TMG
Author: boobsguy_007
Description Source Code Launch App Current Users
/*--------------------------------------------------------------
 Name:	      		AutoResetGoalHiddenShowCB
 Author:          boobsguy_007
 Last Modified:	  2015-10-28
 

 Version History
 ============================================
 V1.27 2015-10-28:
 ============================================
 -------------------------------------------------------------*/

var appVars = {
  Name: "AutoResetGoalHiddenShowCB", // The name of the application
  Version: 1.27,            // The current version of the application
  ProdMode: true,          // Set to true for actual production ode
  Author: "boobsguy_007",  // The author of this version. 
//  Author: "Bob",  // The author of this version. 
//  Author: "cbcbtst1",      // The author of this version. 
  Debug: false,            // Whether the application is in debug (verbose) mode.  Don't change this in prod
  StartupTime: null,       // The time the application started up.  Don't set this, it gets set at runtime
  Constants: {
    Goals: 4               // The number of goals to permit configuration of in the startup settings window - add to UserConstants below to override per user
  }
};

// colors
var Colors = {AliceBlue: "#F0F8FF", AntiqueWhite: "#FAEBD7", Aqua: "#00FFFF", Aquamarine: "#7FFFD4", Azure: "#F0FFFF", Beige: "#F5F5DC", Bisque: "#FFE4C4", Black: "#000000", BlanchedAlmond: "#FFEBCD", Blue: "#0000FF", BlueViolet: "#8A2BE2", Brown: "#A52A2A", BurlyWood: "#DEB887", CadetBlue: "#5F9EA0", Chartreuse: "#7FFF00", Chocolate: "#D2691E", Coral: "#FF7F50", CornflowerBlue: "#6495ED", Cornsilk: "#FFF8DC", Crimson: "#DC143C", Cyan: "#00FFFF", DarkBlue: "#00008B", DarkCyan: "#008B8B", DarkGoldenRod: "#B8860B", DarkGrey: "#A9A9A9", DarkGreen: "#006400", DarkKhaki: "#BDB76B", DarkMagenta: "#8B008B", DarkOliveGreen: "#556B2F", DarkOrange: "#FF8C00", DarkOrchid: "#9932CC", DarkRed: "#8B0000", DarkSalmon: "#E9967A", DarkSeaGreen: "#8FBC8F", DarkSlateBlue: "#483D8B", DarkSlateGrey: "#2F4F4F", DarkTurquoise: "#00CED1", DarkViolet: "#9400D3", DeepPink: "#FF1493", DeepSkyBlue: "#00BFFF", DimGrey: "#696969", DodgerBlue: "#1E90FF", FireBrick: "#B22222", FloralWhite: "#FFFAF0", ForestGreen: "#228B22", Fuschia: "#FF00FF", Gainsboro: "#DCDCDC", GhostWhite: "#F8F8FF", Gold: "#FFD700", GoldenRod: "#DAA520", Grey: "#808080", Green: "#008000", GreenYellow: "#ADFF2F", HoneyDew: "#F0FFF0", HotPink: "#FF69B4", IndianRed: "#CD5C5C", Indigo: "#4B0082", Ivory: "#FFFFF0", Khaki: "#F0E68C", Lavender: "#E6E6FA", LavenderBlush: "#FFF0F5", LawnGreen: "#7CFC00", LemonChiffon: "#FFFACD", LightBlue: "#ADD8E6", LightCoral: "#F08080", LightCyan: "#E0FFFF", LightGoldenRodYellow: "#FAFAD2", LightGrey: "#D3D3D3", LightGreen: "#90EE90", LightPink: "#FFB6C1", LightSalmon: "#FFA07A", LightSeaGreen: "#20B2AA", LightSkyBlue: "#87CEFA", LightSlateGrey: "#778899", LightSteelBlue: "#B0C4DE", LightYellow: "#FFFFE0", Lime: "#00FF00", LimeGreen: "#32CD32", Linen: "#FAF0E6", Magenta: "#FF00FF", Maroon: "#800000", MediumAquaMarine: "#66CDAA", MediumBlue: "#0000CD", MediumOrchid: "#BA55D3", MediumPurple: "#9370DB", MediumSeaGreen: "#3CB371", MediumSlateBlue: "#7B68EE", MediumSpringGreen: "#00FA9A", MediumTurquoise: "#48D1CC", MediumVioletRed: "#C71585", MidnightBlue: "#191970", MintCream: "#F5FFFA", MistyRose: "#FFE4E1", Moccasin: "#FFE4B5", NavajoWhite: "#FFDEAD", Navy: "#000080", OldLace: "#FDF5E6", Olive: "#808000", OliveDrab: "#6B8E23", Orange: "#FFA500", OrangeRed: "#FF4500", Orchid: "#DA70D6", PaleGoldenRod: "#EEE8AA", PaleGreen: "#98FB98", PaleTurquoise: "#AFEEEE", PaleVioletRed: "#DB7093", PapayaWhip: "#FFEFD5", PeachPuff: "#FFDAB9", Peru: "#CD853F", Pink: "#FFC0CB", Plum: "#DDA0DD", PowderBlue: "#B0E0E6", Purple: "#800080", Red: "#FF0000", RosyBrown: "#BC8F8F", RoyalBlue: "#4169E1", SaddleBrown: "#8B4513", Salmon: "#FA8072", SandyBrown: "#F4A460", SeaGreen: "#2E8B57", SeaShell: "#FFF5EE", Sienna: "#A0522D", Silver: "#C0C0C0", SkyBlue: "#87CEEB", SlateBlue: "#6A5ACD", SlateGrey: "#708090", Snow: "#FFFAFA", SpringGreen: "#00FF7F", SteelBlue: "#4682B4", Tan: "#D2B48C", Teal: "#008080", Thistle: "#D8BFD8", Tomato: "#FF6347", Turquoise: "#40E0D0", Violet: "#EE82EE", Wheat: "#F5DEB3", White: "#FFFFFF", WhiteSmoke: "#F5F5F5", Yellow: "#FFFF00", YellowGreen: "#9ACD32"};

var tipper_colors = {
  legacy: {high_tipper_color: '#9F9', high_total_color: '#CCF'},
  pink: {high_tipper_color: Colors.Pink, high_total_color: Colors.Violet},
  forest: {high_tipper_color: Colors.SpringGreen, high_total_color: Colors.LimeGreen},
  sky: {high_tipper_color: Colors.PowderBlue, high_total_color: Colors.SkyBlue},
  purple: {high_tipper_color: Colors.Orchid, high_total_color: Colors.MediumSlateBlue},
  sunshine: {high_tipper_color: Colors.Yellow, high_total_color: Colors.Gold}
};

var Groups = {
  TokenHolders: 'cyan',
  Tippers: 'blue',
  Fans: 'green',
  Moderators: 'red'
};

var goalSettings = [];
//var cblcUserList = [];
//var cblcIsRunning = false;
var hiddenShowUserList = [];
var ticketUserList = [];

for (var gix = 2; gix <= appVars.Constants.Goals; gix++) {
  goalSettings.push({name: 'goal_' + gix + '_tokens', label: 'Goal ' + gix + ' Tokens', type: 'int', minValue: 0, required: false});
  goalSettings.push({name: 'goal_' + gix + '_multigoals', label: 'MultiGoals (#, blank=none, 0=unlimited', type: 'int', minValue: 0, required: false});
  goalSettings.push({name: 'goal_' + gix + '_desc', label: 'Description', type: 'str', minLength: 0, maxLength: 255, required: false});
}

/*
  {name: 'mod_allow_broadcaster_cmd', label: 'Allow Mods To Use Cmds', type: 'choice', choice1: 'Yes', choice2: 'Yes', defaultValue: 'No'},
  {name: 'progression_mode', label: 'Goal Progression Mode', type: 'choice', choice1: 'Automatic', choice2: 'Manual', defaultValue: 'Manual'},
  {name: 'final_action', label: 'After Last Goal', type: 'choice', choice1: 'Display final-goal-met subject', choice2: 'Loop goals', choice3: 'Start hidden show',  defaultValue: 'Start hidden show'},
  {name: 'keep_no_goal', label: '1st Goal No-Goal', type: 'choice', choice1: 'No', choice2: 'Yes', defaultValue: 'No'},
  {name: 'show_timer_in_subject', label: 'Time-Left In Subject', type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'Yes'},
  {name: 'hide_token_haul', label: 'Hide Total Tokens In Display', type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'No'},
  {name: 'flash_hidden_show_mins', label: 'Flash Show Timer Mins', type: 'int', defaultValue: 1, required: true},
  {name: 'flash_hidden_show_mode', label: 'Flash Show Timer Mode', type: 'choice', choice1: 'Automatic', choice2: 'Manual', defaultValue: 'Manual'},
  {name: 'before_hidden_show_timer_mins', label: 'Timer Mins Until Hidden Show', type: 'int', minValue: 0, maxValue: 99,defaultValue: 5, required: true},
  {name: 'tipper_color_scheme', label: 'Tipper Hilite Color Scheme', type: 'choice', choice1: 'None', choice2: 'Pink', choice3: 'Forest', choice4: 'Sky', choice5: 'Purple', choice6: 'Sunshine', choice7: 'Legacy', choice8: 'Random', defaultValue: 'Legacy'},
  {name: 'before_hidden_show_timer_msg', label: 'Timer Msg Until Hidden Show', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: '%time% minutes left before hidden show starts.\\nHidden show entrance tokens: %bhs% before show start, %dhs% after show starts.\\nCurrent hidden show invitees: %husers%'},
  {name: 'before_hidden_show_timer_emsg', label: 'Times Up Msg Before Hidden Show', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'Hidden show starting now!\\nHidden show starting now!\\nHidden show starting now'},
  {name: 'timer5_msg_mins', label: 'Timer 5 Msg Mins', type: 'int', defaultValue: 0, required: false},
  {name: 'timer5_msg', label: 'Timer 5 Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: ''},
  {name: 'timer6_msg_mins', label: 'Timer 6 Msg Mins', type: 'int', defaultValue: 0, required: false},
  {name: 'timer6_msg', label: 'Timer 6 Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: ''},
  {name: 'goal_1_multigoals', label: 'Goal 1 Multigoals (#, blank=none, 0=unlimited)', type: 'str', minLength: 0, maxLength: 5, required: false, defaultValue: ''},
*/

/*
  {name: 'flash_tokens_amt', label: 'Flash Show Price', type: 'int', defaultValue: 30, required: true},
  {name: 'flash_tips_count_for_hidden', label: 'Flash Price Counts Toward Hidden Show', type: 'choice', choice1: 'Yes', choice2: 'No', defaultValue: 'No'},
  {name: 'ticket_tokens_amt', label: 'Ticket Show Price', type: 'int', defaultValue: 0, required: true},
  {name: 'flash_hidden_msg', label: 'Flash Show Cam Msg', type: 'str', minLength: 1, maxLength: 255, required: false, defaultValue: 'I am doing a private flash show for those who have paid at least %famt% tokens. You can get a private hidden flash for %famt% tokens.'},
  {name: 'ticket_hidden_msg', label: 'Ticket Show Cam Msg', type: 'str', minLength: 1, maxLength: 255, required: false, defaultValue: 'I am doing a private ticket-only hidden show for those who have paid at least %tamt% tokens. You can join by paying %tamt% tokens now.'},
  {name: 'timer1_msg_mins', label: 'Flash Show Interval Msg Mins', type: 'int', defaultValue: 5, required: false},
  {name: 'timer2_msg_mins', label: 'Ticket Show Interval Msg Mins', type: 'int', defaultValue: 0, required: false},
  {name: 'timer1_msg', label: 'Flash Show Interval Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'From %bcstr%: *** I will flash for you privately anytime during normal goal for just %famt%t!! :smile'},
  {name: 'timer2_msg', label: 'Ticket Show Interval Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'From %bcstr%: *** Invite yourself to my private ticket-only shower show for just %tamt%t !! :smile'},

  {name: 'timer3_msg_mins', label: 'Hidden Show Interval Msg Mins', type: 'int', defaultValue: 7, required: false},
  {name: 'timer4_msg_mins', label: 'General Interval Msg Mins', type: 'int', defaultValue: 7, required: false},
  {name: 'timer3_msg', label: 'Hidden Show Interval Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'From %bcstr%: *** All of your goal tips contribute towards my hidden show entrance fee of %bhs%t before hidden show starts. Entrance fee is %dhs%t after hidden show starts. :smile'},
  {name: 'timer4_msg', label: 'General Interval Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'I hope I can bring you a smile, warmth, and excitement in this room! 5t if you like me. 10t if you love me and want a kiss! if you want a private naked flash, just you and me, %famt%t\n\n:kisses4u'},

 **/


cb.settings_choices = [
  {name: 'before_hidden_show_entry_fee', label: 'Before Hidden Show Price', type: 'int', defaultValue: 25, required: true},
  {name: 'during_hidden_show_entry_fee', label: 'During Hidden Show Price', type: 'int', defaultValue: 80, required: true},
  {name: 'final_goal_msg', label: 'Hidden Show Cam Msg', type: 'str', minLength: 0, maxLength: 255, required: false, defaultValue: 'Those who have paid %bhs% tokens are invited to my hidden show! Or join during hidden show for %dhs% tokens.'},
  {name: 'goal_1_tokens', label: 'Goal 1 Tokens', type: 'int', minValue: 1, required: false, defaultValue: 25},
  {name: 'goal_1_multigoals', label: 'MultiGoals (#, blank=none, 0=unlimited', type: 'int', minValue: 0, required: false},
  {name: 'goal_1_desc', label: 'Description', type: 'str', minLength: 1, maxLength: 255, required: true, defaultValue: 'Goal 1'}
];

cb.settings_choices = cb.settings_choices.concat(goalSettings);

var settings = {
  uExceptionPref: '$userException',
  hiddenShowGoal: false,
  progression_mode_manual: true,
  goals: [],
  final_action: 'hidden',
  before_hidden_show_entry_fee: 0,
  during_hidden_show_entry_fee: 0,
  final_goal_msg: 'Goal reached!  Thanks to all tippers!',
  flash_hidden_msg: '',
  ticket_hidden_msg: '',
  highlight_theme: 'legacy',
  show_timer_in_subject: true,
  allow_mod_superuser_cmd: false,
  hide_token_haul: false,
  support_mode: true,
  goals_defined: 0,
  imsg: '',
  emsg: '',
  timerMins: 0,
  timerInfo: [],
  showEmotes: false,
  tipSetOpts: false,
  lbMins: 5,

  toString: function() {
    var settingsStr = '';

    for (var prop in this) {
      if (typeof (this[prop]) === "string" || typeof (this[prop]) === "boolean" || typeof (this[prop]) === "number")
        settingsStr += ", " + prop + ": '" + this[prop] + "'";
    }

    cb.log(settingsStr.substr(2));
    return settingsStr.substr(2);
  }
};

var Msg = {
  toAll: 0xff,
  toB:   0x01,      // Broadcaster
  toM:   0x02,      // Moderator
  toU:   0x04,      // User (specified)
  toG:   0x08,      // Group (specified)
  toO:   0x10,      // Originator
  toBM:  0x03,      // Broadcaster + Moderator
  toMO:  0x12,      // Moderator + Originator, optimized to not send dup msgs
  toBMO: 0x13,      // Broadcaster + Moderator + Originator, optimized to not send dup msgs
  
  sendMsg: function(toType, str, user, bColor, fColor, weight) {
    if (isUndefined(str))
      str = '';
    
    if (isUndefined(bColor))
      bColor = null;
    
    if (isUndefined(fColor))
      fColor = null;
    
    if (isUndefined(weight))
      weight = 'bold';
    
    if (isUndefined(user))
      user = null;
    
    if (toType === Msg.toAll)
        cb.sendNotice(str, null, bColor, fColor, weight, null);

    else {
      if (toType & Msg.toB) {
        if (fColor === null) fColor = Colors.Blue;
        cb.sendNotice(str, cb.room_slug, bColor, fColor, weight, null);
      }
      
      if (toType & Msg.toM) {
        if (fColor === null) fColor = Colors.Blue;
        cb.sendNotice(str, null, bColor, fColor, weight, Groups.Moderators);
      }
      
      if (toType & Msg.toU) {
        if (fColor === null) fColor = Colors.Black;
        cb.sendNotice(str, user, bColor, fColor, weight, null);
      }
      
      if (toType & Msg.toG) {
        if (fColor === null) fColor = Colors.Black;
        cb.sendNotice(str, null, bColor, fColor, weight, user);
      }
      
      if (toType & Msg.toO) {
        if (fColor === null) fColor = Colors.Black;
/***************        
        cb.sendNotice("toType=" + toType + " cb.room_slug=" + cb.room_slug + " modUser=" + modUser + " msgUser=" + msgUser);
****************/        
        if (! (((toType & Msg.toB) &&
                 msgUser === cb.room_slug) ||
                (toType & Msg.toM) &&
                 msgUser === modUser)
              && msgUser !== '')
          cb.sendNotice(str, msgUser, bColor, fColor, weight, null);
      }
    }   
  }
};

var nHiddenShows = 1;
var msg     = {};
var msgUser = '';
var modUser = '';
var tipMsg  = '';
var tipAmt  = '';
var tipModeOpts = false;
var userPref = '$User_';
var roomSubject = '';
var panel = {};
var curRoomSubj = null;

var stats = {
  goalAlreadyReached: false,
  goalReached: false,
  curGoalNo: 0,
  prevGoalNo: 0,
  curGoalSerNo: 0,
  totGoals: 0,
  totGoalAmts: 0,
  totAllTokens: 0,
  totTokensSinceReset: 0,
  totVirtualTokens: 0,
  totVirtualTokensSinceReset: 0,
  mostRecentUser: '',
  mostRecentTip: 0,
  highUser: '',
  highTip: 0,
  totBhsTokens: 0,
  totDhsTokens: 0
};

//---------------------------------------------------------------------------
// goalno reference functions
//---------------------------------------------------------------------------
/*
      goal[0] - unused (marked "unused")
      goal[1] - either valid goal (marked "valid") to be used for normal tipping/goals,
                or dummy goal (marked "dummy") to be used for no goal tipping
      goal[goalList.length - 1] - hidden show goal (marked "hidden")
      when adding goal or changing goal, if specified goal is the "dummy" goal, then change "dummy" to "valid". 
      New goals are always marked "valid"
*/

var goalFirst  = function()  { return 1; };
var goalLast   = function()  { return Math.max(1, goalList.length - 2); };
var goalNew    = function()  { return Math.max(1, goalList.length - 1); };
var goalNew9   = function()  { return goalList.length; };
var goalNext   = function()  { return Math.max(0, Math.min(stats.curGoalNo + 1, goalList.length - 1)); };
var goalPrev   = function()  { return stats.prevGoalNo; };
var goalCur    = function()  { return stats.curGoalNo; };
var goalFirst0 = function()  { return 0; };
var goalLast9  = function()  { return Math.max(0, goalList.length - 1); };
var goalNum    = function(n) { return n; };
var goalTypeDummy   = "dummy";
var goalTypeNormal  = "normal";
var goalTypeHidden  = "hidden";
var goalTypeFinal   = "final";
var goalTypePrivate = "private";

var userListObj  = {};
var goalList     = [];

var tokTypeTotTok = 'totTok',
    tokTypeTotTokThisGoal = 'totTokThisGoal',
    tokTypeHighTok = 'highTok',
    tokTypeHighTokThisGoal = 'highTokThisGoal',
    tokTypeBhsTok = 'bhsTokens',
    tokTypeDhsTok = 'dhsTokens',
    tokTypeFlashTok = 'flashTokens',
    tokTypeTotFlashTok = 'totFlashTokens',
    tokTypeTotFlashTokThisGoal = 'totFlashTokensThisGoal',
    tokTypeTicketTok = 'ticketTokens',
    tokTypeTotTicketTok = 'totTicketTokens';

var tokTypeProp  = {};
tokTypeProp[tokTypeTotTok] = 0;
tokTypeProp[tokTypeTotTokThisGoal] = 0;
tokTypeProp[tokTypeHighTok] = 0;
tokTypeProp[tokTypeHighTokThisGoal] = 0;
tokTypeProp[tokTypeBhsTok] = 0;
tokTypeProp[tokTypeDhsTok] = 0;
tokTypeProp[tokTypeFlashTok] = 0;
tokTypeProp[tokTypeTotFlashTok] = 0;
tokTypeProp[tokTypeTotFlashTokThisGoal] = 0;
tokTypeProp[tokTypeTicketTok] = 0;
tokTypeProp[tokTypeTotTicketTok] = 0;

var tokTypeDesc = {};
tokTypeDesc[tokTypeTotTok] = "Total Tokens";
tokTypeDesc[tokTypeTotTokThisGoal] = "Total Tokens This Goal";
tokTypeDesc[tokTypeHighTok] = "High Tip";
tokTypeDesc[tokTypeHighTokThisGoal] = "High Tip This Goal";
tokTypeDesc[tokTypeBhsTok] = "Before Hidden Show Tokens to Enter";
tokTypeDesc[tokTypeDhsTok] = "During Hidden Show Tokens to Enter";
tokTypeDesc[tokTypeFlashTok] = "Before Flash Show Tokens to Enter";
tokTypeDesc[tokTypeTotFlashTok] = 'Total Flash Tokens';
tokTypeDesc[tokTypeTotFlashTokThisGoal] = 'Total Flash Tokens This Goal';
tokTypeDesc[tokTypeTicketTok] = "Before Ticket Show Tokens to Enter";
tokTypeDesc[tokTypeTotTicketTok] = 'Total Ticket Tokens';

var tokTypeSDesc = {};
tokTypeSDesc[tokTypeTotTok] = "Tot";
tokTypeSDesc[tokTypeTotTokThisGoal] = "TotGoal";
tokTypeSDesc[tokTypeHighTok] = "HiTip";
tokTypeSDesc[tokTypeHighTokThisGoal] = "HiTipGoal";
tokTypeSDesc[tokTypeBhsTok] = "Bhs";
tokTypeSDesc[tokTypeDhsTok] = "Dhs";
tokTypeSDesc[tokTypeFlashTok] = "Flash";
tokTypeSDesc[tokTypeTotFlashTok] = 'TotFlash';
tokTypeSDesc[tokTypeTotFlashTokThisGoal] = 'TotFlashGoal';
tokTypeSDesc[tokTypeTicketTok] = "Ticket";
tokTypeSDesc[tokTypeTotTicketTok] = 'TotTicket';

var showTypeDesc = {};
showTypeDesc[tokTypeFlashTok] = "Private Flash Show";
showTypeDesc[tokTypeBhsTok] = "Hidden Show";
showTypeDesc[tokTypeDhsTok] = "Hidden Show";
showTypeDesc[tokTypeTicketTok] = "Private Ticket-Only Show";

//---------------------------------------------------------------------------
function UserObj(user) {
//---------------------------------------------------------------------------

  this.tokVars = {};
  this.user = user;
  this.curGoalSerNo = 0;

  for (var p in tokTypeProp) {
    if (tokTypeProp.hasOwnProperty(p))
      this.tokVars[p] = 0;
  };
  setUserListObj(this, user);
}

//-----------------------------------------------------------------------
function resetUserListObjGoals(goalType) {
//-----------------------------------------------------------------------
  var cnt = 0;

  for (var p in userListObj) {
    if (!isUndefined(p) && userListObj.hasOwnProperty(p) && p.substr(0, userPref.length) === userPref) {
      cnt++;
      var userObj = userListObj[p];
      userObj.resetUserGoals(goalType);
    }
  }
  return cnt;
}

//---------------------------------------------------------------------------
UserObj.prototype.resetUserGoals = function(goalType) {
//---------------------------------------------------------------------------
  this.tokVars[tokTypeTotTokThisGoal] = 0;
  this.tokVars[tokTypeHighTokThisGoal] = 0;
  this.tokVars[tokTypeTotFlashTokThisGoal] = 0;

  if (goalType === goalTypeHidden) {
    this.tokVars[tokTypeBhsTok] = 0;
    this.tokVars[tokTypeDhsTok] = 0;
  }
  return this;
};

//---------------------------------------------------------------------------
UserObj.prototype.initUser = function(user) {
//---------------------------------------------------------------------------

  return UserObj.call(this, user);
};

//---------------------------------------------------------------------------
UserObj.prototype.getTokTypeVal = function(user, tokType) {
//---------------------------------------------------------------------------
  var userObj = getUserObj(user);
  
  if (tokTypeProp.hasOwnProperty(tokType) && !isUndefined(userObj))
    return userObj.tokVars[tokType];
  else
    return 0;
};

//---------------------------------------------------------------------------
UserObj.prototype.setTokTypeVal = function(user, tokType, val) {
//---------------------------------------------------------------------------
  if (tokTypeProp.hasOwnProperty(tokType))
    getUserObj(user).tokVars[tokType] = val;
};

//---------------------------------------------------------------------------
function tipUserObj(user, tip) {
//---------------------------------------------------------------------------
  var otip = tip;
  var userObj = getUserObj(user);

  if (isUndefined(userObj))
    userObj = new UserObj(user);
  
  else if (userObj.curGoalSerNo !== stats.curGoalSerNo)
//    userObj.initUser(user);
    userObj.resetUserGoals(goalTypeNormal);
  userObj.curGoalSerNo = stats.curGoalSerNo;

// Tip based on tip selection type

  if (tipModeOpts) {
    var parms = {};
    parms.dtip = tip;
    parms.goalTip = tip;
    parms.uncond = false;
    parms.bhsAlreadyIn = false;

    switch (tipMsg.substr(0, 1).toLowerCase()) {
      case "t":     // Ticket show
        parms.dtip = tipUserObjChkTicket.call(userObj, parms);
        break;
      
      case "f":      // Flash show
        parms.dtip = tipUserObjChkFlash.call(userObj, parms);
        break;
      
      case "h":      // Prepaid hidden show
        parms.uncond = true;
        parms.dtip = tipUserObjChkBhs.call(userObj, parms);
        break;
      
      default:
        parms.uncond = true;
        parms.dtip = tipUserObjChkBhs.call(userObj, parms);
        break;
    }

    if (parms.dtip > 0) {
      parms.uncond = true;
      parms.dtip = tipUserObjChkBhs.call(userObj, parms);
    }
  }    

//-----------------------------------------------
// Determine tip show amt based on show amts
//-----------------------------------------------

  else {
    var famt   = hiddenShow.getFlashPrice();
    var tamt   = hiddenShow.getTicketPrice();
    var bhsamt = hiddenShow.getBhsPrice();
    
    var amts = [[famt,   tipUserObjChkFlash],
                [tamt,   tipUserObjChkTicket],
                [bhsamt, tipUserObjChkBhs]].
        sort(function(a, b) { return b[0] - a[0]; });
    amts.push([bhsamt, tipUserObjChkBhs]);

    var parms = {};
    parms.dtip = tip;
    parms.goalTip = tip;
    parms.uncond = false;
    parms.bhsAlreadyIn = false;
    
    for (var i = 0, ul = amts.length - 1; i < ul && parms.dtip > 0; i++)
      if (amts[i][0] > 0)
        parms.dtip = amts[i][1].call(userObj, parms);
             
    if (parms.dtip > 0) {
      parms.uncond = true;
      parms.dtip = tipUserObjChkBhs.call(userObj, parms);
//      parms.dtip = amts[ul][1].call(userObj, parms);
    }
  }
        
  userObj.tokVars[tokTypeTotTok]         += otip;
  userObj.tokVars[tokTypeTotTokThisGoal] += otip;
  userObj.tokVars[tokTypeHighTok]         = Math.max(userObj.tokVars[tokTypeHighTok], otip);
  userObj.tokVars[tokTypeHighTokThisGoal] = Math.max(userObj.tokVars[tokTypeHighTokThisGoal], otip);

  return parms.goalTip;
}

//---------------------------------------------------------------------------
function tipUserObjChkTicket(parms) {
//---------------------------------------------------------------------------
  var tip       = parms.dtip;
  var user      = this.user;
  var tokType   = tokTypeTicketTok;
  var samt      = hiddenShow.getTicketPrice();
  var showType  = showTypeDesc[tokType];
  var alreadyIn = this.tokVars[tokType] >= samt;

  if (samt > 0 &&
      tip >= samt) {
    
    tip -= dtip;
//  tip -= samt;
    
    parms.goalTip = Math.max(0, parms.goalTip - samt);
    var dtip = Math.max(0, samt - this.tokVars[tokType]);
    this.tokVars[tokTypeTicketTok]   += dtip;
    this.tokVars[tokTypeTotTicketTok] = dtip;

    if (hiddenShow.getIsTicketShowRunning()) {
      hiddenShow.addTicketUsers(user);
      var invite = 'are';
    }
    else
       invite = 'will be';

    if (alreadyIn) {
//      Msg.sendMsg(Msg.toO, "Thanks, {0}!  You were already invited to the {1}!".format(user, showType));
//      Msg.sendMsg(Msg.toBM, "User {0} was already invited to the {1}!".format(user, showType));
    }
    else {
      Msg.sendMsg(Msg.toO, ("Thanks, {0}!  You have a ticket and " + invite + " invited to the {1}!").format(user, showType));
      Msg.sendMsg(Msg.toBM, "User {0} has purchased a ticket for the {1}!".format(user, showType));
    }
  }
  return tip;
}  
  
//---------------------------------------------------------------------------
function tipUserObjChkFlash(parms) {
//---------------------------------------------------------------------------
  var tip = parms.dtip;
  var user = this.user;
  var tokType = tokTypeFlashTok;
  var samt = hiddenShow.getFlashPrice();
  var showType = showTypeDesc[tokType];
  var alreadyIn = this.tokVars[tokType] >= samt;
  
  if (samt > 0 &&
      tip >= samt) {
    
    tip -= samt;
    this.tokVars[tokTypeFlashTok]            += samt;
    this.tokVars[tokTypeTotFlashTok]         += samt;
    this.tokVars[tokTypeTotFlashTokThisGoal] += samt;
    
    if (alreadyIn) {
//      Msg.sendMsg(Msg.toO, "Thanks, {0}!  You were already invited to the {1}!".format(user, showType));
//      Msg.sendMsg(Msg.toBM, "User {0} was already invited to the {1}!".format(user, showType));
    }
    else {
      Msg.sendMsg(Msg.toO, "Thanks, {0}!  You will be invited to the {1}!".format(user, showType));
      Msg.sendMsg(Msg.toBM, "User {0} has been invited to the {1}!".format(user, showType));
    }
    
    if (settings.flash_tips_count_for_hidden) {
      tip += samt;
/***********************      
      parms.dtip = samt;
      tipUserObjChkBhs.call(this, parms);
************************/
    }
    else
      parms.goalTip = Math.max(0, parms.goalTip - samt);
  }
  return tip;
}

//---------------------------------------------------------------------------
function tipUserObjChkBhs(parms) {
//---------------------------------------------------------------------------
  var tip       = parms.dtip;
  var user      = this.user;
  var uncond    = parms.uncond;

  if (!hiddenShow.enabled)
    return tip;
  
  if (hiddenShow.getIsHiddenShowRunning()) {
    var tokType  = tokTypeDhsTok;
    var statType = 'totDhsTokens';
    var samt     = hiddenShow.getDhsPrice();
    var invite   = 'are';
  }
  else {
    tokType  = tokTypeBhsTok;
    statType = 'totBhsTokens';
    samt     = hiddenShow.getBhsPrice();
    invite   = 'will be';
    uncond   = true;
  }
  
  var showType  = showTypeDesc[tokType];
  var alreadyIn = this.tokVars[tokType] >= samt;
  
  if (samt > 0 && (uncond || tip >= samt)) {
    if (uncond) {
      var dtip = tip;
      tip = 0;
    }
    else {
      var dtip = samt - this.tokVars[tokType];
      tip = Math.max(0, tip - dtip);
    }

    if (dtip > 0) {
      this.tokVars[tokType] += dtip;
      stats[statType]       += dtip;
      
      if (this.tokVars[tokType] >= samt) {
        if (!hiddenShow.checkHiddenUser(user)) {
          Msg.sendMsg(Msg.toO, ("Thanks, {0}!  You " + invite + " invited to the {1}!").format(user, showType));
          Msg.sendMsg(Msg.toBM, "User {0} has been invited to the {1}!".format(user, showType));
          hiddenShow.addHiddenUsers(user);
        }
        else
          Msg.sendMsg(Msg.toO, "Thanks, {0}!  Enjoy the {1}!".format(user, showType));
      }
    }
  }
  return tip;
}

//---------------------------------------------------------------------------
function getUserObj(user, createFlg) {
//---------------------------------------------------------------------------
  var userObj = userListObj[userPref + user];

  if (isUndefined(userObj)) {
    if (createFlg)
      userObj = new UserObj(user);
    else
      userObj = null;
  }
  return userObj;
}

//---------------------------------------------------------------------------
function setUserListObj(userObj, user) {
//---------------------------------------------------------------------------
  return userListObj[userPref + user] = userObj;
}

//-------------------------------------------------------------------------
function getLbUserObjList(cnt, minTokens, tokType) {
//-------------------------------------------------------------------------

  var userlist = [];
  
  for (var p in userListObj) {
    if (!isUndefined(p) && userListObj.hasOwnProperty(p) && p.substr(0, userPref.length) === userPref) {
      var userObj = userListObj[p];
      var user = userObj.user;

      if (userObj.tokVars[tokType] >= minTokens) // && minTokens > 0)
        userlist.push(userObj);
    }
  }

  userlist.sort(function(a, b) {
    return b.tokVars[tokType] - a.tokVars[tokType];
  });
  
  if (cnt === 0)
    return userlist;
  else
    return userlist.slice(0, cnt);
}

//-------------------------------------------------------------------------
function getLbUserList(cnt, minTokens, tokType) {
//-------------------------------------------------------------------------

  var userlist = getLbUserObjList(cnt, minTokens, tokType);
  var namelist = [];
  
  for (var i = 0, ul = userlist.length; i < ul; i++)
    namelist.push(userlist[i].user);
  
  return namelist.sort();
}

//-----------------------------------------------------------------------
function formatLbUserList(cnt, minTokens, tokType, userFmt) {
//-----------------------------------------------------------------------
  if (isUndefined(userFmt) || typeof(userFmt) !== 'boolean')
    userFmt = false;
    
  var userlist = getLbUserObjList(cnt, minTokens, tokType);
  var lbout    = '------ ';

  if (cnt === 0)
    lbout += "Leaderboard";
  else
    lbout += "Leaderboard Top " + cnt; 

  if (!userFmt)
    lbout += " by " + tokTypeDesc[tokType];
  lbout += " ------\n";

  if (userFmt && userlist.length === 0)
    return '';
  
  for (var i = 0, ul = userlist.length; i < ul; i++) {
    var userObj = userlist[i];

    if (userFmt) {
      lbout += '#' + (i + 1) /*formatNumLZ(i + 1, 2)*/ + ' ' + userObj.user + ' (' + userObj.tokVars[tokTypeTotTok] + ' Tokens), Highest Tip (' + userObj.tokVars[tokTypeHighTok] + ' Tokens)\n';
      continue;
    }
    lbout += '(' + (i + 1) /*formatNumLZ(i + 1, 2)*/ + ') ' + userObj.user + " - " + tokTypeSDesc[tokType] + "=" + userObj.tokVars[tokType];

    if (tokType !== tokTypeTotTok)
      lbout += " " + tokTypeSDesc[tokTypeTotTok] + "=" + userObj.tokVars[tokTypeTotTok];
    if (tokType !== tokTypeTotTokThisGoal)
      lbout += " " + tokTypeSDesc[tokTypeTotTokThisGoal] + "=" + userObj.tokVars[tokTypeTotTokThisGoal];
    if (tokType !== tokTypeHighTok)
      lbout += " " + tokTypeSDesc[tokTypeHighTok] + "=" + userObj.tokVars[tokTypeHighTok];
    if (tokType !== tokTypeHighTokThisGoal)
      lbout += " " + tokTypeSDesc[tokTypeHighTokThisGoal] + "=" + userObj.tokVars[tokTypeHighTokThisGoal];
    if (tokType !== tokTypeBhsTok)
      lbout += " " + tokTypeSDesc[tokTypeBhsTok] + "=" + userObj.tokVars[tokTypeBhsTok];
    if (tokType !== tokTypeDhsTok)
      lbout += " " + tokTypeSDesc[tokTypeDhsTok] + "=" + userObj.tokVars[tokTypeDhsTok];

    lbout += "\n";
  }

  if (lbout.substr(-1) === '\n')
    lbout = lbout.substring(0, lbout.length - 1);
  return lbout;
}

//---------------------------------------------------------------------------
function formatNumLZ(num, len) {
//---------------------------------------------------------------------------
  while (num.toString().length < len)
    num = '' + '0' + num;
  return num;
}

//---------------------------------------------------------------------------
function GoalObj(amt, repCnt, desc, type) {
//---------------------------------------------------------------------------

  if (amt !== -1) {
    this.goalAmt     = amt;
    this.goalRepCnt  = repCnt;
    this.goalDesc    = desc;
    this.goalType    = type;
  }
  else if (! isUndefined(type)) 
    this.goalType = type;
  
  this.vCurAmt     = 0;
  this.lastAmt     = 0;
  this.curAmt      = 0;
  this.dhsAmt      = 0;
  this.curRepCnt   = 0;
  this.goalHitTime = 0;
  this.goalSerNo   = ++stats.curGoalSerNo;
}

//---------------------------------------------------------------------------
GoalObj.prototype.initGoal = function(amt, repCnt, desc) {
//---------------------------------------------------------------------------

  return GoalObj.call(this, amt, repCnt, desc);
};

//---------------------------------------------------------------------------
function resetGoal(goalNo) {
//---------------------------------------------------------------------------

  var goalObj = goalList[goalNo];
  goalObj.initGoal(-1);

  return goalObj;
}

//---------------------------------------------------------------------------
function addGoal(goalNo, repCnt, amt, desc, type) {
//---------------------------------------------------------------------------

  var goalObj = new GoalObj(amt, repCnt, desc, type);

  goalList.splice(goalNo, 0, goalObj);

  if (stats.curGoalNo >= goalNo)
    stats.curGoalNo++;
//    stats.curGoalNo = Math.max(0, --stats.curGoalNo);
  
  return goalObj;
}

//---------------------------------------------------------------------------
function delGoal(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst() || goalNo > goalLast())
    return null;
  
  if (stats.curGoalNo >= goalNo)
    stats.curGoalNo = Math.max(0, --stats.curGoalNo);
//    stats.curGoalNo--;
  
  return goalList.splice(goalNo, 1)[0];
}

//---------------------------------------------------------------------------
function delGoals(g1, g2) {
//---------------------------------------------------------------------------

  if (g1 < goalFirst() || g2 > goalLast() || g2 < g1) {
//     Msg.sendMsg(Msg.toO, "delgoal range spec not correct. USAGE: /delgoal OR /delgoal <g1> OR /delgoal <g1> <g2> OR /delgoal * OR /delgoal ALL");
    return false;
  }
  
  var newGoal = goalCur;
  var newGoalFlg = goalCur() >= g1 && goalCur() <= g2;
  
  for (var i = g1; i <= g2; i++) {
    var desc = goalList[i].goalDesc;
    var curGoalFlg = i === goalCur();
    
    if (delGoal(i) === null) {
      Msg.sendMsg(Msg.toO, "Error deleting goal {0} '{1}'".format(i, desc));
      return false;
    }
    Msg.sendMsg(Msg.toO, "Deleted goal {0} '{1}".format(i, desc));
    Msg.sendMsg(Msg.toM,"{0} has deleted goal {1} '{2}'".format(msgUser, i, desc));

    if (curGoalFlg) {
      if (i >= goalLast() - 1)
        newGoal = goalFirst0;
    }
  }
  Msg.sendMsg(Msg.toO, "Deleted {0} goals successfully".format(g2 - g1 + 1));
  Msg.sendMsg(Msg.toM, "{0} goals successfully deleted by {1}".format(g2 - g1 + 1, msgUser));

  if (newGoalFlg) {
    nextGoal(newGoal);
    updPanel();
  }
  
  return true;
}

//---------------------------------------------------------------------------
function chgGoal(goalNo, repCnt, amt, desc) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst() || goalNo > goalLast())
    return null;
  
  var goalObj = goalList[goalNo];

  goalObj.goalAmt    = amt;
  goalObj.goalDesc   = desc;
  goalObj.goalRepCnt = repCnt;  
  return goalObj;
}

//---------------------------------------------------------------------------
function getGoalType(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return '';
  
  var goalObj = goalList[goalNo];

  return goalObj.goalType;
}

//---------------------------------------------------------------------------
function getGoalDesc(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return '';
  
  var goalObj = goalList[goalNo];
  var desc    = goalObj.goalDesc;
  
  desc = substMsg(desc);
  return desc;
}

//---------------------------------------------------------------------------
function setGoalDesc(goalNo, desc) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return '';
  
  var goalObj = goalList[goalNo];

  goalObj.goalDesc = desc;
  return goalObj;
}

//---------------------------------------------------------------------------
function getGoalRepCnt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.goalRepCnt;
}

//---------------------------------------------------------------------------
function getGoalCurRepCnt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.curRepCnt;
}

//---------------------------------------------------------------------------
function getGoalHitTime(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.goalHitTime;
}

//---------------------------------------------------------------------------
function getGoalAmt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.goalAmt;
}

//---------------------------------------------------------------------------
function getGoalCurAmt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.curAmt;
}

//---------------------------------------------------------------------------
function getGoalVCurAmt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.vCurAmt;
}

//---------------------------------------------------------------------------
function getGoalLastAmt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.lastAmt;
}

//---------------------------------------------------------------------------
function getGoalDhsAmt(goalNo) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.dhsAmt;
}

//---------------------------------------------------------------------------
function setGoalDhsAmt(goalNo, amt) {
//---------------------------------------------------------------------------

  if (goalNo < goalFirst0() || goalNo > goalLast9())
    return 0;
  
  var goalObj = goalList[goalNo];

  return goalObj.dhsAmt = amt;
}

//---------------------------------------------------------------------------
function nextGoal(goalNo, testFlg) {
//---------------------------------------------------------------------------

  var savGoalNo = stats.curGoalNo;
  
  if (goalNo === '*') {
    goalNo = goalCur();
    var resetCur = true;
  }
  else
    resetCur = false;
  
  if (goalNo === goalLast9 && resetCur)
    goalNo = goalNext;
  
  if (goalNo === goalNext) {
    if (goalCur() === goalLast()) {
      if (settings.final_action === 'hidden' ||
          settings.final_action === 'display')
        goalNo = goalLast9();
      else            // loop to first goal
        goalNo = goalFirst0();
    }
    else if (goalCur() === goalLast9())
      goalNo = goalFirst0();
    else
      goalNo = goalNext();
  }
  else if (typeof goalNo !== "number")
    goalNo = goalNo();

  goalNo = Math.min(goalLast9(), Math.max(goalNo, goalFirst0()));
  
  if (goalNo === goalFirst0() &&
      !settings.keep_no_goal)
    goalNo = goalFirst();
  
  if (!isUndefined(testFlg) && testFlg)
    return goalNo;
  
  if (goalNo !== goalCur()) {
    if (goalNo === goalLast9() && getGoalType(goalLast9()) === goalTypeHidden) {
//        (settings.final_action === 'hidden') {
      if (!hiddenTimerObj.getIsRunning()) {
        hiddenTimerObj.start(hiddenShow.timerMins);
        return goalNo;
      }
      else {
        hiddenTimerObj.stop();
        hiddenShow.startHiddenShow();
      }
    }
  }
  
  stats.curGoalNo = goalNo;
  stats.prevGoalNo = savGoalNo;
  var newGoal = goalNo !== savGoalNo;
  
  if (newGoal || resetCur) {
    hiddenTimerObj.stop();
    if (goalList[savGoalNo].goalType === goalTypeHidden) {
      hiddenShow.stopHiddenShow();
    }

    if (newGoal)
      resetUserListObjGoals(goalList[savGoalNo].goalType);
    stats.goalReached = false;
    stats.goalAlreadyReached = false;
    stats.totGoals++;
    stats.totGoalAmts += getGoalCurAmt(goalNo);
    if (resetCur)
      stats.curGoalSerNo--;
    if (resetCur || goalNo < savGoalNo)
      resetGoal(goalNo);
    updPanel();
  }

  return goalNo;
}

//---------------------------------------------------------------------------
function tipGoal(amt, user, virtualTokFlg) {
//---------------------------------------------------------------------------

  var goalObj = goalList[goalCur()];
  var oamt    = amt;

  if (virtualTokFlg) {
    goalObj.lastAmt                   = goalObj.curAmt;
    goalObj.curAmt                   += amt;
    goalObj.vCurAmt                  += amt;

    stats.totVirtualTokens           += amt;
    stats.totVirtualTokensSinceReset += amt;
    updPanel();
  }

  else if (amt > 0) {
    if ((goalObj.goalAmt > 0 || goalCur() === goalLast9()) && user !== '')
      amt = tipUserObj(user, amt);

    if (amt > 0) {
      goalObj.lastAmt            = goalObj.curAmt;
      goalObj.curAmt            += amt;
    }
    stats.totAllTokens        += oamt;
    stats.totTokensSinceReset += oamt;
    stats.mostRecentTip        = oamt;
    stats.mostRecentUser       = user;

    if (hiddenShow.getIsHiddenShowRunning())
      goalObj.dhsAmt = oamt;
  
    if (oamt >= stats.highTip) {
      stats.highTip  = oamt;
      stats.highUser = user;
    }
    
    var dCurRepCnt = Math.floor(goalObj.curAmt / goalObj.goalAmt); 
    if (dCurRepCnt > 0 && goalObj.goalRepCnt >= 0) {
//      stats.goalReached = goalObj.goalRepCnt > 0;
      stats.goalReached = true;
      
      for (var i = 0; i < dCurRepCnt; i++) {
        if (goalObj.goalRepCnt > 0 && goalObj.curRepCnt >= goalObj.goalRepCnt)
          break;
        goalObj.curRepCnt++;
        goalObj.curAmt -= goalObj.goalAmt;
        Msg.sendMsg(Msg.toBMO, "Goal Reached for the " + getOrdNumSuffix(goalObj.curRepCnt) + " Time");
      }
    }
  }
  
  stats.goalReached = stats.goalReached || 
                      goalObj.goalRepCnt === -1 &&
                      goalObj.curAmt >= goalObj.goalAmt;
  if (stats.goalReached)
    goalObj.goalHitTime = new Date();
  
  updPanel();
  return (stats.goalReached);
} 

//---------------------------------------------------------------------------
function recordTip(user, tipAmt, virtualTokFlg) {
//---------------------------------------------------------------------------
  if (tipGoal(tipAmt, user, virtualTokFlg) === 0) {
    if (! stats.goalAlreadyReached) {
      //---------------------------------
      // Goal has been reached first time
      //---------------------------------
      goalTimerObj.stop();
      var goalObj  = goalList[goalCur()];
      var goalAmt  = goalObj.goalAmt;
      var goalDesc = goalObj.goalDesc;
    
      debugLog("Goal amt " + goalAmt + " for current goal " + stats.curGoalAmt + " has been reached");

      if (settings.progression_mode_manual ||
          nextGoal(goalNext, true) === goalLast9() && getGoalType(goalLast9()) === goalTypeHidden) {
        
        //--------------------------------------------
        // Manual skip mode or next goal is hidden
        //--------------------------------------------

        Msg.sendMsg(Msg.toB, "* Goal met: " + goalDesc + " - type '/next' to move on");
        Msg.sendMsg(Msg.toM, "* Goal met: " + goalDesc + " - the broadcaster must type '/next' to move on");
        Msg.sendMsg(Msg.toAll, "** Goal met! **");
      }
      else {
        //--------------------------------------------
        // Autoskip mode
        //--------------------------------------------
          
        Msg.sendMsg(Msg.toBMO, "* Goal met - automatic progressioin mode: " + getGoalDesc(goalCur()));
        Msg.sendMsg(Msg.toBMO, "* Goal met - automatic progressioin mode: " + getGoalDesc(goalCur()));
        nextGoal(goalNext);
      }
    }
  }
  else {
    var userObj = getUserObj(user);
  }
  stats.goalAlreadyReached = stats.goalReached;
}

//---------------------------------------------------------------------------
function internalGetTipperTheme() {
//---------------------------------------------------------------------------
  if (settings.highlight_theme === 'random') {
    var themeBail = Math.floor(Math.random() * 6);
    var themeIndex = 1;
    debugLog("Random theme selected, index " + themeBail);
    for (var themeName in tipper_colors) {
      if (themeIndex === themeBail && !isUndefined(tipper_colors[themeName])) {
        debugLog("Selected theme: [Rand] " + themeName);
        return tipper_colors[themeName];
      }
      themeIndex++;
    }
    return tipper_colors.legacy;
  }
  else {
    debugLog("Selected theme: '" + settings.highlight_theme + "'");
    return tipper_colors[settings.highlight_theme];
  }
}

//---------------------------------------------------------------------------
function getTipperTheme() {
//---------------------------------------------------------------------------
  var theme = internalGetTipperTheme();
  return isUndefined(theme) ? tipper_colors.legacy : theme;
}

//---------------------------------------------------------------------------
function debugLog(message) {
//---------------------------------------------------------------------------
  if (appVars.Debug)
    cb.log("[{0}] TMG: {1}".format(new Date().toString(), message));
}

//------------------------------------------------------------------------------
// Timer Object and Methods
//------------------------------------------------------------------------------

var initTimerObj;
var goalTimerObj;
var hiddenTimerObj;
var timerObjList = {};
var timerList = [];                             // List of active timer objects

//------------------------------------------------

//------------------------------------------------
function TimerObj(name) {
//------------------------------------------------
  this.name            = name;                  // Timer name - just a label 
  this.nIntervals      = 0;                     // # minutes - should be set when starting timer
  this.intervalCnt     = 0;                     // Countdown counter - current # mins left
  this.running         = false;                 // True when running
  this.intervalMsg     = '';                    // Interval messages array to be set when creating obj
  this.timerExpiredMsg = '';                    // Timer expired message to be set when creating obj
}

//------------------------------------------------
function setTimerObjDefaults() {
//------------------------------------------------
  TimerObj.prototype.name            = '';      // Timer name - just a label 
  TimerObj.prototype.nIntervals      = 0;       // # minutes - should be set when starting timer
  TimerObj.prototype.intervalCnt     = 0;       // Countdown counter - current # mins left
  TimerObj.prototype.running         = false;   // True when running
  TimerObj.prototype.intervalMsg     = '';      // Interval messages array to be set when creating obj
  TimerObj.prototype.timerExpiredMsg = '';      // Timer expired message to be set when creating obj
  TimerObj.prototype.timerSecs       = 60;      // Timer duration in seconds - 60 (1 min)
  TimerObj.prototype.interval        = TimerObj.prototype.timerSecs * 1000;   // Actual timer interval in msecs
//  TimerObj.prototype.userIntFunc     = function() {}; // Default user interval function to call before intervalFunc
  TimerObj.prototype.intervalFunc    = function() { updPanel(); }; // Default interval function to call
  TimerObj.prototype.delOnStop       = false;   // Delete timerObj on stop()        
  TimerObj.prototype.msgsOnStop      = false;   // Display messages on stop()       
//  TimerObj.prototype.timerVal        = function(secs) { return secs * TimerObj.prototype.interval; };
}

//------------------------------------------------
TimerObj.prototype.setMsgs = function(intervalMsg, expiredMsg) {
//------------------------------------------------
    this.intervalMsg     = intervalMsg;
    this.timerExpiredMsg = expiredMsg;
};

//------------------------------------------------
TimerObj.prototype.getIntervalCnt = function() {
//------------------------------------------------
    return this.intervalCnt;
};

//------------------------------------------------
TimerObj.prototype.getName = function() {
//------------------------------------------------
    return this.name;
};

//------------------------------------------------
TimerObj.prototype.getIsRunning = function() {
//------------------------------------------------
    return this.running;
};

//------------------------------------------------
TimerObj.prototype.process = function() {
//------------------------------------------------
  var tList = timerList.slice(0);
  
  for (var i = tList.length - 1; i >= 0; i--) {
    var timerObj = tList[i];
      
    timerObj.intervalCnt = Math.max(timerObj.intervalCnt - 1, 0);

    if (timerObj.getIsRunning()) {
      debugLog("Timer " + timerObj.name + " processed at " + new Date().toString());
      timerObj.displayIntervalMsg('process');

      if (!isUndefined(timerObj.userIntFunc) &&
          typeof timerObj.userIntFunc === "function")

        timerObj.userIntFunc.call(timerObj, 'process');

      if (timerObj.intervalCnt <= 0 &&
          timerObj.nIntervals > 0)

        timerObj.stop();                   // Stop and remove this timer element
    }
  }
    
  if (timerList.length > 0) {
    TimerObj.prototype.running = true;
    debugLog("Setting timer at " + new Date().toString());
    cb.setTimeout(TimerObj.prototype.process, TimerObj.prototype.interval);
  }
  else {
    debugLog("Disabling all timers at " + new Date().toString());
    TimerObj.prototype.running = false;
  }

  if (!isUndefined(TimerObj.prototype.intervalFunc) &&
      typeof TimerObj.prototype.intervalFunc === "function")

    TimerObj.prototype.intervalFunc.call();
};

//------------------------------------------------
TimerObj.prototype.start = function(mins) {
//------------------------------------------------
//  if (!this.running)
    this.push();                             // Add this timer obj to timer list if not in list
//    timerList.push(this);                      // Add this timer obj to timer list
  
  if (isUndefined(mins))
//    mins = 0;
//  else if (mins === '*')
    mins = this.nIntervals;
  
  this.nIntervals   = mins;                  // # intervals (# minutes)
  this.intervalCnt  = mins;                  // cur # intervals (# minutes) left
  this.running      = true;                  // Indicate timer running

  if (!isUndefined(this.userIntFunc) &&
      typeof this.userIntFunc === "function")

    this.userIntFunc.call(this, 'start');
  
  if (!TimerObj.prototype.running) {
    debugLog("Enabling timer at " + new Date().toString());
    TimerObj.prototype.running = true;
    cb.setTimeout(TimerObj.prototype.process, TimerObj.prototype.interval);
  }
  debugLog("Timer " + this.name + " started for " + mins + " minutes at " + new Date().toString());
  this.displayIntervalMsg('start');
  
  if (!isUndefined(TimerObj.prototype.intervalFunc) &&
      typeof TimerObj.prototype.intervalFunc === "function")

    TimerObj.prototype.intervalFunc.call();
};

//------------------------------------------------
TimerObj.prototype.stop = function() {
//------------------------------------------------
  if (this.running) {
    if (this.msgsOnStop) {
      if (this.intervalCnt > 0) { 
        this.intervalCnt = 0;
        this.displayIntervalMsg('stop');
      }
    }
    
    this.intervalCnt = 0;
    this.running = false;                        // Indicate timer running
    debugLog("Timer " + this.name + " stopped at " + new Date().toString());
    
    if (this.delOnStop) {
      for (var i = timerList.length - 1; i >= 0; i--) {
        var timerObj = timerList[i];
        if (timerObj === this) {
          timerList.splice(i, 1);
          break;
        }
      }
    }
  }

  if (!isUndefined(TimerObj.prototype.intervalFunc) &&
      typeof TimerObj.prototype.intervalFunc === "function")

    TimerObj.prototype.intervalFunc.call();
};

//------------------------------------------------
TimerObj.prototype.push = function() {
//------------------------------------------------
  for (var i = 0, ul = timerList.length; i < ul; i++) {
    if (timerList[i] === this) {
      return false;
    }
  }
  timerList.push(this);
  return true;
};

//------------------------------------------------
TimerObj.prototype.displayIntervalMsg = function(phase) {
//------------------------------------------------
  var msg = '';

  if (!isUndefined(this.intervalMsg) &&
       this.intervalCnt > 0)
    msg = this.intervalMsg;

  else if (!isUndefined(this.timerExpiredMsg) &&
       this.intervalCnt === 0 &&
       phase !== 'start')
    msg = this.timerExpiredMsg;
  
  if (!isUndefined(msg)) {
    msg = substMsg(msg, ['%time%', this.intervalCnt]);
    Msg.sendMsg(Msg.toAll, msg, null, null, Colors.DarkRed);
  }
};

//------------------------------------------------
TimerObj.prototype.getTimeLeftText = function() {
//------------------------------------------------
  if (this.running)
    return this.intervalCnt + " min left";
  else
    return '';
};  

//------------------------------------------------
function createTimerObj(name, func, imsg, emsg) {
//------------------------------------------------
  var timerObj = getTimerObj(name);
  if (!isUndefined(timerObj))
    return timerObj;
  
  timerObj = new TimerObj(name);
  timerObjList[name] = timerObj;
  
  if (!isUndefined(func))
    timerObj.userIntFunc = func;              // Timer user interval function   

  timerObj.setMsgs(imsg, emsg);
  timerObj.push();
  return timerObj;
}

//------------------------------------------------
function getTimerObj(name) {
//------------------------------------------------
  var timerObj = timerObjList[name];
  if (!isUndefined(timerObj))
    return timerObj;
  else
    return null;
}
  

//------------------------------------------------------------------------------
// End Timer Object and Methods
//------------------------------------------------------------------------------

var hiddenShow = {
  enabled: true,
  hiddenMessage: '',
  flashMessage: '',
  ticketMessage: '',
  flashMins: 0,
  flashPrice: 0,
  ticketPrice: 0,
  dhsPrice: 0,
  bhsPrice: 0,
  imsg: '',
  emsg: '',
  timerMins: 0,
  flashShowRunning: false,
  ticketShowRunning: false,

//--------------------------------------------------
  setHiddenPrice: function(bhsPrice, dhsPrice) {
//--------------------------------------------------
    var tokType  = tokTypeBhsTok;
    var showType = showTypeDesc[tokType];

    var savPrice = this.bhsPrice;
    this.bhsPrice = parseInt(bhsPrice);
    if (isNumericStr(dhsPrice))
      this.dhsPrice = parseInt(dhsPrice);

    var timerObj = getTimerObj('HiddenMsg');
    if (this.bhsPrice === 0) {
      if (!isUndefined(timerObj))
        timerObj.stop();
      this.setEnabled(false);
      Msg.sendMsg(Msg.toO, showType + " is now disabled");
    }
    else if (savPrice === 0) {
      if (!isUndefined(timerObj))
        timerObj.start();
      this.setEnabled(true);
      Msg.sendMsg(Msg.toO, showType + " is now enabled");
    }
  },
  //--------------------------------------------------
  getBhsPrice: function() {
//--------------------------------------------------
    return this.bhsPrice;
  },
//--------------------------------------------------
  getDhsPrice: function() {
//--------------------------------------------------
    return this.dhsPrice;
  },
//--------------------------------------------------
  setFlashPrice: function(flashPrice) {
//--------------------------------------------------
    var tokType  = tokTypeFlashTok;
    var showType = showTypeDesc[tokType];
    var savPrice = this.flashPrice;
    this.flashPrice = parseInt(flashPrice);

    if (this.flashPrice === 0)
      Msg.sendMsg(Msg.toO, showType + " is now disabled");
    else if (savPrice === 0)
      Msg.sendMsg(Msg.toO, showType + " is now enabled");
  },
//--------------------------------------------------
  getFlashPrice: function() {
//--------------------------------------------------
    return this.flashPrice;
  },
//--------------------------------------------------
  setTicketPrice: function(ticketPrice) {
//--------------------------------------------------
    var tokType  = tokTypeTicketTok;
    var showType = showTypeDesc[tokType];
    var savPrice = this.ticketPrice;
    this.ticketPrice = parseInt(ticketPrice);

    if (this.ticketPrice === 0)
      Msg.sendMsg(Msg.toO, showType + " is now disabled");
    else if (savPrice === 0)
      Msg.sendMsg(Msg.toO, showType + " is now enabled");
  },
//--------------------------------------------------
  getTicketPrice: function() {
//--------------------------------------------------
    return this.ticketPrice;
  },
//--------------------------------------------------
  setHiddenMessage: function(message) {
//--------------------------------------------------
    this.hiddenMessage = message;
  },
//--------------------------------------------------
  getHiddenMessage: function() {
//--------------------------------------------------
    return this.hiddenMessage;
  },
//--------------------------------------------------
  getCompleteHiddenMsg: function() {
//--------------------------------------------------
//    return getGoalDesc(goalLast9());
    return (substMsg(this.hiddenMessage));
  },
//--------------------------------------------------
  setFlashMessage: function(message) {
//--------------------------------------------------
    this.flashMessage = message;
  },
//--------------------------------------------------
  getFlashMessage: function() {
//--------------------------------------------------
    return this.flashMessage;
  },
//--------------------------------------------------
  getCompleteFlashShowMsg: function() {
//--------------------------------------------------
    return (substMsg(this.flashMessage));
  },
//--------------------------------------------------
  setTicketMessage: function(message) {
//--------------------------------------------------
    this.ticketMessage = message;
  },
//--------------------------------------------------
  getTicketMessage: function() {
//--------------------------------------------------
    return this.ticketMessage;
  },
//--------------------------------------------------
  getCompleteTicketShowMsg: function() {
//--------------------------------------------------
//    return this.ticketMessage.replace("%famt%", hiddenShow.getTicketPrice());
    return (substMsg(this.ticketMessage));
  },
//--------------------------------------------------
  setEnabled: function(enabled) {
//--------------------------------------------------
    this.enabled = enabled;
  },
//--------------------------------------------------
  getEnabled: function() {
//--------------------------------------------------
    return this.enabled;
  },
//--------------------------------------------------
  getIsFlashShowRunning: function() {
//--------------------------------------------------
      return this.getIsAnyRunning() && goalCur() !== goalLast9();
  },
  
//--------------------------------------------------
  getIsTicketShowRunning: function() {
//--------------------------------------------------
      return this.getIsAnyRunning() && goalCur() !== goalLast9();
  },
  
//--------------------------------------------------
  getIsHiddenShowRunning: function() {
//--------------------------------------------------
      return this.getIsAnyRunning() && goalCur() === goalLast9() && getGoalType(goalCur()) === goalTypeHidden;
  },
  
//--------------------------------------------------
  getIsAnyRunning: function() {
//--------------------------------------------------
    return cb.limitCam_isRunning();
  },

//--------------------------------------------------
  reset: function() {
//--------------------------------------------------
    if (!this.enabled)
      return;

    debugLog("Resetting hiddenShow");
    this.removeHiddenUsers('*');
    cb.limitCam_stop();
  },

//--------------------------------------------------
  timerProcess: function() {
//--------------------------------------------------
    var nxtgoal = 0;
    
    if (this.getIsRunning() &&
        this.intervalCnt <= 0 &&
        this.nIntervals > 0 &&
        (nxtgoal = nextGoal(goalNext, true)) === goalLast9() &&
        getGoalType(nxtgoal) === goalTypeHidden) {
//        nextGoal(goalLast9, true) === goalLast9()) {

      Msg.sendMsg(Msg.toBMO, "Timer has started " + showTypeDesc[tokTypeBhsTok]);
      nextGoal(goalLast9);                  // Start hidden show
    }
  },

//--------------------------------------------------
  startFlashShow: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeFlashTok;
    var showType = showTypeDesc[tokType];
    if (this.getIsAnyRunning())
      return false;

    if (! isUndefined(modUser))
      users += ',' + modUser;
    var userlist = arrayAddObjs([], str2Array(users));
    users = userlist.join(', ');

    cb.limitCam_start(this.getCompleteFlashShowMsg(), userlist);
    this.flashShowRunning = true;

    var xmsg = "User {0} has requested {1} tokens {2}".format(msgUser, this.getTicketPrice(), showType);
    debugLog(xmsg);
    Msg.sendMsg(Msg.toBMO, "{0} started by {1} for users {2}".format(showType, msgUser, users));

    return true;
  },
      
//--------------------------------------------------
  stopFlashShow: function() {
//--------------------------------------------------
    var tokType  = tokTypeFlashTok;
    var showType = showTypeDesc[tokType];

    this.flashShowRunning = false;
    cb.limitCam_stop();
    cb.limitCam_removeAllUsers();

    debugLog("Stopping flash show");
    Msg.sendMsg(Msg.toBMO, "{0} stopped by {1}".format(showType, msgUser));
  },
 
//--------------------------------------------------
  startTicketShow: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeTicketTok;
    var showType = showTypeDesc[tokType];
    if (this.getIsAnyRunning())
      return false;

    if (! isUndefined(modUser))
      users += ',' + modUser;
    var userlist = arrayAddObjs([], str2Array(users));
    users = userlist.join(', ');

    cb.limitCam_start(this.getCompleteTicketShowMsg(), userlist);
    this.ticketShowRunning = true;

    var xmsg = "User {0} has requested {1} tokens {2}".format(msgUser, this.getTicketPrice(), showType);
    debugLog(xmsg);
    Msg.sendMsg(Msg.toBMO, "{0} started by {1} for users {2}".format(showType, msgUser, users));

    return true;
  },
      
//--------------------------------------------------
  stopTicketShow: function() {
//--------------------------------------------------
    var tokType  = tokTypeTicketTok;
    var showType = showTypeDesc[tokType];

    this.ticketShowRunning = false;
    cb.limitCam_stop();
    cb.limitCam_removeAllUsers();

    debugLog("Stopping ticket show");
    Msg.sendMsg(Msg.toBMO, "{0} stopped by {1}".format(showType, msgUser));
  },
 
//--------------------------------------------------
  addTicketUsers: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeTicketTok;
    var showType = showTypeDesc[tokType];
    if (!this.getIsTicketShowRunning())
      return false;

    var userlist = arrayAddObjs(cb.limitCam_allUsersWithAccess(), str2Array(users));
    users = userlist.join(', ');

    xmsg = "Added users {0} to {1}".format(users, showType);
    debugLog(xmsg);

    Msg.sendMsg(Msg.toBMO, "Users added to {0}: {1}".format(showType, users));
    cb.limitCam_addUsers(userlist);
    return true;
  },
      
//--------------------------------------------------
  removeTicketUsers: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeTicketTok;
    var showType = showTypeDesc[tokType];
    if (users === '*') {
      if (this.getIsTicketShowRunning()) {
        cb.limitCam_removeAllUsers();
      
        var xmsg = "Removed all users from " + showType + " access";
        debugLog(xmsg);
        Msg.sendMsg(Msg.toBMO, "All users removed from {0} by {1}".format(showType, msgUser));
      }
      return '';
    }
    
    var userlist = str2Array(users);
    users        = userlist.join(' ');
    
    if (userlist.length > 0 &&
        this.getIsTicketShowRunning()) {

      cb.limitCam_removeUsers(userlist);

      xmsg = "Removed users from {0} access: {1}".format(showType, users);
      debugLog(xmsg);
      Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
    }
    return '';
  },
  
//--------------------------------------------------
  startHiddenShow: function() {
//--------------------------------------------------
    var tokType  = tokTypeBhsTok;
    var showType = showTypeDesc[tokType];
    if (!this.enabled)
      return;

    var userlist = this.getHiddenUsers();
    if (! isUndefined(modUser))
      userlist.push(modUser);
    userlist = arrayAddObjs([], userlist);
    var users = userlist.join(', ');

    cb.limitCam_start(this.getCompleteHiddenMsg(), userlist);   

    var xmsg = "User {0} has requested {1}/{2} tokens {3}".format(msgUser, this.getBhsPrice(), this.getDhsPrice(), showType);
    debugLog(xmsg);
    Msg.sendMsg(Msg.toBMO, "{0} started by {1} for users {2}".format(showType, msgUser, users));
  },
      
//--------------------------------------------------
  stopHiddenShow: function() {
//--------------------------------------------------
    var tokType  = tokTypeBhsTok;
    var showType = showTypeDesc[tokType];
    if (!this.enabled)
      return;

    cb.limitCam_stop();
    this.removeHiddenUsers('*');

    debugLog("Stopping hiddenShow");
    Msg.sendMsg(Msg.toBMO, "{0} stopped by {1}".format(showType, msgUser));
  },
      
//--------------------------------------------------
  addHiddenUsers: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeBhsTok;
    var showType = showTypeDesc[tokType];
    var userlist = str2Array(users);
    users        = userlist.join(' ');

    hiddenShowUserList = arrayAddObjs(this.getHiddenUsers(), userlist);

    if (userlist.length > 0 &&
        this.getIsHiddenShowRunning())
      
      cb.limitCam_addUsers(userlist);

    debugLog("Added users to {0} access: {1}".format(showType, users));
    Msg.sendMsg(Msg.toBMO, "Users added to {0} by {1}: {2}".format(showType, msgUser, users));
    return '';
  },
      
//--------------------------------------------------
  removeHiddenUsers: function(users) {
//--------------------------------------------------
    var tokType  = tokTypeBhsTok;
    var showType = showTypeDesc[tokType];
    if (users === '*') {
      if (this.getIsHiddenShowRunning())
        cb.limitCam_removeAllUsers();
      
      hiddenShowUserList = [];
      var xmsg = "Removed all users from " + showType + " access";
      debugLog(xmsg);
      Msg.sendMsg(Msg.toBMO, "All users removed from {0} by {1}".format(showType, msgUser));
      return '';
    }
    
    var userlist = str2Array(users);
    users        = userlist.join(' ');
    
//    hiddenShowUserList = arrayRemoveObjs(this.getHiddenUsers(), userlist);
    hiddenShowUserList = arrayRemoveObjs(hiddenShowUserList, userlist);

    if (userlist.length > 0 &&
        this.getIsHiddenShowRunning())
      cb.limitCam_removeUsers(userlist);
    
    xmsg = "Removed users from {0} access: {1}".format(showType, users);
    debugLog(xmsg);
    Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
    return '';
  },
  
//--------------------------------------------------
  getHiddenUsers: function() {
//--------------------------------------------------
    if (this.getIsHiddenShowRunning())
      return arrayAddObjs(cb.limitCam_allUsersWithAccess(), hiddenShowUserList);
    else
      return hiddenShowUserList;
  },

//--------------------------------------------------
  checkHiddenUser: function(user) {
//--------------------------------------------------
    if (this.getIsHiddenShowRunning())
      return cb.limitCam_userHasAccess(user);
    else
      return cbjs.arrayContains(hiddenShowUserList, user);
//      return cbjs.arrayContains(arrayAddObjs(cb.limitCam_allUsersWithAccess(), hiddenShowUserList), user);
  },
      
//--------------------------------------------------
  getAccessUsers: function() {
//--------------------------------------------------
      return cb.limitCam_allUsersWithAccess();
  }
};

//--------------------------------------------------
function processIntTimers() {
//--------------------------------------------------
    
  if (this.getIsRunning() &&
      this.intervalCnt <= 0)
    this.intervalCnt = this.nIntervals;
}

//--------------------------------------------------
function processLbTimer() {
//--------------------------------------------------
  if (this.getIsRunning() &&
      this.intervalCnt <= 0 &&
      this.nIntervals > 0) {
    
    this.intervalCnt = this.nIntervals;
    var lbout = formatLbUserList(5, 0, tokTypeTotTok, true);
    if (lbout !== '')
      Msg.sendMsg(Msg.toAll, lbout);
  }
}

//---------------------------------------------------------------------------
function str2Array(str) {
//---------------------------------------------------------------------------
  if (isUndefined(str))
    return [];
  
  var arr = str.split(/[, ]/);
  return arrayAddObjs([], arr);
}
      
//---------------------------------------------------------------------------
function arrayRemoveObjs(arr, objs) {
//---------------------------------------------------------------------------
  for (var i = 0, ol = objs.length; i < ol; i++) {
    arr = cbjs.arrayRemove(arr, objs[i]);
  }
  return arr;
}
  
//---------------------------------------------------------------------------
function arrayAddObjs(arr1, arr2) {
//---------------------------------------------------------------------------
  var arr = [];
  var objs = arr1.concat(arr2);
  
  for (var i = 0, ol = objs.length; i < ol; i++) {
    if (!isUndefined(objs[i]) && !cbjs.arrayContains(arr, objs[i]))
      arr.push(objs[i]);
  }
  return arr;
}
  
//---------------------------------------------------------------------------
function substMsg(xmsg, p1, p2, p3, p4, p5) {
//---------------------------------------------------------------------------

  if (isUndefined(p1))
    var p1var = '', p1val = '';
  else
    p1var = p1[0], p1val = p1[1];
  
  if (isUndefined(p2))
    var p2var = '', p2val = '';
  else
    p2var = p2[0], p2val = p2[1];
  
  if (isUndefined(p3))
    var p3var = '', p3val = '';
  else
    p3var = p3[0], p3val = p3[1];
  
  if (isUndefined(p4))
    var p4var = '', p4val = '';
  else
    p4var = p4[0], p4val = p4[1];
  
  if (isUndefined(p5))
    var p5var = '', p5val = '';
  else
    p5var = p5[0], p5val = p5[1];
  
  var userlist = getLbUserList(0, hiddenShow.getFlashPrice(), tokTypeFlashTok);
  var fusers   = userlist.join(', ');
  var userlist = getLbUserList(0, hiddenShow.getTicketPrice(), tokTypeTicketTok);
  var tusers   = userlist.join(', ');
  var husers   = hiddenShow.getHiddenUsers().join(', ');  
  
  var cnt = 30;
  
  do {
    var savMsg = xmsg;
    xmsg = xmsg.replace("\\n",      "\n").
                replace("%bhs%",    hiddenShow.getBhsPrice()).
                replace("%dhs%",    hiddenShow.getDhsPrice()).
                replace("%famt%",   hiddenShow.getFlashPrice()).
                replace("%tamt%",   hiddenShow.getTicketPrice()).
                replace("%husers%", husers).
                replace("%fusers%", fusers).
                replace("%tusers%", tusers).
                replace("%bcstr%",  cb.room_slug).
                replace(p1var,      p1val).
                replace(p2var,      p2val).
                replace(p3var,      p3val).
                replace(p4var,      p4val).
                replace(p5var,      p5val);
  } while (xmsg !== savMsg && cnt--);
  return xmsg;
}

//---------------------------------------------------------------------------
function getOrdNumSuffix(num) {
//---------------------------------------------------------------------------
  return num;
}

//---------------------------------------------------------------------------
function getOrdNumSuffix(num) {
//---------------------------------------------------------------------------
  var nxx = num % 100;
  var nx  = num % 10;
  if (nxx >= 11 && nxx <= 13) suf = 'th';
  else if (nx === 1) suf = 'st';
  else if (nx === 2) suf = 'nd';
  else if (nx === 3) suf = 'rd';
//  else if (nx >= 4 || nx === 0) suf = 'th';
  else  suf = 'th';
  return '' + num + suf;
};

//---------------------------------------------------------------------------
String.prototype.format = function() {
//---------------------------------------------------------------------------
  var newString = String(this);
  for (var idx = 0, idxl = arguments.length; idx < idxl; idx++) {
    newString = newString.replace('{' + idx + '}', arguments[idx]);
  }
  return String(newString);
};

//---------------------------------------------------------------------------
function objToString(obj) {
//---------------------------------------------------------------------------
  var str = '';
  var dlm = '';

  for (var prop in obj) {
    if (typeof (obj[prop]) === "string" || typeof (obj[prop]) === "boolean" || typeof (obj[prop]) === "number")
      str += dlm + prop + ": '" + obj[prop] + "'";
    else if (typeof (obj[prop]) === "object")
      str += dlm + "OBJECT " + prop + ": (" + objToString(obj[prop]) + ":OBJECT " + prop + ")";
    dlm = ", ";
  }
  return str;
}

//---------------------------------------------------------------------------
function getSumTotalGoal() {
//---------------------------------------------------------------------------
  return stats.totGoalAmts;
}

//---------------------------------------------------------------------------
function getAllGoals() {
//---------------------------------------------------------------------------
  var allGoals  = '';
  var totTokens = 0;
  var tokens    = 0;
  var goalObj   = null;
  var repCnt    = '';
  
  for (var i = goalFirst(); i <= goalLast(); i++) {
    goalObj = goalList[i];
    if (goalObj.goalRepCnt === -1)
      repCnt = '';
    else if (goalObj.goalRepCnt === 0)
      repCnt = '/99999';
    else
      repCnt = '/' + goalObj.goalRepCnt;

    allGoals += "(" + String(i) + repCnt + ") - " + (tokens = goalObj.goalAmt) + ' Desc=' + goalObj.goalDesc + '\n';
    totTokens += tokens;
  }
  allGoals += "--- Total All Goals: " + totTokens + "\n";

  var curGoalNo = goalCur();
  var curGoalDesc = '';

  if (curGoalNo === goalLast9() && getGoalType(curGoalNo) === goalTypeHidden)
//    curGoalDesc = showTypeDesc[tokTypeBhsTok];
    curGoalDesc = "(*) - Hidden Show";
  else if (curGoalNo === goalLast9() && getGoalType(curGoalNo) !== goalTypeHidden)
    curGoalDesc = "(*) - Final Goal";
  else if (curGoalNo === goalFirst0())
    curGoalDesc = "(*) - No Goal";
  else
    curGoalDesc = "(" + String(curGoalNo) + ") - " + getGoalDesc(curGoalNo);

  allGoals += "Current goal: " + curGoalDesc + "\n";

  var nextGoalNo = nextGoal(goalNext, true);
  var nextGoalDesc = '';
  
  if (nextGoalNo === goalLast9() && getGoalType(nextGoalNo) === goalTypeHidden)
    nextGoalDesc = "(*) - Hidden Show";
  else if (nextGoalNo === goalLast9() && getGoalType(nextGoalNo) !== goalTypeHidden)
    nextGoalDesc = "(*) - Final Goal";
  else if (nextGoalNo === goalFirst0())
    nextGoalDesc = "(*) - No Goal";
  else
    nextGoalDesc = "(" + String(nextGoalNo) + ") - " + getGoalDesc(nextGoalNo);

  allGoals += "Next goal: " + nextGoalDesc + "\n";
  
  return allGoals;
}

//---------------------------------------------------------------------------
function getTokensPerTime(mins) {
//---------------------------------------------------------------------------
  mins *= 60;
  var now = new Date();
  var timespan = now - appVars.StartupTime;

  return (stats.totAllTokens / Math.max(1, (timespan / 1000 / mins))).toFixed(1);
}

//---------------------------------------------------------------------------
function getDollarsPerTime(mins) {
//---------------------------------------------------------------------------
  return (0.05 * getTokensPerTime(mins)).toFixed(2);
}

//---------------------------------------------------------------------------
function getTotalDollars() {
//---------------------------------------------------------------------------
  return (0.05 * stats.totAllTokens).toFixed(2);
}

//---------------------------------------------------------------------------
function getGoalTokensRemaining() {
//---------------------------------------------------------------------------
  var r = getGoalAmt(goalCur()) - getGoalCurAmt(goalCur());
  return (r < 0) ? 0 : r;
}

//---------------------------------------------------------------------------
function formatUsername(val) {
//---------------------------------------------------------------------------
  return isUndefined(val) ? "--" : val.substr(0, 12);
}

function reset(allFlg) {

  if (allFlg) {
    debugLog("Performing reset all");

    for (var p in stats)
      if(stats.hasOwnProperty(p)) {
        if (typeof stats[p] === 'number')
          stats[p] = 0;
    
        else if (typeof stats[p] === 'string')
          stats[p] = '';
      }
  }

  else
    debugLog("Performing partial reset");

  stats.curGoalNo = 0;
  hiddenShow.reset();
  nextGoal('*');
  updPanel();
}

//---------------------------------------------------------------------------
function updPanel(subj) {
//---------------------------------------------------------------------------
  if (isUndefined(subj))
    subj = '';
  
  updRoomSubject(subj);
  drawPanel();
}

//---------------------------------------------------------------------------
function updRoomSubject(subj) {
//---------------------------------------------------------------------------
  if (stats.curGoalNo >= goalFirst0() &&
      stats.curGoalNo <= goalLast9()) {

    if (isUndefined(subj)) {
      var goalObj = goalList[goalCur()];
      subj = goalObj.goalDesc;
    
      if (goalObj.goalType === goalTypeHidden)
//        subj = goalObj.goalDesc.format(hiddenShow.getBhsPrice(), hiddenShow.getDhsPrice());
        subj = substMsg(goalObj.goalDesc);
//      subj = goalObj.goalDesc.replace("%bhs%", hiddenShow.getBhsPrice()).
//                                replace("%dhs%", hiddenShow.getDhsPrice());
      else {
        var repGoal = false;
        if (goalObj.goalAmt > 0) {
          if ((repGoal = goalObj.goalRepCnt > 0 && goalObj.curRepCnt < goalObj.goalRepCnt) ||
               !stats.goalReached ||
               goalObj.goalRepCnt === 0) {
            
            var tokLeft = '' + (goalObj.goalAmt - goalObj.curAmt) + ' Goal';
            if (repGoal) {
              var amtLeft = (goalObj.goalRepCnt - goalObj.curRepCnt) * goalObj.goalAmt - goalObj.curAmt;
              tokLeft += ', ' + amtLeft + ' All Goals';
            }
            subj += ' [' + tokLeft + ']';
          }
          else if (stats.goalReached && goalObj.goalRepCnt === -1)
            subj += ' [Goal Reached!]';
          else if (stats.goalReached && goalObj.goalRepCnt > 0)
            subj += ' [All Goals Reached!]';
        }
        if (settings.show_timer_in_subject && goalTimerObj.getIsRunning())
          subj += " (" + goalTimerObj.getTimeLeftText() + ")";
      }
    }
  }

  if (isUndefined(subj))
    subj = '';
  
  if (subj !== curRoomSubj) {
    debugLog("Changing subject to: " + subj);
    cb.changeRoomSubject(subj);
    curRoomSubj = subj;
  }
}

//---------------------------------------------------------------------------
function unload() {
//---------------------------------------------------------------------------
  cb.onTip(function() {});
  cb.onDrawPanel(function() {});
  cb.onMessage(function() {});
  cb.onEnter(function() {});
  cb.onLeave(function() {});
}

//---------------------------------------------------------------------------
cb.onTip(function(tip) {
//---------------------------------------------------------------------------
  msgUser = tip.from_user;
  tipMsg  = tip.message;
  tipAmt  = tip.amount;
  Msg.sendMsg(Msg.toM, msgUser + " tipped " + tipAmt + ": " + tipMsg, Colors.darkMagenta);
  recordTip(msgUser, tipAmt, false);
});

//---------------------------------------------------------------------------
cb.tipOptions(function() {
//---------------------------------------------------------------------------
  if (!settings.tipSetOpts) {
    tipModeOpts = false;
    return;
  }
  
  var hsPrice = 0, minsType = '';
  
  if (hiddenShow.getIsHiddenShowRunning()) {
    hsPrice = hiddenShow.getDhsPrice();
    minsType = 'continue';
  }
  else {
    hsPrice = hiddenShow.getBhsPrice();
    minsType = 'prepay';
  }
    
  var fsPrice = hiddenShow.getFlashPrice();
  var tsPrice = hiddenShow.getTicketPrice();

  tipModeOpts = true;
  
  var tipOpts = [];
  if (hsPrice > 0)
    tipOpts.push({label: 'Hidden Show (Private Group) ' + minsType + ' @ ' + hsPrice + 't/min'});
  if (fsPrice > 0)
    tipOpts.push({label: 'Flash Show (Private Single)'});
  if (tsPrice > 0)
    tipOpts.push({label: 'Ticket Show (Private Group)'});

  if (tipOpts.length === 0) {
    tipModeOpts = false;
    return;
  }
  
  tipOpts.push({label: 'You Just Like Me!'});

  return ({options: tipOpts, label: 'Tip Reason:'});
//  return {options: [{label: 'Private Flash'}, {label: 'Ticket Show'},  {label: 'Hidden Show'},  {label: 'You Like Her'}], label:"Tip Reason:"};
});

//---------------------------------------------------------------------------
cb.onEnter(function(user) {
//---------------------------------------------------------------------------
  msgUser = user.user;
  if (user.is_mod && isAuthor(msgUser))
    modUser = user.user;

/*********************
  if (user.in_fanclub || user.is_mod) {
    hiddenShow.addHiddenUsers(user.user);
  }
**********************/
});

//---------------------------------------------------------------------------
cb.onLeave(function(user) {
//---------------------------------------------------------------------------
  msgUser = user.user;
  /*
   if (user.in_fanclub || user.is_mod) {
   hiddenShow.removeHiddenUsers(user.user);
   }
   */
});

//---------------------------------------------------------------------------
function drawPanel() {
//---------------------------------------------------------------------------
  switch (goalCur()) {

    // --------- First Goal -----------
    case goalFirst0():
      panel = {
        template: '3_rows_of_labels',
        row1_label: 'Cur (Total) Tokens:',
        row1_value: getGoalCurAmt(stats.curGoalNo) + ' (' + stats.totAllTokens + ')',
        row2_label: 'Highest (Total) Tip:',
        row2_value: formatUsername(stats.highUser) + ' / ' + stats.highTip + ' (' + UserObj.prototype.getTokTypeVal(stats.highUser, tokTypeTotTokThisGoal) + ')', 
        row3_label: 'Latest Tip',
        row3_value: formatUsername(stats.mostRecentUser) + ' / ' + stats.mostRecentTip
      };
    
      if (settings.hide_token_haul) {
        panel.row1_label = '';
        panel.row1_value = '';
      }
      break;

    // --------- Last (Hidden) Goal -----------
    case goalLast9():
      panel = {
        template: '3_rows_of_labels',
        row1_label: 'Cur (Total) Tokens:',
        row1_value: getGoalCurAmt(stats.curGoalNo) + ' (' + stats.totAllTokens + ')',
        row2_label: '#Users in Hidden Show:',
        row2_value: hiddenShow.getHiddenUsers().length - (modUser !== '' ? 1 : 0),
//        row2_label: 'CurDhs/TotDhs/TotBhs:',
//        row2_value: getGoalDhsAmt(stats.curGoalNo) + ' / ' + stats.totDhsTokens + ' / ' + stats.totBhsTokens,
        row3_label: 'Highest (Total) Tip',
        row3_value: formatUsername(stats.highUser) + ' / ' + stats.highTip + ' (' + UserObj.prototype.getTokTypeVal(stats.highUser, tokTypeTotTokThisGoal) + ')' 
      };

      if (goalTimerObj.getIsRunning()) {
        panel.row3_label += '/Timer';
        panel.row3_value += ' / ' + goalTimerObj.getTimeLeftText();
      }
      else
        panel.row3_label += ':';
      break;
      
    // --------- Normal Goal -----------
    default:
      panel = {};
      panel.template = '3_rows_of_labels';
      panel.row1_label = 'Current / Goal' + (settings.hide_token_haul ? '' : ' (Total)') + ':';
      panel.row1_value = getGoalCurAmt(stats.curGoalNo) + ' / ' + getGoalAmt(stats.curGoalNo) + (settings.hide_token_haul ? '' : ' (' + stats.totAllTokens + ')');
      panel.row2_label = 'Highest Tip (Total):';
      panel.row2_value = formatUsername(stats.highUser) + ' / ' + stats.highTip + ' (' + UserObj.prototype.getTokTypeVal(stats.highUser, tokTypeTotTokThisGoal) + ')'; 

      if (getGoalRepCnt(goalCur()) === -1) {
//      ----- Normal Goal -----
        panel.row3_label = 'Latest Tip';
        panel.row3_value = formatUsername(stats.mostRecentUser) + ' / ' + stats.mostRecentTip;
      }
      else {
//      ----- Multi Goal -----

// check if goalRepCnt > 0 -- add x Goals Of y to output
// add # tokens left to room msg

        var goalRepCnt  = getGoalRepCnt(goalCur());
        var goalHitTime = getGoalHitTime(goalCur());
        var goalsHit    = '' + getGoalCurRepCnt(goalCur());

        if (goalRepCnt > 0)
          goalsHit += ' of ' + goalRepCnt;
        
        if (goalHitTime === 0)
          goalHitTime = 'Never';
        else {
          var minutes = Math.floor(((new Date()).getTime() - goalHitTime.getTime()) / 60000);
          var xminutes = '' + minutes + ' min';
          if (minutes !== 1)
            xminutes += 's';
          goalHitTime = '' + xminutes + ' ago';
        }
        panel.row3_label = 'Goals Reached / When';
        panel.row3_value = goalsHit + ' / ' + goalHitTime;
      }

      if (goalTimerObj.getIsRunning()) {
        panel.row3_label += ' / Time Left:';
        panel.row3_value += ' / ' + goalTimerObj.getTimeLeftText();
      }
      else
        panel.row3_label += ':';
      break;
        
  }
  cb.drawPanel();
}


//---------------------------------------------------------------------------
cb.onDrawPanel(function() {
//---------------------------------------------------------------------------
  return panel;
});

//---------------------------------------------------------------------------
function buildStatsOutput(includeExtraInfo) {
//---------------------------------------------------------------------------
  var output = '';
  output += "Total tokens: " + stats.totAllTokens + "\n";
  output += "Total goal tokens: " + stats.totGoalAmts + "\n";
  output += "Avg tokens/hour: " + getTokensPerTime(60) + "\n";
  if (includeExtraInfo) {
    output += "Total $$$: $" + getTotalDollars() + "\n";
    output += "Avg $$$/hour: $" + getDollarsPerTime(60) + "\n";
  }
  output += "\n--- Tip Stats ---\n";
  output += "Highest total tip: " + stats.highTip + " from " + stats.highUser + "\n";
//  output += "Awesomest tip: " + Tipping.Leaderboard.Leaders.Highest.Amount + " from " + Tipping.Leaderboard.Leaders.Highest.Username + "\n";
//  output += "Stingiest tip: " + Tipping.Leaderboard.Leaders.Lowest.Amount + " from " + Tipping.Leaderboard.Leaders.Lowest.Username + "\n";
  output += "Most recent tip: " + stats.mostRecentTip + " from " + stats.mostRecentUser + "\n";
//  output += "\n--- Leaderboard (All) ---\n";
  output += formatLbUserList(0, 1, tokTypeTotTok);
  return output;
}

//---------------------------------------------------------------------------
function buildInviteList_Flash(cnt) {
//---------------------------------------------------------------------------
  var xmsg = '';
  var tokType  = tokTypeFlashTok;
  var showType = showTypeDesc[tokType];
  var samt = hiddenShow.getFlashPrice();
  
  if (samt <= 0) {
    xmsg += showType + " show is not enabled\n";
    return xmsg;
  }
  
  if (!hiddenShow.getIsFlashShowRunning()) 
    xmsg += showType + " show is not currently running:\n";
  else {
    xmsg += showType + " show is running for these users:\n";
    var userlist = hiddenShow.getAccessUsers();
    xmsg += userlist.join(', ') + "\n" + "Total = " + userlist.length;
  }

  var userlist = getLbUserList(cnt, samt, tokType);
  if (userlist.length === 0)
    xmsg += "No users waiting for " + showType + "\n";
  else {
    xmsg += "Users and token amts waiting for " + showType + ":\n";
    var dlm = ', ';
    for (var i = 0, ul = userlist.length; i < ul; i++) {
      if (i === ul - 1) dlm = '';      
      var user = userlist[i];
      var amt  = UserObj.prototype.getTokTypeVal(user, tokType);
      xmsg    += user + "=" + amt + dlm;
    }
    xmsg += "\n";
  }
  return xmsg;
}

//---------------------------------------------------------------------------
function buildInviteList_Ticket(cnt) {
//---------------------------------------------------------------------------
  var xmsg = '';
  var tokType  = tokTypeTicketTok;
  var showType = showTypeDesc[tokType];
  var samt = hiddenShow.getTicketPrice();
  
  if (samt <= 0) {
    xmsg += showType + " show is not enabled\n";
    return xmsg;
  }
  
  if (!hiddenShow.getIsTicketShowRunning())
    xmsg += showType + " show is not currently running:\n";
  else {
    xmsg += showType + " show is running for these users:\n";
    var userlist = hiddenShow.getAccessUsers();
    xmsg += userlist.join(', ') + "\n";
  }

  var userlist = getLbUserList(cnt, samt, tokType);
  if (userlist.length === 0)
    xmsg += "No users waiting for " + showType + "\n";
  else {
    xmsg += "Users and token amts waiting for " + showType + ":\n";
    var dlm = ', ';
    for (var i = 0, ul = userlist.length; i < ul; i++) {
      if (i === ul - 1) dlm = '';      
      var user = userlist[i];
      var amt  = UserObj.prototype.getTokTypeVal(user, tokType);
      xmsg    += user + "=" + amt + dlm;
    }
    xmsg += "\n";
  }
  return xmsg;
}

//---------------------------------------------------------------------------
function buildInviteList_Hidden(cnt) {
//---------------------------------------------------------------------------
  var xmsg = '';
  var tokType  = tokTypeBhsTok;
  var showType = showTypeDesc[tokType];
  var samt = hiddenShow.getBhsPrice();
  
  if (samt <= 0) {
    xmsg += showType + " show is not enabled\n";
    return xmsg;
  }
  
  if (hiddenShow.getIsHiddenShowRunning()) {
    xmsg += showType + " show is running for these users:\n";
    var userlist = hiddenShow.getAccessUsers();
    xmsg += userlist.join(', ') + "\n";
  }
  else {
    xmsg += showType + " show is not currently running\n";
    
    if (hiddenTimerObj.getIsRunning())
      xmsg += "Before-" + showType + " timer is running for " + (hiddenTimerObj.nIntervals - hiddenTimerObj.intervalCnt).toString() + " mins, " + hiddenTimerObj.intervalCnt + " mins left\n";

    var userlist = hiddenShow.getHiddenUsers();

    if (userlist.length === 0)
      xmsg += "No users waiting for " + showType + "\n";
    else {
      xmsg += "Users and token amts waiting for " + showType + ":\n";
//      var userlist = getLbUserList(cnt, hiddenShow.getBhsPrice(), tokTypeBhsTok);
        
      var dlm = ', ';
      for (var i = 0, ul = userlist.length; i < ul; i++) {
        var user = userlist[i];
        if (i === ul - 1) dlm = '';      
        var bhsamt = UserObj.prototype.getTokTypeVal(user, tokTypeBhsTok);
        xmsg += user + "=" + bhsamt + dlm;
      }
      xmsg += "\n";
    }
  }
  return xmsg;
}
  
//---------------------------------------------------------------------------
function displayHelp(arg1, arg2) {
//---------------------------------------------------------------------------

  var arr = [];
  var errFlg = false;
  
  if (isUndefined(arg2))
    arg2 = '??';

  if (!isUndefined(arg1) &&
      (arg1.indexOf('*') !== -1 ||
       arg1.indexOf('?') !== -1))
     
    arg1 = new RegExp('^' + arg1.replace('*','.*').replace('?','.') + '$');

  var arg1len = arg1.length;

  for (var p in cmdObj) {
    if (isUndefined(p) || !cmdObj.hasOwnProperty(p)) continue;

    if (p.length > 8 && p.substr(0,8) === "cmdFunc_" &&
        p.substr(-4) !== "_chk") {

      var cmd = p.substr(8); 
      if (cmd === "help") continue;
      
      var cmdFuncChk = p + "_chk";
      errFlg = isUndefined(cmdObj[cmdFuncChk]);

      if (!errFlg) {
        var cmdFuncChkStrL = (cmdObj[cmdFuncChk])[0];
        var cmdFuncChkStr  = (cmdObj[cmdFuncChk])[1];
        errFlg = typeof cmdFuncChkStr !== "string";
      }
      
      if (!errFlg) {
        var cmdChk = "cmdChk_" + cmdFuncChkStr;
        errFlg = typeof cmdObj[cmdChk] !== "function";
      }

      if (! errFlg)
        errFlg = !cmdObj[cmdChk].call();

      if (! errFlg) {
        if (isUndefined(arg1) ||
            arg1 instanceof RegExp && cmd.match(arg1) ||
            arg1len >= cmdFuncChkStrL && arg1 === cmd.substr(0, arg1len))
          arr.push(p);
      }
    }
  }

  arr.sort();
  
  for (var i = 0, arrl = arr.length; i < arrl; i++) {
    var cmdFunc = arr[i];

    if (typeof cmdObj[cmdFunc] === "function") {
      var args = [['', "help", arg2]];
      errFlg = ! cmdObj[cmdFunc].apply(cmdObj, args);
    }
  }

  return !errFlg;
}

//---------------------------------------------------------------------------
function cmdAlias(aliasName, cmdFunc) {
//---------------------------------------------------------------------------
  return [aliasName, cmdFunc];
}

//---------------------------------------------------------------------------
function getCmdInfo(arg) {
//---------------------------------------------------------------------------

  for (var p in cmdObj) {
    if (isUndefined(p) || !cmdObj.hasOwnProperty(p)) continue;

    if (p.length > 8 && p.substr(0,8) === "cmdFunc_" &&
        p.substr(-4) === "_chk") {

      var cmdFunc = p.substr(0, p.length - 4);
      var cmd     = p.substr(8, p.length - 12);
      var chkInfo = cmdObj[p];
      var cmdLen  = chkInfo[0];
      var cmdAuth = chkInfo[1];
      
      if (typeof(cmdObj[cmdFunc]) === "string")
        cmdFunc = cmdObj[cmdFunc];
      
//      var cmdOrig = (typeof(cmdObj[cmdFunc]) === "function" ? '' : cmdObj[cmdFunc]);
      //         cmdObj[cmdFunc] !== cmdOrig) {
      
      if (arg === cmd.substr(0,Math.max(cmdLen, arg.length)))
//        return [cmd, cmdLen, cmdAuth, cmdFunc, cmdOrig];
        return ({cmd: cmd, cmdLen: cmdLen, cmdAuth: cmdAuth, cmdFunc: cmdFunc});
    }
  }
  
  return null;
}

//---------------------------------------------------------------------------
function chkCmdAuth(cmdInfo) {
//---------------------------------------------------------------------------

  var arr = [];
  var errFlg = false;
  
  var cmdChk = "cmdChk_" + cmdInfo.cmdAuth;
  errFlg = typeof cmdObj[cmdChk] !== "function";

  if (! errFlg)
    errFlg = !cmdObj[cmdChk].call();

  return (!errFlg);
}

//---------------------------------------------------------------------------
cb.onMessage(function(xmsg) {
//---------------------------------------------------------------------------
  msg     = xmsg;
  msgUser = msg.user;
  
  if (msg.is_mod && isAuthor(msgUser))
    modUser = msgUser;
  
  /* Tip king highlighting */
  if (settings.highlight_theme !== 'none' && msgUser === stats.highUser) {
    msg.background = getTipperTheme().high_total_color;
  }
  else if (settings.highlight_theme !== 'none' && msgUser === stats.highUser) {
    msg.background = getTipperTheme().high_tipper_color;
  }

  if (msg.m.substr(0, 1) === '#' && isAuthor(msgUser)) {
    msg.in_fanclub = true;
    msg.m = msg.m.substr(1);
    msg.background = "#3C6793";
    msg.c = "#fff";
    return msg;
  };
  
  // If msg starts with a /, suppress it and assume it is a command

  if (msg.m.substr(0, 1) !== "/") {
    if (!settings.showEmotes && !isSuperuser(msgUser))
      msg.m = msg.m.replace(':', '').
                    replace('<', '(').
                    replace('>', ')');
    return msg;
  }
  
  if (msg.m.substr(0, 5) === '/tip ')
    return msg;
  
  msg["X-Spam"] = true;
  
//  Msg.sendMsg(Msg.toO, "Orig user = " + msgUser + ", author = " + appVars.Author + ", superuser() = " + isSuperuser(msgUser));

  if (! isSuperuser(msgUser))
    return msg;
    
  Msg.sendMsg(Msg.toO, "Cmd entered by " + msgUser + ": " + msg.m);
  
  var cmd  = '';
  var ocmd = '';
  var args = '';
  var str  = msg.m.substr(1);
  var args = str.match(/(\'.*?\')|(\".*?\")|(\S+)/ig);

  var errFlg = isUndefined(args);

  if (! errFlg) {
    ocmd = cmd = args[0];
    var argStr = args.join(' ');
    args.splice(0, 0, argStr);

    var cmdInfo = getCmdInfo(cmd);
    errFlg = isUndefined(cmdInfo);
  }
//        return ({cmd: cmd, cmdLen: cmdLen, cmdAuth: cmdAuth, cmdFunc: cmdFunc});
 
  if (! errFlg) {
        cmd      = cmdInfo.cmd;
    var cmdLen   = cmdInfo.cmdLen;
    var cmdAuth  = cmdInfo.cmdAuth;
    var cmdFunc  = cmdInfo.cmdFunc;
  
//    var cmdFunc = "cmdFunc_" + (cmdOrig !== '' ? cmdOrig : cmd);
    errFlg = isUndefined(cmdFunc) || typeof cmdObj[cmdFunc] !== "function";
  }

  if (!errFlg)
    errFlg = execMsgCmd(args, cmdInfo);

  if (errFlg)
    Msg.sendMsg(Msg.toMO, "Invalid cmd: " + ocmd);

  return msg;
});

//---------------------------------------------------------------------------
function execMsgCmd(args, cmdInfo) {
//---------------------------------------------------------------------------
  try {
    var cmd      = cmdInfo.cmd;
    var cmdLen   = cmdInfo.cmdLen;
    var cmdAuth  = cmdInfo.cmdAuth;
    var cmdFunc  = cmdInfo.cmdFunc;
    errFlg = !chkCmdAuth(cmdInfo);

    if (! errFlg) {
      args = [args];
      errFlg = !cmdObj[cmdFunc].apply(cmdObj, args);
    }
  }
/****/
  catch(e) {
    var uExceptionPrefL = settings.uExceptionPref.length;
    if (e.name.substr(0, uExceptionPrefL) !== settings.uExceptionPref)
      Msg.sendMsg(Msg.toM, "Error caught in cmdFunc proc:" + objToString(e));

    errFlg = true;
    if (!appVars.ProdMode || e.name.substr(0, uExceptionPrefL) === settings.uExceptionPref) {
      unload();
      throw e;
    }
  }
  /****/
  return errFlg;
}

//---------------------------------------------------------------------------
var cmdObj = {
//---------------------------------------------------------------------------

//--- Broadcaster only
  cmdChk_broadcaster: function() {
    return isSuperuser(msgUser);
//    return isBroadcaster(msgUser);
  },

  //--- Broadcaster, moderator (if allowed)
  cmdChk_broadMod: function() {
    return isSuperuser(msgUser);
//    return isBroadMod(msgUser);
  },

  //--- Broadcaster, moderator (if allowed), author (if allowed)
  cmdChk_superUser: function() {
    return isSuperuser(msgUser);
  },

  //--- Author (if allowed)
  cmdChk_author: function() {
    return isAuthor(msgUser);
  },

  cmdFunc_addgoal_chk:      [3,"broadcaster"],
  cmdFunc_addtokens_chk:    [4,"superUser"],
  cmdFunc_admit_chk:        [3,"superUser"],
  cmdFunc_agoal_chk:        [2,"broadcaster"],    // alias of addgoal
  cmdFunc_chggoal_chk:      [3,"superUser"],
  cmdFunc_cgoal_chk:        [2,"broadcaster"],    // alias of chggoal
  cmdFunc_delgoal_chk:      [3,"superUser"],
  cmdFunc_deltokens_chk:    [4,"superUser"],
  cmdFunc_dgoal_chk:        [2,"broadcaster"],    // alias of delgoal
  cmdFunc_dumpstats_chk:    [6,"author"],
  cmdFunc_dumpsettings_chk: [6,"author"],
  cmdFunc_emotes_chk:       [2,"superUser"],
  cmdFunc_eval_chk:         [2,"author"],
  cmdFunc_exit_chk:         [4,"superUser"],
  cmdFunc_flash_chk:        [2,"superUser"],
  cmdFunc_fshow_chk:        [1,"superUser"],
  cmdFunc_goals_chk:        [1,"superUser"],
  cmdFunc_help_chk:         [2,"superUser"],
  cmdFunc_hidden_chk:       [2,"superUser"],
  cmdFunc_hshow_chk:        [1,"superUser"],
  cmdFunc_hidemsg_chk:      [4,"superUser"],
  cmdFunc_msg_chk:          [1,"superUser"],
  cmdFunc_next_chk:         [1,"superUser"],
  cmdFunc_pm_chk:           [2,"superUser"],
  cmdFunc_reset_chk:        [2,"superUser"],
  cmdFunc_setcolors_chk:    [4,"superUser"],
  cmdFunc_stats_chk:        [2,"superUser"],
  cmdFunc_support_chk:      [2,"broadcaster"],
  cmdFunc_tickets_chk:      [2,"superUser"],
  cmdFunc_tshow_chk:        [1,"superUser"],
  cmdFunc_timer_chk:        [3,"superUser"],
  cmdFunc_tipopts_chk:      [4,"superUser"],
  cmdFunc_unadmit_chk:      [2,"superUser"],
  cmdFunc_xdebug_chk:       [2,"author"],
  cmdFunc_xtip_chk:         [4,"author"],
  cmdFunc_version_chk:      [2,"superUser"]
};

//------------------------------------------------------------------------------
function displayHelpMsg(helpMsg, arg) { 
//------------------------------------------------------------------------------

  if (!isUndefined(arg) && arg.substr(0,1) === '?') {
    switch(arg) {
//*   case '??': 
      case '?': 
        helpMsg = helpMsg.substring(0, helpMsg.indexOf('\n')).substr(7);
        Msg.sendMsg(Msg.toO, helpMsg);
        break;
        
      case '???':
        helpMsg = helpMsg.substr(7);
        var helpMsgs = helpMsg.split('\n');
        Msg.sendMsg(Msg.toO, helpMsgs[0]);
        Msg.sendMsg(Msg.toO, helpMsgs.slice(1).join('/n'));
        break;

      case '??':
      default:
        var helpMsgs = helpMsg.split('\n');
        Msg.sendMsg(Msg.toO, helpMsgs[0]);
        Msg.sendMsg(Msg.toO, helpMsgs.slice(1).join('/n'));
        break;
    }

    return true;
  }
  return false;
}

//------------------------------------------------------------------------------
cmdObj.cmdFunc_addgoal = function(args) {
//------------------------------------------------------------------------------
  // /addgoal *|goal#[/repcnt] tokens description|'description'|"description"
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /ADDGoal *|goal#[/repcnt] tokens description\n-- Adds goal at end (*) or after goal#. Tokens and description are required. Tokens must be > 1. Repcnt * (default) is normal goal, 0 repeats/resets goal indefinitely, n repeats/resets goal n times. Description can either be a string or string in single- or double-quotes.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var goalId, tokens, desc;
  var repCnt = -1;
  
  // {*|goalid}[/repcnt]
  if (isUndefined(args[2]) || isUndefined(args[3] || isUndefined(args[4])))
    errMsg = helpMsg;
  else {
    var arg2 = args[2].match(/^(.+?)\/?(.*)$/i);
    if (arg2 !== null) {
      if (arg2[1] === '*')
        goalId = goalLast9();
      else if (isNumericStr(arg2[1]))
        goalId = parseInt(arg2[1]);
      else
        errMsg = helpMsg;
      
      if (errMsg === '')
        if (!isUndefined(arg2[2])) {
          if (arg2[2] === '')
            repCnt = 0;
          else if (isNumericStr(arg2[2])) {
            if ((repCnt = parseInt(arg2[2])) < 0)
              errMsg = helpMsg;
          }
/*******************************
          else if (arg2[2] === '*')
            repCnt = -1;
*******/
          else
            errMsg = helpMsg;
        }
    }              
    else
      errMsg = helpMsg;
  }
  
  // Tokens
  if (errMsg === '') {
    if (isNumericStr(args[3]))
      tokens = parseInt(args[3]);
    else
      errMsg = helpMsg;
  }
    
  // Desc
  if (errMsg === '') {
    if (args[4].substr(0,1) === '"' || args[4].substr(0,1) === "'")
      desc = args[4].substr(1,args[4].length - 2);
    else
      desc = args.slice(4).join(' ');
  }
  
  if (errMsg === '') {
    if (goalId < goalFirst() || goalId > goalLast9() || tokens < 1)
      errMsg = helpMsg;
    else {      
      addGoal(goalId, repCnt, tokens, desc, goalTypeNormal);
      if (goalId === goalCur())
        updPanel();
      if (repCnt === -1)
        repCnt = '';
      else if (repCnt === 0)
        repCnt = '/' + '99999';
      else
        repCnt = '/' + repCnt;
      
      Msg.sendMsg(Msg.toBMO, "{0} has added new goal ({1}{2}) {3} - '{4}'".format(msgUser, goalId, repCnt, tokens, desc));
    }
  }

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_agoal = 'cmdFunc_addgoal';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_addtokens = function(args) {
//------------------------------------------------------------------------------
  // /addtokens tokens
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /ADDTokens tokens\n-- adds virtual tokens to the current tokens, and keeps track of total virtual tokens. Tokens must be > 0";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var tokens = 0;
  
  if (!isUndefined(args[2]))
    tokens = parseInt(args[2]);
  
  if (tokens > 0) {
    Msg.sendMsg(Msg.toBMO, "Added {0} tokens to the current goal by {1}".format(tokens, msgUser));
    recordTip(msgUser, tokens, true);
  }
  else
    Msg.sendMsg(Msg.toO, helpMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_admit = function(args) {
//------------------------------------------------------------------------------
  // /admit user|userlist
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /ADMit user|userlist\n-- adds user (or list of users separated by blank or comma) into current or next hidden show";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  users = args.slice(2).join(', ');
  if (!isUndefined(users)) {
    hiddenShow.addHiddenUsers(users);
    Msg.sendMsg(Msg.toBMO, "Users added to hidden show: {0}".format(msgUser, users));
  }
  else
    Msg.sendMsg(Msg.toO, helpMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_chggoal = function(args) {
//------------------------------------------------------------------------------
// /chggoal [Reset] *|goal#[/repcnt] *|tokens *|description|'description'|"description"
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /CHGgoal [Reset] *|goal#[/repcnt] *|tokens *|description\n-- changes specified goal (goal# or * for current goal) tokens and/or description. Tokens and description are required but can be * to keep current values. Tokens must be > 1. Repcnt * (default) is normal goal, 0 repeats/resets goal indefinitely, n repeats/resets goal n times. Description can either be a string, string in single-quotes, or string in double quotes.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var goalId, repCnt, tokens, desc;
  var oldRepCnt = '*';
  var oldGoalDesc = '*';
  var oldTokens = '*';
  var oldRepCnt = '*';
  var resetFlg  = false;

  // [Reset]
  if (isUndefined(args[2]))
    errMsg = helpMsg;
  else {
    var len2 = args[2].length;
    if (len2 >= 1 && args[2] === 'reset'.substr(0, len2)) {
      args.splice(2, 1);
      resetFlg = true;
    }
  }
  
  // {*|goalid}[/repcnt]
  if (isUndefined(args[2]) || isUndefined(args[3] || isUndefined(args[4])))
    errMsg = helpMsg;
  else {
    var arg2 = args[2].match(/^(.+?)\/?(.*)$/i);
    if (arg2 !== null) {
      if (arg2[1] === '*')
        goalId = goalCur();
      else if (isNumericStr(arg2[1]))
        goalId = parseInt(arg2[1]);
      else
        errMsg = helpMsg;
        
      if (errMsg === '') {
        oldGoalDesc = getGoalDesc(goalId);
        oldTokens   = getGoalAmt(goalId);
        oldRepCnt   = getGoalRepCnt(goalId);
        repCnt      = -1;

        if (args[2] === '*' || arg2[2] === '*')
          repCnt = oldRepCnt;
        else if (isUndefined(arg2[2]))
          repCnt = -1;
        else if (isNumericStr(arg2[2])) {
          if ((repCnt = parseInt(arg2[2])) < 0)
            errMsg = helpMsg;
        }            
        else
          errMsg = helpMsg;
      }
    }
    else
      errMsg = helpMsg;
  }
  

  // *|tokens
  if (errMsg === '') {
    if (args[3] === '*')
      tokens  = oldTokens;
    else if (isNumericStr(args[3]))
      tokens = parseInt(args[3]);
    else
      errMsg = helpMsg;
  }
    
  
  // *|desc|'desc'|"desc"
  if (errMsg === '') {
    if (args[4] === '*')
      desc = oldGoalDesc;
    else if (args[4].substr(0,1) === '"' || args[4].substr(0,1) === "'")
      desc = args[4].substr(1,args[4].length - 2);
    else
      desc = args.slice(4).join(' ');
  }
  
  if (errMsg === '') {
    if (goalId < goalFirst() || goalId > goalLast() || tokens < 1 ||
        chgGoal(goalId, repCnt, tokens, desc) === null)
      errMsg = helpMsg;
    else {
      var chgStr = 'changed';
      if (resetFlg) {
        stats.curGoalSerNo--;
        resetGoal(goalId);
        chgStr += ' and reset';
      }
//      if (goalId === goalCur())
      updPanel();

      if (repCnt === -1)
        repCnt = '';
      else if (repCnt === 0)
        repCnt = '/' + '99999';
      else
        repCnt = '/' + repCnt;

      if (oldRepCnt === -1)
        oldRepCnt = '';
      else if (oldRepCnt === 0)
        oldRepCnt = '/' + '99999';
      else
        oldRepCnt = '/' + oldRepCnt;
      
      Msg.sendMsg(Msg.toBMO, "{0} has {1}\ngoal{2}{3} Tokens={4} Desc='{5}\nto\ngoal{6}{7} Tokens={8}, Desc={9}'".format(msgUser, chgStr, goalId, oldRepCnt, oldTokens, oldGoalDesc, goalId, repCnt, getGoalAmt(goalId), getGoalDesc(goalId)));
    }
  }

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_cgoal = 'cmdFunc_chggoal';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_delgoal = function(args) {
//------------------------------------------------------------------------------
  // /delgoal All|*(|goal1# [goal2#])
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /DELGoal All|*|goal# 'goal2#])\n-- deletes specified goal. If goal# is current goal, then resets goal to no goal";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var goal1, goal2;
  
  if (isUndefined(args[2]))
    errMsg = helpMsg;
  else {
    var len2 = args[2].length;
    if (args[2] === '*')
      goal1 = goal2 = goalCur();
    else if (len2 > 0 && args[2] === "all".substr(0, len2)) {
      goal1 = goalFirst();
      goal2 = goalLast();
    }
    else if (isNumericStr(args[2])) {
      goal1 = parseInt(args[2]);
      if (isNumericStr(args[3]))
        goal2 = parseInt(args[3]);
      else
        goal2 = goal1;
    }
    else
      errMsg = helpMsg;
  }
  
  if (errMsg === '') {
    if (goal1 < goalFirst() || goal1 > goalLast() || 
        goal2 < goalFirst() || goal2 > goalLast() ||
        goal2 < goal1)
      errMsg = helpMsg;
  }

  if (errMsg === '')
    if (! delGoals(goal1, goal2))
      errMsg = helpMsg;

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_dgoal = 'cmdFunc_delgoal';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_deltokens = function(args) {
//------------------------------------------------------------------------------
  // /deltokens tokens
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /DELTokens tokens\n-- deleted (removes) virtual tokens from the current tokens, and keeps track of total virtual tokens. Tokens must be > 0. Will not remove more than oustanding virtual tokens.";

  var errMsg = '';
  var errMsg1 = "No virtual tokens to remove";
  
  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var tokens = 0;
  
  if (!isUndefined(args[2]))
    tokens = parseInt(args[2]);
  
  if (tokens > 0)
    var tokens = Math.min(getGoalVCurAmt(goalCur()), tokens);
  else
    errMsg = helpMsg;
  
  if (errMsg !== '' && 
      tokens > 0) {
    
    Msg.sendMsg(Msg.toBMO, "Removed {1} virtual tokens from the current goal by {1}".format(tokens, msgUser));
    recordTip(msgUser, -tokens, true);
  }
  else
    errMsg = errMsg1;
  
  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_dumpstats = function(args) {
//------------------------------------------------------------------------------
  // /dumpstats
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /DUMPSTats\n-- dumps internal stats.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  // For diagnosing stats issues - have seen some issues where balances don't update after a tip for some reason 
  cb.chatNotice("sum_total_goal: " + getSumTotalGoal() +
                ", Tipping.VirtualTotal: " + Tipping.VirtualTotal +
                ", Tipping.CurrentGoal.CurrentAmount: " + Tipping.CurrentGoal.CurrentAmount +
                ", Tipping.ActualTotal: " + Tipping.ActualTotal +
                ", total_remaining: " + (getSumTotalGoal() - Tipping.VirtualTotal) +
                ", Tipping.CurrentGoal.Number: " + Tipping.CurrentGoal.Number, msgUser);
  cb.chatNotice("Tipping.Leaderboard.Leaders.Highest.Amount: " + Tipping.Leaderboard.Leaders.Highest.Amount +
                ", Tipping.Leaderboard.Leaders.Highest.Username: " + Tipping.Leaderboard.Leaders.Highest.Username +
                ", Tipping.Leaderboard.Leaders.Lowest.Amount: " + Tipping.Leaderboard.Leaders.Lowest.Amount +
                ", Tipping.Leaderboard.Leaders.Lowest.Username " + Tipping.Leaderboard.Leaders.Lowest.Username +
                ", Tipping.Leaderboard.Leaders.MostRecent.Amount: " + Tipping.Leaderboard.Leaders.MostRecent.Amount +
                ", Tipping.Leaderboard.Leaders.MostRecent.Username: " + Tipping.Leaderboard.Leaders.MostRecent.Username, msgUser);
  cb.chatNotice("Tipping.Leaderboard.Leaders.HighestTotal.Username: " + Tipping.Leaderboard.Leaders.HighestTotal.Username +
                ", Tipping.Leaderboard.Leaders.HighestTotal.Amount: " + Tipping.Leaderboard.Leaders.HighestTotal.Amount, msgUser);
  cb.chatNotice("Tipping.Leaderboard.Leaders.HighestTotal.OptOut: " + Tipping.Leaderboard.Leaders.HighestTotal.OptOut +
                ", Tipping.Leaderboard.Leaders.Highest.OptOut: " + Tipping.Leaderboard.Leaders.Highest.OptOut, msgUser);
  cb.chatNotice("appVars.StartupTime: " + appVars.StartupTime +
                ", Tokens Per Hour: " + getTokensPerTime(60) +
                ", Dollars Per Hour: " + getDollarsPerTimee(60), msgUser);
  cb.chatNotice("Leaderboard:\n" + formatLbUserList(0, 1, tokTypeTotTok), msgUser);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_dumpsettings = function(args) {
//------------------------------------------------------------------------------
  // /dumpsettings
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /DUMPSEttings\n-- dumps internal settings.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  cb.chatNotice(cb.settings, msgUser);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_emotes  = function(args) {
//------------------------------------------------------------------------------
  // /emotes ON|OFF
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /EMotes [ON|OFF]\n-- turns ON or OFF emoticon output in messages. OFF will prevent display of emoticon GIFs, blank to display current setting.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  if (isUndefined(args[2]))
    Msg.sendMsg(Msg.toO, "Show emoticons in msgs setting is " + (settings.showEmotes ? "ON" : "OFF"));
    
  else if (args[2] === "on") {
    settings.showEmotes = true;
    Msg.sendMsg(Msg.toBMO, "Show Emoticons in Msgs set to ON by {0}".format(msgUser));
  }
  
  else if (args[2] === "off") {
    settings.showEmotes = false;
    Msg.sendMsg(Msg.toBMO, "Show Emoticons in Msgs set to OFF by {0}".format(msgUser));
  }
  
  else
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_eval  = function(args) {
//------------------------------------------------------------------------------
  // /eval exp
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /EVal exp\n-- evaluates and displays the expression";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var exp = args.slice(2).join(' ');
  var result = '';
  try {
    result = (1, eval)(exp);   // .toString();
    /*
    if (typeof result !== "string")
      result = result.toString();
    */
  }
  catch(e) {
    Msg.sendMsg(Msg.toM, "Error caught in eval:" + e);
  };
  
  Msg.sendMsg(Msg.toO, "Eval result: \(" + result + "\)");

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_exit  = function(args) {
//------------------------------------------------------------------------------
  // /exit
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /EXIT\n-- exits the app";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  Msg.sendMsg(Msg.toBMO, 'User ' + msgUser + ' requested graceful exit of app ' + appVars.Name + ' ' + appVars.Version);
  unload();
  throw new userException(settings.uExceptionPref + '_ExitApp', 'Gracefully exiting app ' + appVars.Name + ' ' + appVars.Version);
  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_fshow = function(args) {
//------------------------------------------------------------------------------
  // /Fshow [ON|OFF|All|Status|Price [p1[,p2]|Add users|Admit users|Invite users|Unadmit users|Remove users|Uninvate users]
  var tokType  = tokTypeFlashTok;
  var showType = showTypeDesc[tokType];

  var helpMsg = "USAGE: /Fshow [1|ON|OFF|STatus|Add users|Invite users|Admit users]|Unadmit users|Remove users|Uninvite users|Msg hidemsg\n-- ON enters " + showType + " for next queued user, OFF exits " + showType + ", All enters " + showType + " for all queued users, blank or Status displays " + showType + " status and waiting users, Add adds users (separated by blanks or commas) to " + showType + ". " + showType + " will not start if any hidden show is already running, Msg sets new " + showType + " hidden cam msg. Price displays show price, or sets price if specified.";

  var parms = {};
  
  parms.tokType = tokType;
  parms.showType = showType;
  parms.startShow = function(parms, userlist) {return hiddenShow.startFlashShow(userlist); };
  parms.stopShow  = function() {return hiddenShow.stopFlashShow(); };
  parms.isShowRunning = function() {return hiddenShow.getIsFlashShowRunning(); };
  parms.inviteFunc = buildInviteList_Flash;
  parms.samt = hiddenShow.getFlashPrice();
  parms.helpMsg = helpMsg;
  parms.setMsg = function(msg) { return hiddenShow.setFlashMessage(msg); };
  parms.setPrice = function(p1, p2) { hiddenShow.setFlashPrice(p1, p2); };  
  parms.getPrice = function() { return hiddenShow.getFlashPrice(); };  
  
  return commonShow(args, parms);
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_flash = 'cmdFunc_fshow';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_goals = function(args) {
//------------------------------------------------------------------------------
  // /GOals [Timer [ON mins|OFF]]
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /GOals [Timer [ON mins|OFF]]\n-- displays list of goals, current, and next goal. If TImer specified, sets goal timer ON to #mins, sets goal timer OFF, or displays goal timer status";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var errMsg1 = "Enter /timer #mins where #mins is a number from 1 to 60";
  var errMsg2 = "Goal timer is not running";
  var errMsg3 = "Goal timer is already running";
  
  if (isUndefined(args[2])) {
    Msg.sendMsg(Msg.toO, "\n--- All Goals ---");
    Msg.sendMsg(Msg.toO, getAllGoals());

    return true;
  }

  var len2 = args[2].length;
  if (!isUndefined(args[2]) && (len2 < 1 || args[2] !== 'timer'.substr(0, len2)))
    errMsg = helpMsg;
  else if (isUndefined(args[3])) {
/*************************************************
    var xmsg = "\n--- Timer List ---\n";
    for (var i = 0, tl = timerList.length; i < tl; i++) {
      var timerObj = timerList[i];
      xmsg += "Timer[" + i + "]: Name=" + timerObj.name + " running=" + (timerObj.running ? "Y" : "N") + " #mins=" + timerObj.nIntervals + " left=" + timerObj.intervalCnt + " intrvl=" + (timerObj.interval / 1000) + "s\n";
    }
**************************************************/
    var xmsg = "\n--- Goal Timer ---\n";
    xmsg += " Running=" + (goalTimerObj.running ? "Y" : "N") + " #Mins=" + goalTimerObj.nIntervals + " Left=" + goalTimerObj.intervalCnt + " Name=" + goalTimerObj.name + "\n";
    Msg.sendMsg(Msg.toO, xmsg);
  }      
  else if (args[3] === 'off') {
    if (!goalTimerObj.getIsRunning())
      errMsg = errMsg2;
    else {
      goalTimerObj.stop();
      Msg.sendMsg(Msg.toBMO, "{0} has stopped the goal timer".format(msgUser));
    }
  }
  else if (args[3] === 'on') {
    if (goalTimerObj.getIsRunning())
      errMsg = errMsg3;
    else {
      if (!isNumericStr(args[4]))
        errMsg = helpMsg;
    }
  
    if (errMsg === '') {
      var mins = parseInt(args[4]);
      if (mins < 0 || mins > 60)
        errMsg = errMsg1;
      else {
        goalTimerObj.start(mins);
        Msg.sendMsg(Msg.toO, "Goal timer set to {0} minutes by {1}.  Type '/GOals TImer OFF' to stop it early".format(mins, msgUser));
      }
    }
  }
  else
    errMsg = errMsg1;
  
  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_help = function(args) {
//------------------------------------------------------------------------------
  // /help
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  Msg.sendMsg(Msg.toO, "*** Command Help ***");

  var op1 = args[2];
  var op2 = args[3];

  if (isUndefined(op1))
    op1 = '';
  
  if (isUndefined(op2))
    op2 = '';
  
  var len1 = op1.length;
  var len2 = op2.length;
  
  if (op2 === '') {         
    if (len1 > 0 &&
        (op1 === 'all'.substr(0, len1) ||
         op1 === 'full'.substr(0, len1))) {

      op2 = '???';
      op1 = '';
    } 
    else {
//*   op2 = '??';
      op2 = '?';
//      if (op1 === '')
//        op1 = '*';
    }
  }
  else if (len2 > 0 &&
           (op2 === 'all'.substr(0, len2) ||
            op2 === 'full'.substr(0, len2)))

    op2 = '???';
  else
//* op2 = '??';
    op2 = '?';
  
  displayHelp(op1, op2);

    Msg.sendMsg(Msg.toO, "Enter /help [cmd] [ALL | FULL] to display help for cmd (can include wildcards (*,?), ALL or FULL displays full help\n*** End Command Help ***");

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_hshow = function(args) {
//------------------------------------------------------------------------------
  // /Hshow [ON|OFF|STatus|Add users|Admit users|Invite users|Unadmit users|Remove users|Uninvate users]
  var tokType  = tokTypeBhsTok;
  var showType = showTypeDesc[tokType];

  var helpMsg = "USAGE: /Hshow [ON|OFF|STatus|Add users|Invite users|Admit users]|Unadmit users|Remove users|Uninvite users|Msg hidemsg\n-- blank or STatus displays " + showType + " status and waiting users, ON enters " + showType + " for all queued users, OFF exits " + showType + ",  Add adds users (separated by blanks or commas) to " + showType + ". " + showType + " will not start if any hidden show is already running. If " + showType + " timer minutes was specified at startup, enters " + showType + " after # minutes and displays info msgs every minute before " + showType + ", Msg sets new " + showType + " hidden cam msg.";

  var parms = {};
  
  parms.tokType = tokType;
  parms.showType = showType;
  parms.startShow = function() {nextGoal(goalLast9); };
  parms.stopShow  = function() {nextGoal(goalFirst0); hiddenShow.stopHiddenShow(); };
  parms.isShowRunning = function() { return hiddenShow.getIsHiddenShowRunning(); };
  parms.inviteFunc = buildInviteList_Hidden;
  parms.samt = hiddenShow.getBhsPrice();
  parms.helpMsg = helpMsg;
  parms.setMsg = function(msg) { return hiddenShow.setHiddenMessage(msg); };
  parms.setPrice = function(p1, p2) { hiddenShow.setHiddenPrice(p1, p2); };  
  parms.getPrice = function() { return '' + hiddenShow.getBhsPrice() + ', ' + hiddenShow.getDhsPrice(); };  
  
  return commonShow(args, parms);
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_hidden = 'cmdFunc_hshow';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_hidemsg = 'cmdFunc_hsmsg';
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
cmdObj.cmdFunc_msg = function(args) {
//------------------------------------------------------------------------------
  // /msg [#fcolor] [#bcolor] [#weight] msg
  
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /Msg [#fcolor] [#bcolor] [#weight] msg\n-- sends msg ro room as if from app.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var ac      = 2;
  var fcolor  = '';
  var bcolor  = '';
  var weight  = '';
  
  if (!isUndefined(args[ac]) && args[ac].substr(0, 1) === '#')
    fcolor = args[ac++].substr(1);
  
  if (!isUndefined(args[ac]) && args[ac].substr(0, 1) === '#')
    bcolor = args[ac++].substr(1);

  if (!isUndefined(args[ac]) && args[ac].substr(0, 1) === '#')
    weight = args[ac++].substr(1);

  if (isUndefined(Colors[fcolor]))
    fcolor = '';
  else
    fcolor = Colors[fcolor];

  if (isUndefined(Colors[bcolor]))
    bcolor = '';
  else
    bcolor = Colors[bcolor];

  var pmMsg   = args.slice(ac).join(' ');

  Msg.sendMsg(Msg.toAll, pmMsg, null, bcolor, fcolor, weight);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_next = function(args) {
//------------------------------------------------------------------------------
  // /next [*|FIRST|LAST|HIDDEN|NONE|n]
  var showType = showTypeDesc[tokTypeBhsTok];

  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /NExt [*|FIRST|LAST|HIDDEN|NONE|n}\n-- sets next goal. * resets current goal. FIRST sets to first goal. LAST sets to last goal. HIDDEN starts " + showType + ". NONE sets no goal. N sets specified goal number";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var goalId;
  var errMsg  = '';
  
  if (isUndefined(args[2])) {
    Msg.sendMsg(Msg.toBMO, "{0} requested next goal".format(msgUser));
    goalId = goalNext;
  }
  else if (isNumericStr(args[2])) {
    Msg.sendMsg(Msg.toBMO, "{0} requested goal {1}".format(msgUser),args[2]);
    goalId = parseInt(args[2]);
  }
  else if (args[2] === '*')
    goalId = '*';
  else {
    var len2 = args[2].length;
    switch(args[2]) {
      case "first".substr(0, len2):
        Msg.sendMsg(Msg.toBMO, "{0} requested first goal".format(msgUser));
        goalId = goalFirst;
        break;
        
      case "last".substr(0, len2):
        Msg.sendMsg(Msg.toBMO, "{0} requested last goal".format(msgUser));
        goalId = goalLast;
        break;
        
      case "hidden".substr(0, len2):
        Msg.sendMsg(Msg.toBMO, "{0} requested hidden goal".format(msgUser));
        goalId = goalLast9;
        break;
        
      case "none".substr(0, len2):
        Msg.sendMsg(Msg.toBMO, "{0} requested no goal".format(msgUser));
        goalId = goalFirst0;
        break;

      default:
        errMsg = helpMsg;
        break;
    }
  }
  
  if (errMsg !== '')
     Msg.sendMsg(Msg.toO, errMsg);

  else {
    nextGoal(goalId);
    if (goalCur() !== goalPrev())
      Msg.sendMsg(Msg.toBMO, "Next goal {0} requested by {1} from goal {2}".format(stats.curGoalNo, msgUser, stats.prevGoalNo));
    else if (goalId === '*')
      Msg.sendMsg(Msg.toBMO, "Current goal {0} reset requested by {1}".format(stats.curGoalNo, msgUser));
  }

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_pm = function(args) {
//------------------------------------------------------------------------------
  // /pm msg
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /PM msg\n-- sends private msg to the other superuser party.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var user    = '';
  var pmMsg   = args.slice(2).join(' ');
  
  if (msgUser === cb.room_slug)
    user = Msg.toM;
  else
    user = Msg.toB;
  
  Msg.sendMsg(user, 'PM from ' + msgUser + ' ==> ' + pmMsg, null, Colors.Aquamarine, Colors.DarkBlue, 'bolder');

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_reset = function(args) {
//------------------------------------------------------------------------------
  // /reset [ALL]
  var showType = showTypeDesc[tokTypeBhsTok];

  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /REset [ALL]\n-- resets goal back to no goal and exits " + showType + ". If ALL is specified, resets all stats back to zero";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  if (args[2] === "all") {
    Msg.sendMsg(Msg.toBMO, "{0} requested full reset".format(msgUser));
    reset(true);
  }
  else {
    Msg.sendMsg(Msg.toBMO, "{0} requested partial reset".format(msgUser));
    reset(false);
  }
  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_setcolors = function(args) {
//------------------------------------------------------------------------------
  // /setcolors RANDOM|NONE|color
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /SETColortheme RANDOM|NONE|color\n-- color schemes available: 'None', 'Legacy', 'Sky', 'Ocean', 'Amethyst', 'Sunshine', 'Forest', 'Pink', 'Purple' or 'Random'";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var selectedTheme = args[2];

  if (isUndefined(selectedTheme))
    errMsg = helpMsg;
  else if (selectedTheme === "random" || selectedTheme === "all" ||
           !isUndefined(tipper_colors[selectedTheme])) {
  
    Msg.sendMsg(Msg.toBMO, "{0} has set the color theme to '{1}'".format(msgUser, selectedTheme));
    settings.highlight_theme = selectedTheme;
  }
  else
    errMsg = helpMsg;
  
  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_stats = function(args) {
//------------------------------------------------------------------------------
  // /stats
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /STats\n-- displays token and goal stats";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  Msg.sendMsg(Msg.toO, "\n--- Goal Statistics ---");
  Msg.sendMsg(Msg.toO, buildStatsOutput(isSuperuser(msgUser)));
  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_support = function(args) {
//------------------------------------------------------------------------------
  // /support ON|OFF
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /SUpport ON|OFF\n-- sets the support mode for the author";
  var errMsg = '';
  
  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  if (isUndefined(args[2]))
    {}
  else if (args[2] === "on")
    settings.support_mode = true;
  else if (args[2] === "off")
    settings.support_mode = false;
  else
    errMsg = helpMsg;

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);
  else
    Msg.sendMsg(Msg.toBMO, "Support mode setting is " + (settings.support_mode ? "ON" : "OFF"));
  return true;
  
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_tickets = function(args) {
//------------------------------------------------------------------------------
  // /tickets
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /TIckets\n-- displays user ticket info for hidden, " + showTypeDesc[tokTypeTicketTok] + ", and " + showTypeDesc[tokTypeTicketTok] + "s.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var buildFlg = false;
  
  if (hiddenShow.getTicketPrice() > 0) {
    Msg.sendMsg(Msg.toO, "\n--- " + showTypeDesc[tokTypeTicketTok] + " Invite List ---");
    Msg.sendMsg(Msg.toO, buildInviteList_Ticket(0));
    buildFlg = true;
  }
  
  if (hiddenShow.getFlashPrice() > 0) {
    Msg.sendMsg(Msg.toO, "\n--- " + showTypeDesc[tokTypeFlashTok] + " Invite List ---");
    Msg.sendMsg(Msg.toO, buildInviteList_Flash(0));
    buildFlg = true;
  }
  
  if (hiddenShow.getBhsPrice() > 0) {
    Msg.sendMsg(Msg.toO, "\n--- " + showTypeDesc[tokTypeBhsTok] + " Invite List ---");
    Msg.sendMsg(Msg.toO, buildInviteList_Hidden(0));
    buildFlg = true;
  }
  
  if (! buildFlg)
    Msg.sendMsg(Msg.toO, "No shows enabled");
    
  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_timer = function(args) {
//------------------------------------------------------------------------------
  // /TIMer [n {[ON [mins]|OFF|[Imsg imsg] [Emsg emsg]}]]
  // /TIMer [All]
  // /TIMer  n  ON  [mins]  [Imsg imsg]   [Emsg emsg]
  // /TIMer  n  OFF
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /TIMer [All] | [n ON [mins|*] | OFF | Imsg 'imsg' | Emsg 'emsg']]\n-- no operands displays all timers All displays all timers with msgs, n specifies timer#, ON starts timer with specified #mins (or * for no mins change), OFF turns off timer, Imsg sets the interval msg, Emsg sets the expired timer msg.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var errMsg1 = "Timer #n must be between 0 and " + (timerList.length - 1);
  var errMsg2 = "Cannot specify both ON and OFF";
  var errMsg3 = "Timer minutes must be either '*' or numeric between 0 and 59";
  var allFlg = false;
  var tix = '';
  var mins = '';
  var p1 = 0, p2 = 0;
  
  if (isUndefined(args[2]))
    args[2] = '';
  if (isUndefined(args[3]))
    args[3] = '';

  var len2 = args[2].length;
  var len3 = args[3].length;
  
  if (len2 >= 1 && args[2] === "all".substr(0, len2))
    allFlg = true;
  else if (isNumericStr(args[2])) {
    tix = parseInt(args[2]);
    if (len3 >= 1 && args[3] === "all".substr(0, len3))
      allFlg = true;
  }
  
  if (len2 === 0 || allFlg || isNumericStr(tix) && len3 === 0) {
    if (isNumericStr(tix)) {
      p1 = tix;
      p2 = p1 + 1;
    }
    else {
      p1 = 0;
      p2 = timerList.length;
    }
    
//  if (args[2] === '' || allFlg) {
    var xmsg = "\n--- Timer List ---\n";
    for (var i = p1; i < p2; i++) {
      var timerObj = timerList[i];
//    Msg.sendMsg(Msg.toO, xmsg);
      xmsg += "Timer[" + i + "] Running=" + (timerObj.running ? "Y" : "N") + " #Mins=" + timerObj.nIntervals + " Left=" + timerObj.intervalCnt + " Name=" + timerObj.name;
      if (allFlg) {
        var imsg = timerObj.intervalMsg;
        if (isUndefined(imsg))
          imsg = '';
        else
          imsg = imsg.replace(/\:/g, '\&c');
        
        var emsg = timerObj.timerExpiredMsg;
        if (isUndefined(emsg))
          emsg = '';
        else
          emsg = emsg.replace(/\:/g, '\&c');

        xmsg += "\n-- imsg='" + imsg + "'\n-- emsg='" + emsg + "'\n";
      }
      xmsg += "\n"; 
    }
    Msg.sendMsg(Msg.toO, xmsg);
  }
  
  else if (tix !== '' && isNumericStr(tix) && !isUndefined(args[3])) {
    var onFlg = false;
    var offFlg = false;
    var imsgFlg = false;
    var emsgFlg = false;
    
    for (var i = 3, ul = args.length; i < ul && errMsg === ''; i++) {
      if (isUndefined(args[i]))
        args[i] = '';
      i1 = i + 1;
      if (isUndefined(args[i1]))
        args[i1] = '';
    
      var len3 = args[i].length;
      
/*********************************
      if (len3 >= 1 && args[i] === 'msgs'.substr(0, len3)) {
        imsg = timerObj.intervalMsg;
        if (isUndefined(imsg))
          imsg = '';
        else
          imsg = imsg.replace(/\:/g, '\&c');
        
        emsg = timerObj.timerExpiredMsg;
        if (isUndefined(emsg))
          emsg = '';
        else
          emsg = emsg.replace(/\:/g, '\&c');

        xmsg += "\n-- imsg='" + imsg + "'\n-- emsg='" + emsg + "'\n";
      }
****************************************/
      if (args[i] === 'on') {
        onFlg = true;
        narg = args[i1];

        if (!isUndefined(narg)) {
          i++;
          if (narg === '*')
            mins = '';
          else if (isNumericStr(narg)) {
            mins = parseInt(narg);
            if (mins < 0 || mins > 60)
              errMsg = errMsg3;
          }
          else
            errMsg = errMsg3;
        }
      }
      else if (args[i] === 'off')
        offFlg = true;
      else if (len3 >= 1 && args[i] === 'imsg'.substr(0, len3)) {
        if (!isUndefined(args[i1]) && (args[i1].substr(0,1) === '"' || args[i1].substr(0,1) === "'"))
          var imsg = args[i1].substr(1,args[i1].length - 2);
        else
          var imsg = args.slice(i1).join(' ');
        imsg = imsg.replace(/\&c/g, '\:');
        imsgFlg = true;
        i = ul;
      }
      else if (len3 >= 1 && args[i] === 'emsg'.substr(0, len3)) {
        if (!isUndefined(args[i1]) && (args[i1].substr(0,1) === '"' || args[i1].substr(0,1) === "'"))
          var emsg = args[i1].substr(1,args[i1].length - 2);
        else
          var emsg = args.slice(i1).join(' ');
        emsg = emsg.replace(/\&c/g, '\:');
        i = ul;
        emsgFlg = true;
      }
      else
        errMsg = helpMsg;
    }
      
    if (errMsg === '') {
      if (tix < 0 || tix >= timerList.length)
        errMsg = errMsg1;
      else if (onFlg && offFlg)
        errMsg = errMsg2;
    } 
     
    var timerObj = timerList[tix];
    if (errMsg === '') {
      if (imsgFlg) {
        timerObj.intervalMsg = imsg;
        Msg.sendMsg(Msg.toBMO, "Timer {0} imsg changed by {1} to '{2}'".format(tix, msgUser, imsg));
      }
      if (emsgFlg) {
        timerObj.timerExpiredMsg = emsg;
        Msg.sendMsg(Msg.toBMO, "Timer {0} emsg changed by {1} to '{2}'".format(tix, msgUser, emsg));
      }
      if (onFlg) {
        timerObj.start(mins);
        if (mins === '')
          mins = '*';
        Msg.sendMsg(Msg.toBMO, "Timer {0} set to ON by {1} for {2} minutes".format(tix, msgUser, mins));
      }
      if (offFlg) {
        timerObj.stop();
        Msg.sendMsg(Msg.toBMO, "Timer {0} set to OFF by {1}".format(tix, msgUser));
      }
    }
  }
  else
    errMsg = helpMsg;
  
  if (errMsg !== '')
     Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_tipopts = function(args) {
//------------------------------------------------------------------------------
  // /TIPOpts [ON|OFF]
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /TIPOpts [ON|OFF\n-- ON sets tip options mode, OFF sets normal tip msg mode.";
  var errMsg = '';
  var tipSetOpts = settings.tipSetOpts;
  
  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  if (isUndefined(args[2]))
    {}
  else if (args[2] === "on")
    settings.tipSetOpts = true;
  else if (args[2] === "off")
    settings.tipSetOpts = false;
  else
    errMsg = helpMsg;

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);
  else
    Msg.sendMsg(Msg.toBMO, "Tip options setting is " + (settings.tipSetOpts ? "ON" : "OFF"));

  if (tipSetOpts !== settings.tipSetOpts)
    updPanel();
  
  return true;
};
  
//------------------------------------------------------------------------------
cmdObj.cmdFunc_tshow = function(args) {
//------------------------------------------------------------------------------
  // /tshow [ON|OFF|STatus|Add users|Admit users|Invite users|Unadmit users|Remove users|Uninvate users]
  var tokType  = tokTypeTicketTok;
  var showType = showTypeDesc[tokType];

  var helpMsg = "USAGE: /Tshow [ON|OFF|STatus|Add users|Invite users|Admit users]|Unadmit users|Remove users|Uninvite users|Msg hidemsg\n-- 1 enters " + showType + " for next queued user, OFF exits " + showType + ", ON enters " + showType + " for all queued users, blank or STatus displays " + showType + " status and waiting users, Add adds users (separated by blanks or commas) to " + showType + ". " + showType + " will not start if any hidden show is already running, Msg sets new " + showType + " hidden cam msg.";
  
  var parms = {};
  
  parms.tokType = tokType;
  parms.showType = showType;
  parms.startShow = function(parms, userlist) {return hiddenShow.startTicketShow(userlist); };
  parms.stopShow  = function() {return hiddenShow.stopTicketShow(); };
  parms.isShowRunning = function() {return hiddenShow.getIsTicketShowRunning(); };
  parms.inviteFunc = buildInviteList_Ticket;
  parms.samt = hiddenShow.getTicketPrice();
  parms.helpMsg = helpMsg;
  parms.setMsg = function(msg) { return hiddenShow.setTicketMessage(msg); };
  parms.setPrice = function(p1, p2) { hiddenShow.setTicketPrice(p1, p2); };  
  parms.getPrice = function() { return hiddenShow.getTicketPrice(); };  
  
  return commonShow(args, parms);
};

//------------------------------------------------------------------------------
function commonShow(args, parms) {
//------------------------------------------------------------------------------
  // /xshow [ON|OFF|All|Status|Price [p1[,p2]]|Add users|Admit users|Invite users|Unadmit users|Remove users|Uninvate users]|Msg msg
  // /xshow ON
  // /xshow OFF
  // /xshow All
  // /xshow [St]
  // /xshow a users
  // /xshow u users
  // /xshow P [price]
  // /xshow P price1 price2
  // /xshow Msg msg

  var tokType   = parms.tokType;
  var startShow = parms.startShow;
  var stopShow  = parms.stopShow;
  var isShowRunning = parms.isShowRunning;
  var inviteFunc = parms.inviteFunc;
  var samt = parms.samt;
  var showType = parms.showType;
  var helpMsg  = parms.helpMsg;
  var setMsg = parms.setMsg;
  var setPrice = parms.setPrice;
  var getPrice = parms.getPrice;
  
  var userlist0 = [];
  var userlist  = [];
  var users     = '';
  
  var errMsg  = '';
  var xmsg = '';
  
  if (isUndefined(args[2])) args[2] = '';
  
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var len2 = isUndefined(args[2]) ? 0 : args[2].length;
  if (len2 === 0 ||
      len2 >= 1 && args[2] === "status".substr(0, len2)) {
    Msg.sendMsg(Msg.toO, inviteFunc(0));
  }
  
  else if (len2 >= 1 &&
           (args[2] === "admit".substr(0, len2) ||
            args[2] === "add".substr(0, len2) ||
            args[2] === "invite".substr(0, len2))) {

    if (tokType === tokTypeBhsTok && ! hiddenShow.getEnabled() ||
        samt <= 0) {
      Msg.sendMsg(Msg.toO, showType + " is not enabled");
      return true;
    }
    
    userlist = str2Array(args.slice(3).join(' '));
    users    = userlist.join(', ');
    
    if (tokType === tokTypeBhsTok ||
        tokType === tokTypeTicketTok && hiddenShow.getIsTicketShowRunning()) {
      if (users !== '') {
        if (tokType === tokTypeBhsTok)
          hiddenShow.addHiddenUsers(users);
        else
          hiddenShow.addTicketUsers(users);
//        Msg.sendMsg(Msg.toBMO, "Users added to {0} by {1}: {2}".format(showType, msgUser, users));
      }
      else
        Msg.sendMsg(Msg.toO, "No users added to {1}".format(showType));
    }

    else {
      for (var i = 0, ul = userlist.length; i < ul; i++) {
        var user = userlist[i];
        var userObj = getUserObj(user, true);
        var amt  = UserObj.prototype.getTokTypeVal(user, tokType);
        
        if (amt >= samt)
          Msg.sendMsg(Msg.toO, "User " + user + " already invited to " + showType);
        else {
          UserObj.prototype.setTokTypeVal(user, tokType, samt);
          Msg.sendMsg(Msg.toBMO, "User {0} invited by {1} to {2}".format(user, msgUser, showType));
          userlist0.push(user);
        }
      }
      if (userlist0.length === 0)
        Msg.sendMsg(Msg.toO, "No new users invited to " + showType);
    }
  }  
  else if (len2 >= 1 &&
           (args[2] === "unadmit".substr(0, len2) ||
            args[2] === "remove".substr(0, len2) ||
            args[2] === "uninvite".substr(0, len2))) {

    if (tokType === tokTypeBhsTok && ! hiddenShow.getEnabled() ||
        samt <= 0) {
      Msg.sendMsg(Msg.toO, showType + " is not enabled");
      return true;
    }
    
    userlist = str2Array(args.slice(3).join(' '));
    users    = userlist.join(', ');
    
    if (tokType === tokTypeBhsTok) {
      if (args[3] === '*') {
        userlist = hiddenShow.getHiddenUsers();
        if (userlist.length === 0)
          Msg.sendMsg(Msg.toO, "No users to remove from {0}".format(showType));
        else {
          hiddenShow.removeHiddenUsers('*');
          users = userlist.join(', ');
//          Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
        }
      }
      else if (userlist.length > 0) {
        hiddenShow.removeHiddenUsers(users);
//        Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
      }
      else
        Msg.sendMsg(Msg.toO, "No users were removed from " + showType);
    }
    else if (tokType === tokTypeTicketTok && hiddenShow.getIsTicketShowRunning()) {
      if (args[3] === '*') {
        userlist = hiddenShow.getticketUsers();
        if (userlist.length === 0)
          Msg.sendMsg(Msg.toO, "No users to remove from {0}".format(showType));
        else {
          hiddenShow.removeTicketUsers('*');
          users = userlist.join(', ');
//          Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
        }
      }
      else if (userlist.length > 0) {
        hiddenShow.removeHiddenUsers(users);
//        Msg.sendMsg(Msg.toBMO, "Users removed from {0} by {1}: {2}".format(showType, msgUser, users));
      }
      else
        Msg.sendMsg(Msg.toO, "No users were removed from " + showType);
    }
    else {    // Flash show, or ticket show and not running
      if (args[3] === '*')
        userlist = getLbUserList(0, samt, tokType);
      
      for (var i = 0, ul = userlist.length; i < ul; i++) {
        var user = userlist[i];
//        var userObj = getUserObj(user, true);
        var amt  = UserObj.prototype.getTokTypeVal(user, tokType);

        if (amt < samt)
          Msg.sendMsg(Msg.toO, "User was not queued to " + showType + ": " + user);
        else {
          Msg.sendMsg(Msg.toBMO, "User {0} dequeued from {1} by {2}".format(user, showType, msgUser));
          userlist0.push(user);
        }
        UserObj.prototype.setTokTypeVal(user, tokType, 0);
      }
      if (userlist0.length === 0)
        Msg.sendMsg(Msg.toO, "No users were dequeued from " + showType);
    }
  }  

  else if (args[2] === "on" ||
           tokType === tokTypeFlashTok && len2 > 0 && args[2] === 'all'.substr(0, len2)) {

    if (tokType === tokTypeBhsTok && ! hiddenShow.getEnabled() ||
        samt <= 0) {
      Msg.sendMsg(Msg.toO, showType + " is not enabled");
      return true;
    }
    
    if (hiddenShow.getIsAnyRunning())
      Msg.sendMsg(Msg.toO, "Cannot start " + showType + " - a show is already running");
    else if (isShowRunning())
      Msg.sendMsg(Msg.toO, "Cannot start " + showType + " - already running");
    else if (tokType === tokTypeBhsTok) {
      Msg.sendMsg(Msg.toAll, showType + " started for following users: " + hiddenShow.getHiddenUsers().join(', '));
      startShow(parms);
    }
    else {
      var cnt = (args[2].substr(0, 1) === "a" ? 0 : 1);
      userlist = getLbUserList(cnt, samt, tokType);
      
      if (userlist.length > 0) {
        for (var i = 0, ul = userlist.length; i < ul; i++) {
          var user = userlist[i];
          var amt  = Math.max(0,(UserObj.prototype.getTokTypeVal(user, tokType) - samt));
          UserObj.prototype.setTokTypeVal(user, tokType, amt);
//          Msg.sendMsg(Msg.toAll, "Starting " + showType + " for " + user);
          Msg.sendMsg(Msg.toU, showType + " started just for you, " + user, user);
        }
        users = userlist.join(', ');
        Msg.sendMsg(Msg.toAll, showType + " started for following users: " + users);
        startShow(parms, users);
      }
      else
        Msg.sendMsg(Msg.toO, "No users waiting for " + showType);
    }
  }

  else if (len2 > 0 && args[2] === 'price'.substr(0, len2)) {
    var p1 = 0, p2 = '*';
    if (isUndefined(args[3]))
      Msg.sendMsg(Msg.toO, showType + ' price = ' + getPrice());
    else {
      if (isNumericStr(args[3])) {
        p1 = parseInt(args[3]);
        if (errMsg === '' && isNumericStr(args[4]))
          p2 = parseInt(args[4]);
      }
      else
        errMsg = helpMsg;

      if (errMsg === '') {
        setPrice(p1, p2);
        Msg.sendMsg(Msg.toO, 'User {0} set {1} price = {2}'.format(msgUser, showType, getPrice()));
/***************************************
        var timerObj = getTimerObj('HiddenMsg');        
        if (p1 > 0) {
          if (samt <= 0)
            Msg.sendMsg(Msg.toO, showType + " is now enabled");
          if (tokType === tokTypeBhsTok) {
            hiddenShow.setEnabled(true);
            if (timerObj !== null)
              timerObj.start();
          }
        }
        else if (p1 === 0) {
          if (samt > 0)
            Msg.sendMsg(Msg.toO, showType + " is now disabled");
          if (tokType === tokTypeBhsTok) {
            hiddenShow.setEnabled(false);
            if (timerObj !== null)
              timerObj.stop();
          }
        }
*****************************************/
      }
    }
  }

  else if (args[2] === "off") {
    if (!isShowRunning())
      Msg.sendMsg(Msg.toO, "Cannot stop " + showType + " - not currently running");
    else
      stopShow();
  }
  
  else if (len2 >= 1 &&
           args[2] === "msg".substr(0, len2)) {
         
    if (!isUndefined(args[3]) && (args[3].substr(0,1) === '"' || args[3].substr(0,1) === "'"))
      var hideMsg = args[3].substr(1,args[3].length - 2);
    else
      var hideMsg = args.slice(3).join(' ');

    if (isUndefined(hideMsg))
      Msg.sendMsg(Msg.toO, helpMsg);
    else {
      Msg.sendMsg(Msg.toBMO, "{0} has set the {1} message to '{2}'".format(msgUser, showType, hideMsg));
      setMsg(hideMsg);
    }
  }
  else
    errMsg = helpMsg;
  
  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_unadmit = function(args) {
//------------------------------------------------------------------------------
  // /unadmit ALL|user|userlist
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /UNadmit ALL|user|userlist\n-- removes either all users, specified user, or list of users separated by blank or comma from current or next hidden show";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  users = args.slice(2).join(', ');
  if (!isUndefined(users)) {
    hiddenShow.removeHiddenUsers(users);
    Msg.sendMsg(Msg.toBMO, "Users removed from hidden show by {1}: {0}".format(users, msgUser));
  }
  else
    Msg.sendMsg(Msg.toO, helpMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_xdebug = function(args) {
//------------------------------------------------------------------------------
  // /xdebug ON|OFF
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /XDebug ON|OFF\n-- sets debug ON or OFF mode.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  if (args[2] === 'on' || args[2] === 'off') {
    if (args[2] === 'on')
      appVars.Debug = true;
    else
      appVars.Debug = true;

    Msg.sendMsg(Msg.toO, "Debugging (verbose) mode is now " + appVars.Debug);
  }
  else
    Msg.sendMsg(Msg.toO, helpMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_xtip = function(args) {
//------------------------------------------------------------------------------
  // /xtip tokens user 'tipmsg'|"tipmsg"|tipmsg
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "Usage: /XTIP tokens user 'tipmsg'|\"tipmsg\"\n-- simulates tipping for #tokens with tip msg by user.";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  var errMsg  = '';
  var user    = '';

  if (isUndefined(args[2]) || isUndefined(args[3]))
    errMsg = helpMsg;
  else if (isNumericStr(args[2]))
    tipAmt = parseInt(args[2]);
  else
    errMsg = helpMsg;
  
  if (errMsg === '') {
    if (!isUndefined(args[3]))
      user = args[3];
    else
      errMsg = helpMsg;
  }
    
  if (errMsg === '') {
    if (isUndefined(args[4]))
      tipMsg = '';
    else if (args[4].substr(0,1) === '"' || args[4].substr(0,1) === "'")
      tipMsg = args[4].substr(1,args[4].length - 2);
    else
      tipMsg = args.slice(4).join(' ');
  }

  if (errMsg === '') {
    Msg.sendMsg(Msg.toBMO, user + " tipped " + tipAmt + ": " + tipMsg, Colors.darkMagenta);
    recordTip(user, tipAmt, false);
  }

  if (errMsg !== '')
    Msg.sendMsg(Msg.toO, errMsg);

  return true;
};

//------------------------------------------------------------------------------
cmdObj.cmdFunc_version = function(args) {
//------------------------------------------------------------------------------
  // /version
  debugLog("<" + args[0] + "> cmd received from " + msgUser);
  var helpMsg = "USAGE: /VErsion\n-- displays the current app version info";

  if (displayHelpMsg(helpMsg,args[2]))
    return true;

  Msg.sendMsg(Msg.toO, "Running {0} v{1}".format(appVars.Name, appVars.Version));

  return true;
};

//---------------------------------------------------------------------------
function isBroadcaster(user) {
//---------------------------------------------------------------------------
  return (user === cb.room_slug);
}

//---------------------------------------------------------------------------
function isModerator(user) {
//---------------------------------------------------------------------------
  return (user === modUser && settings.allow_mod_superuser_cmd);
}

//---------------------------------------------------------------------------
function isBroadMod(user) {
//---------------------------------------------------------------------------
  return (isBroadcaster(user) || isModerator(user));
}

//---------------------------------------------------------------------------
function isAuthor(user) {
//---------------------------------------------------------------------------
  return (user === appVars.Author); // && settings.support_mode);
}

//---------------------------------------------------------------------------
function isSuperuser(user) {
//---------------------------------------------------------------------------
  return (isBroadcaster(user) || isAuthor(user) /* || isModerator(user) */ );
}

//---------------------------------------------------------------------------
function isNumericStr(str) {
//---------------------------------------------------------------------------
  var xstr = String(str);
  if (isUndefined(str))
    return false;
  else
    return xstr.match(/^ *\d+ *$/);
}

//---------------------------------------------------------------------------
function isUndefined(test) {
//---------------------------------------------------------------------------
  return (typeof test === 'undefined' || test === '' || test === null);
}

//---------------------------------------------------------------------------
function isUndefined0(test) {
//---------------------------------------------------------------------------
  return (isUndefined(test) || test === 0);
}

//---------------------------------------------------------------------------
function getCbSettingsChoices(name, propRet) {
//---------------------------------------------------------------------------
  for (var i = 0, ul = cb.settings_choices.length; i < ul; i++)
    if (cb.settings_choices[i].name === name)
      return cb.settings_choices[i][propRet];
  return '';
}

//---------------------------------------------------------------------------
function userException(name, message) {
//---------------------------------------------------------------------------
   this.name = name;
   this.message = message;
}

//---------------------------------------------------------------------------
function parseOptions() {
//---------------------------------------------------------------------------
  settings.final_goal_msg = cb.settings.final_goal_msg;
//  settings.show_timer_in_subject = (cb.settings.show_timer_in_subject === 'Yes');
  settings.show_timer_in_subject = true;
//  settings.allow_mod_superuser_cmd = (cb.settings.mod_allow_broadcaster_cmd === 'Yes');
  settings.allow_mod_superuser_cmd = true;
//  settings.hide_token_haul = (cb.settings.hide_token_haul === 'Yes');
  settings.hide_token_haul = false;
//  settings.highlight_theme = cb.settings.tipper_color_scheme.toLowerCase();
  settings.highlight_theme = 'l';
//  settings.progression_mode_manual = (cb.settings.progression_mode === 'Manual');
  settings.progression_mode_manual = true;
  settings.before_hidden_show_entry_fee = cb.settings.before_hidden_show_entry_fee;
  settings.during_hidden_show_entry_fee = cb.settings.during_hidden_show_entry_fee;
//  var actionOnFinalGoal = (cb.settings.final_action[0]).toLowerCase();
  var actionOnFinalGoal = 's';
//  settings.imsg = cb.settings.before_hidden_show_timer_msg;
//  settings.emsg = cb.settings.before_hidden_show_timer_emsg;
  settings.imsg = '%time% minutes left before hidden show starts.\\nHidden show entrance tokens: %bhs% before show start, %dhs% after show starts.\\nCurrent hidden show invitees: %husers%';
  settings.emsg = 'Hidden show starting now!\\nHidden show starting now!\\nHidden show starting now';


//  settings.timerMins = cb.settings.before_hidden_show_timer_mins;
  settings.timerMins = 5;
//  settings.flash_hidden_msg = cb.settings.flash_hidden_msg;
  settings.flash_hidden_msg = '';
//  settings.flash_tokens_amt = cb.settings.flash_tokens_amt;
  settings.flash_tokens_amt = 0;
//  settings.flash_hidden_show_mins = cb.settings.flash_hidden_show_mins;
  settings.flash_hidden_show_mins = 1;
//  settings.flash_hidden_show_mode = cb.settings.flash_hidden_show_mode;
  settings.flash_hidden_show_mode = 'a';
//  settings.flash_tips_count_for_hidden = cb.settings.flash_tips_count_for_hidden.substr(0, 1).toLowerCase() === 'y';
  settings.flash_tips_count_for_hidden = false;
//  settings.ticket_hidden_msg = cb.settings.ticket_hidden_msg;
  settings.ticket_hidden_msg = '';
//  settings.ticket_tokens_amt = cb.settings.ticket_tokens_amt;
  settings.ticket_tokens_amt = 0;
//  settings.keep_no_goal = cb.settings.keep_no_goal === 'Yes';
  settings.keep_no_goal = false;
//  settings.timerInfo.push([getCbSettingsChoices('timer1_msg', 'label').split(' ', 1)[0] + 'Msg', cb.settings.timer1_msg_mins, cb.settings.timer1_msg]);
//  settings.timerInfo.push([getCbSettingsChoices('timer2_msg', 'label').split(' ', 1)[0] + 'Msg', cb.settings.timer2_msg_mins, cb.settings.timer2_msg]);

  settings.timerInfo.push(['HiddenMsg', 7, 'From %bcstr%: *** All of your goal tips contribute towards my hidden show entrance fee of %bhs%t before hidden show starts. Entrance fee is %dhs%t after hidden show starts. :smile']);
  settings.timerInfo.push(['GeneralMsg', 6, 'I hope I can bring you a smile, warmth, and excitement in this room! 5t if you like me. 10t if you love me and want a kiss! :kisses4u']);
//  settings.timerInfo.push([cb.settings.timer5_msg_mins, cb.settings.timer3_msg]);
//  settings.timerInfo.push([cb.settings.timer6_msg_mins, cb.settings.timer3_msg]);
  settings.timerInfo.push(['', 0, '']);
  settings.timerInfo.push(['', 0, '']);
//  settings.timerInfo.push(['', 0, '']);
  
  switch (actionOnFinalGoal) {
    case 'l':
      settings.final_action = 'loop';
      break;
    case 's':
      settings.final_action = 'hidden';
      break;
    default:
      settings.final_action = 'display';
      break;
  }

  hiddenShow.setEnabled(true);
//  hiddenShow.setEnabled(settings.final_action === 'hidden');
  hiddenShow.setHiddenMessage(settings.final_goal_msg);
  hiddenShow.setFlashMessage(settings.flash_hidden_msg);
  hiddenShow.setTicketMessage(settings.ticket_hidden_msg);
  hiddenShow.imsg = settings.imsg;
  hiddenShow.emsg = settings.emsg;
  hiddenShow.timerMins = settings.timerMins;
  
  for (var gix = 1; gix <= appVars.Constants.Goals; gix++) {
    if (!isUndefined(cb.settings['goal_' + gix + '_desc']) && !isUndefined0(cb.settings['goal_' + gix + '_tokens'])) {
      var tokens = parseInt(cb.settings['goal_' + gix + '_tokens']);
      var desc = cb.settings['goal_' + gix + '_desc'];
      var repCnt = -1;
      var subgoal = cb.settings['goal_' + gix + '_multigoals'];
      
      if (!isUndefined(subgoal) && isNumericStr(subgoal))
        repCnt = parseInt(subgoal);
      debugLog("The goal {0} will be repeated {1} times!".format(repCnt === -1 ? 1 : repCnt === 0 ? 'unlimited' : repCnt, desc));
      addGoal(goalNew9(), repCnt, tokens, desc, goalTypeNormal);
    }
  }
}

//---------------------------------------------------------------------------
function init() {
//---------------------------------------------------------------------------
  appVars.StartupTime = new Date();

  if (settings.final_action === 'hidden')
    var gType = goalTypeHidden;
  else
    gType = goalTypeFinal;
  
  addGoal(goalNew9(), 1, 0, "No Goal", goalTypeDummy);      // No goal (always first)
  parseOptions();
  addGoal(goalNew9(), 1, 0, hiddenShow.getHiddenMessage(), gType);     // Hidden/final goal (always last)
  
  stats.curGoalNo = 0;

  Msg.sendMsg(Msg.toAll, appVars.Name + " v" + appVars.Version + " started.");
  Msg.sendMsg(Msg.toBMO, "Type '/stats' for token stats at any time, or '/help' for more commands.");
  setTimerObjDefaults();
  initTimerObj = createTimerObj("InitTimer");
  lbTimerObj   = createTimerObj("LbTimer", processLbTimer);
  goalTimerObj = createTimerObj("GoalTimer", null, "*** Time's running out!  Only %time% minutes left to tip to the goal! ***", ":timesup *** Goal timer has ended ***");
  goalTimerObj.delOnStop  = true;   // Delete timerObj on stop()        
  goalTimerObj.msgsOnStop = true;   // Display messages on stop()       
  
  hiddenTimerObj = createTimerObj("HShowTimer", hiddenShow.timerProcess, hiddenShow.imsg, hiddenShow.emsg);
  initTimerObj.start();
  lbTimerObj.start(settings.lbMins)

  for (var i = 0, ul = settings.timerInfo.length; i < ul; i++) {
    var timerName = settings.timerInfo[i][0];
    var timerMins = settings.timerInfo[i][1];
    var timerMsg  = settings.timerInfo[i][2];
    if (timerName === '')
      timerName = 'IntTimer' + i;
    var timerObj = createTimerObj(timerName, processIntTimers , null, timerMsg);
    timerObj.start(timerMins);
    if (timerMins <= 0 ||
        timerName === 'HiddenMsg' && hiddenShow.getBhsPrice() === 0)
      timerObj.stop();
  }

  hiddenShow.setHiddenPrice(settings.before_hidden_show_entry_fee, settings.during_hidden_show_entry_fee);
  hiddenShow.setFlashPrice(settings.flash_tokens_amt);
  hiddenShow.setTicketPrice(settings.ticket_tokens_amt);

  nextGoal(goalFirst0);
//  updPanel();
}

//==============================================================================
// 
// Main
//
//==============================================================================
/***/

if (! isUndefined(cb.settings.goal_1_tokens)) {
    init();
}
/**/