Chaturbate

Apps Home | Create an App
Funkycowboy Tip Menu
Author: funkycowboy345
You are viewing version 2227541. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch App Current Users
There is 1 other version of this script.
/*
Smart Hype Menu Bot (Chaturbate)
Version: 1.0.0

What it does:
- Tip Menu triggers
- Auto Goal tracking with rollover
- Hype Train challenge (time-window token push)
- Leaderboard + periodic status notices
- Chat commands: /menu /goal /leaders /hype /helpbot

Paste this script into Chaturbate "Create App".
*/

cb.settings_choices = [
  { name: 'goal_title', type: 'str', minLength: 1, maxLength: 80, defaultValue: 'Main Goal' },
  { name: 'goal_start_tokens', type: 'int', minValue: 1, maxValue: 50000, defaultValue: 500 },
  { name: 'goal_increment_percent', type: 'int', minValue: 0, maxValue: 200, defaultValue: 0 },
  { name: 'subject_mode', type: 'choice', choice1: 'yes', choice2: 'no', defaultValue: 'yes' },
  { name: 'room_tagline', type: 'str', minLength: 0, maxLength: 60, defaultValue: 'Type /menu for tip actions' },

  { name: 'menu_match_mode', type: 'choice', choice1: 'exact', choice2: 'greater_or_equal', defaultValue: 'exact' },
  { name: 'menu_item_1', type: 'str', minLength: 0, maxLength: 80, defaultValue: '25 - Blow Kiss' },
  { name: 'menu_item_2', type: 'str', minLength: 0, maxLength: 80, defaultValue: '50 - Spin Wheel' },
  { name: 'menu_item_3', type: 'str', minLength: 0, maxLength: 80, defaultValue: '100 - Song Request' },
  { name: 'menu_item_4', type: 'str', minLength: 0, maxLength: 80, defaultValue: '200 - Special Request' },
  { name: 'menu_item_5', type: 'str', minLength: 0, maxLength: 80, defaultValue: '' },
  { name: 'menu_item_6', type: 'str', minLength: 0, maxLength: 80, defaultValue: '' },

  { name: 'thank_you_template', type: 'str', minLength: 0, maxLength: 140, defaultValue: 'Thank you {user} for {amount} tokens. {remaining} tokens left for goal.' },
  { name: 'welcome_notice', type: 'str', minLength: 0, maxLength: 120, defaultValue: 'Welcome {user}. Type /menu to see tip actions.' },
  { name: 'show_commands_on_enter', type: 'choice', choice1: 'yes', choice2: 'no', defaultValue: 'no' },

  { name: 'leaderboard_size', type: 'int', minValue: 1, maxValue: 10, defaultValue: 3 },
  { name: 'leaderboard_every_tokens', type: 'int', minValue: 0, maxValue: 2000, defaultValue: 300 },
  { name: 'notice_interval_min', type: 'int', minValue: 1, maxValue: 60, defaultValue: 8 },

  { name: 'enable_hype', type: 'choice', choice1: 'yes', choice2: 'no', defaultValue: 'yes' },
  { name: 'hype_window_sec', type: 'int', minValue: 20, maxValue: 600, defaultValue: 120 },
  { name: 'hype_target_tokens', type: 'int', minValue: 25, maxValue: 5000, defaultValue: 300 },
  { name: 'hype_min_tip_to_start', type: 'int', minValue: 1, maxValue: 500, defaultValue: 25 },
  { name: 'hype_target_growth_percent', type: 'int', minValue: 0, maxValue: 100, defaultValue: 15 },

  { name: 'command_cooldown_sec', type: 'int', minValue: 0, maxValue: 60, defaultValue: 15 }
];

var state = {
  startedAt: nowSec(),
  goalTitle: '',
  goalTarget: 0,
  goalProgress: 0,
  goalRound: 1,

  totalTokens: 0,
  tippers: {},
  nextLeaderboardMilestone: 0,

  menu: [],

  hypeEnabled: true,
  hypeActive: false,
  hypeTarget: 0,
  hypeWindowSec: 0,
  hypeEndsAt: 0,
  hypeTokens: 0,
  hypeWins: 0,

  autoNoticeIndex: 0,
  cmdCooldown: {}
};

bootstrap();

function bootstrap() {
  state.goalTitle = trim(cb.settings.goal_title || 'Main Goal');
  state.goalTarget = safeInt(cb.settings.goal_start_tokens, 500);
  state.nextLeaderboardMilestone = safeInt(cb.settings.leaderboard_every_tokens, 300);

  state.hypeEnabled = (cb.settings.enable_hype === 'yes');
  state.hypeWindowSec = safeInt(cb.settings.hype_window_sec, 120);
  state.hypeTarget = safeInt(cb.settings.hype_target_tokens, 300);

  rebuildMenu();

  cb.onEnter(onEnter);
  cb.onTip(onTip);
  cb.onMessage(onMessage);

  scheduleAutoNotice();
  scheduleHypeWatcher();

  noticeAll('[Smart Hype Menu Bot] Live. Commands: /menu /goal /leaders /hype /helpbot');
  updateSubject();
}

function onEnter(user) {
  var uname = safeUser(user && user.user);
  var welcome = trim(cb.settings.welcome_notice || '');
  if (welcome) {
    noticeUser(uname, replaceTokens(welcome, uname, 0));
  }

  if (cb.settings.show_commands_on_enter === 'yes') {
    noticeUser(uname, 'Commands: /menu /goal /leaders /hype /helpbot');
  }
}

function onTip(tip) {
  var amount = safeInt(tip && tip.amount, 0);
  var user = safeUser(tip && tip.from_user);

  if (amount <= 0) {
    return;
  }

  state.totalTokens += amount;
  state.goalProgress += amount;
  addTipper(user, amount);

  maybeTriggerMenu(user, amount);
  maybeAdvanceGoal();
  maybeProcessHype(user, amount);

  var template = trim(cb.settings.thank_you_template || '');
  if (template) {
    noticeAll(replaceTokens(template, user, amount));
  }

  maybePostLeaderboardMilestone();
  updateSubject();
}

function onMessage(msg) {
  var text = trim((msg && msg.m) || '');
  var user = safeUser(msg && msg.user);

  if (!text) {
    return msg;
  }

  var lower = text.toLowerCase();
  if (lower === '/menu' || lower === '!menu') {
    if (!canRunCommand(user, 'menu')) { return msg; }
    showMenu(user);
  } else if (lower === '/goal' || lower === '!goal') {
    if (!canRunCommand(user, 'goal')) { return msg; }
    showGoal(user);
  } else if (lower === '/leaders' || lower === '!leaders') {
    if (!canRunCommand(user, 'leaders')) { return msg; }
    showLeaders(user);
  } else if (lower === '/hype' || lower === '!hype') {
    if (!canRunCommand(user, 'hype')) { return msg; }
    showHype(user);
  } else if (lower === '/helpbot' || lower === '!helpbot') {
    if (!canRunCommand(user, 'helpbot')) { return msg; }
    noticeUser(user, 'Commands: /menu /goal /leaders /hype');
  } else if (startsWith(lower, '/resetgoal') || startsWith(lower, '!resetgoal')) {
    if (!isController(msg)) { return msg; }
    resetGoal();
  } else if (startsWith(lower, '/setgoal ') || startsWith(lower, '!setgoal ')) {
    if (!isController(msg)) { return msg; }
    setGoalFromCommand(text);
  } else if (lower === '/botstatus' || lower === '!botstatus') {
    if (!isController(msg)) { return msg; }
    postStatus();
  }

  return msg;
}

function rebuildMenu() {
  var raw = [
    cb.settings.menu_item_1,
    cb.settings.menu_item_2,
    cb.settings.menu_item_3,
    cb.settings.menu_item_4,
    cb.settings.menu_item_5,
    cb.settings.menu_item_6
  ];

  var parsed = [];
  var i;
  for (i = 0; i < raw.length; i++) {
    var line = trim(raw[i] || '');
    if (!line) {
      continue;
    }
    var item = parseMenuItem(line);
    if (item) {
      parsed.push(item);
    }
  }

  state.menu = parsed;
}

function parseMenuItem(line) {
  var parts = line.split('-');
  if (parts.length < 2) {
    return null;
  }

  var tokenPart = trim(parts.shift());
  var labelPart = trim(parts.join('-'));
  var tokens = safeInt(tokenPart, 0);

  if (tokens <= 0 || !labelPart) {
    return null;
  }

  return {
    tokens: tokens,
    label: labelPart
  };
}

function maybeTriggerMenu(user, amount) {
  var mode = cb.settings.menu_match_mode || 'exact';
  var i;
  for (i = 0; i < state.menu.length; i++) {
    var item = state.menu[i];
    var match = false;

    if (mode === 'greater_or_equal') {
      match = (amount >= item.tokens);
    } else {
      match = (amount === item.tokens);
    }

    if (match) {
      noticeAll('Tip Menu: ' + user + ' unlocked "' + item.label + '" (' + item.tokens + ' tokens)');
      if (mode !== 'greater_or_equal') {
        return;
      }
    }
  }
}

function maybeAdvanceGoal() {
  var incrementPct = safeInt(cb.settings.goal_increment_percent, 0);

  while (state.goalProgress >= state.goalTarget) {
    state.goalProgress -= state.goalTarget;
    noticeAll('Goal complete: "' + state.goalTitle + '" reached. Starting next round.');

    state.goalRound += 1;
    if (incrementPct > 0) {
      var increased = Math.floor(state.goalTarget * (1 + (incrementPct / 100)));
      state.goalTarget = Math.max(1, increased);
    }
  }
}

function maybePostLeaderboardMilestone() {
  var stride = safeInt(cb.settings.leaderboard_every_tokens, 300);
  if (stride <= 0) {
    return;
  }

  while (state.totalTokens >= state.nextLeaderboardMilestone) {
    postLeadersToRoom();
    state.nextLeaderboardMilestone += stride;
  }
}

function maybeProcessHype(user, amount) {
  if (!state.hypeEnabled) {
    return;
  }

  var now = nowSec();
  var minTip = safeInt(cb.settings.hype_min_tip_to_start, 25);
  if (!state.hypeActive && amount >= minTip) {
    startHype(now);
    noticeAll('HYPE TRAIN STARTED by ' + user + '. Target: ' + state.hypeTarget + ' tokens in ' + state.hypeWindowSec + 's.');
  }

  if (!state.hypeActive) {
    return;
  }

  if (now > state.hypeEndsAt) {
    failHype();
    return;
  }

  state.hypeTokens += amount;
  var remain = Math.max(0, state.hypeTarget - state.hypeTokens);

  if (state.hypeTokens >= state.hypeTarget) {
    state.hypeWins += 1;
    noticeAll('HYPE TRAIN SUCCESS! Level ' + state.hypeWins + ' complete.');

    var growthPct = safeInt(cb.settings.hype_target_growth_percent, 15);
    if (growthPct > 0) {
      state.hypeTarget = Math.max(1, Math.floor(state.hypeTarget * (1 + (growthPct / 100))));
    }

    state.hypeTokens = 0;
    state.hypeEndsAt = now + state.hypeWindowSec;
    noticeAll('Next Hype Target: ' + state.hypeTarget + ' tokens in ' + state.hypeWindowSec + 's.');
  } else if (remain > 0 && (remain % 50 === 0 || remain <= 25)) {
    noticeAll('Hype Train update: ' + remain + ' tokens left.');
  }
}

function startHype(now) {
  state.hypeActive = true;
  state.hypeTokens = 0;
  state.hypeEndsAt = now + state.hypeWindowSec;
}

function failHype() {
  if (!state.hypeActive) {
    return;
  }

  noticeAll('Hype Train ended. We made ' + state.hypeTokens + '/' + state.hypeTarget + ' tokens.');
  state.hypeActive = false;
  state.hypeTokens = 0;
  state.hypeEndsAt = 0;
}

function scheduleHypeWatcher() {
  cb.setTimeout(function () {
    var now = nowSec();
    if (state.hypeActive && now > state.hypeEndsAt) {
      failHype();
      updateSubject();
    }
    scheduleHypeWatcher();
  }, 5000);
}

function scheduleAutoNotice() {
  var min = safeInt(cb.settings.notice_interval_min, 8);
  var ms = Math.max(1, min) * 60 * 1000;

  cb.setTimeout(function () {
    postAutoNotice();
    scheduleAutoNotice();
  }, ms);
}

function postAutoNotice() {
  var messages = [
    'Tip Menu: type /menu',
    goalStatusLine(),
    leadersStatusLine(),
    hypeStatusLine()
  ];

  var idx = state.autoNoticeIndex % messages.length;
  state.autoNoticeIndex += 1;
  noticeAll(messages[idx]);
}

function showMenu(user) {
  if (!state.menu.length) {
    noticeUser(user, 'Menu not configured.');
    return;
  }

  var i;
  noticeUser(user, 'Tip Menu:');
  for (i = 0; i < state.menu.length; i++) {
    noticeUser(user, state.menu[i].tokens + ' - ' + state.menu[i].label);
  }
}

function showGoal(user) {
  noticeUser(user, goalStatusLine());
}

function showLeaders(user) {
  noticeUser(user, leadersStatusLine());
}

function showHype(user) {
  noticeUser(user, hypeStatusLine());
}

function postLeadersToRoom() {
  noticeAll(leadersStatusLine());
}

function postStatus() {
  noticeAll(goalStatusLine());
  noticeAll(leadersStatusLine());
  noticeAll(hypeStatusLine());
}

function goalStatusLine() {
  var remaining = Math.max(0, state.goalTarget - state.goalProgress);
  return 'Goal: ' + state.goalTitle + ' (Round ' + state.goalRound + ') ' + state.goalProgress + '/' + state.goalTarget + ' tokens. Remaining: ' + remaining + '.';
}

function leadersStatusLine() {
  var leaders = topTippers(safeInt(cb.settings.leaderboard_size, 3));
  if (!leaders.length) {
    return 'Top Tippers: no tips yet.';
  }

  var out = [];
  var i;
  for (i = 0; i < leaders.length; i++) {
    out.push((i + 1) + ') ' + leaders[i].user + ' (' + leaders[i].tokens + ')');
  }
  return 'Top Tippers: ' + out.join(' | ');
}

function hypeStatusLine() {
  if (!state.hypeEnabled) {
    return 'Hype Train: disabled.';
  }

  if (!state.hypeActive) {
    return 'Hype Train: idle. Start with a tip of at least ' + safeInt(cb.settings.hype_min_tip_to_start, 25) + ' tokens.';
  }

  var now = nowSec();
  var leftSec = Math.max(0, state.hypeEndsAt - now);
  var remain = Math.max(0, state.hypeTarget - state.hypeTokens);
  return 'Hype Train: ' + state.hypeTokens + '/' + state.hypeTarget + ' tokens. ' + remain + ' left, ' + leftSec + 's left.';
}

function topTippers(limit) {
  var rows = [];
  var user;
  for (user in state.tippers) {
    if (state.tippers.hasOwnProperty(user)) {
      rows.push({ user: user, tokens: state.tippers[user] });
    }
  }

  rows.sort(function (a, b) {
    return b.tokens - a.tokens;
  });

  if (limit <= 0 || rows.length <= limit) {
    return rows;
  }
  return rows.slice(0, limit);
}

function addTipper(user, amount) {
  if (!state.tippers[user]) {
    state.tippers[user] = 0;
  }
  state.tippers[user] += amount;
}

function replaceTokens(template, user, amount) {
  var remaining = Math.max(0, state.goalTarget - state.goalProgress);
  return String(template)
    .split('{user}').join(user)
    .split('{amount}').join(String(amount))
    .split('{remaining}').join(String(remaining));
}

function updateSubject() {
  if (cb.settings.subject_mode !== 'yes') {
    return;
  }

  if (!cb.changeRoomSubject) {
    return;
  }

  var goalPct = Math.floor((state.goalProgress / Math.max(1, state.goalTarget)) * 100);
  var tagline = trim(cb.settings.room_tagline || '');
  var subject = '[' + goalPct + '%] ' + state.goalTitle + ' ' + state.goalProgress + '/' + state.goalTarget + 'tk';

  if (tagline) {
    subject = subject + ' | ' + tagline;
  }

  try {
    cb.changeRoomSubject(subject);
  } catch (e) {
    // ignore subject update failures
  }
}

function resetGoal() {
  state.goalProgress = 0;
  state.goalRound = 1;
  state.goalTarget = safeInt(cb.settings.goal_start_tokens, 500);
  noticeAll('Goal has been reset to ' + state.goalTarget + ' tokens.');
  updateSubject();
}

function setGoalFromCommand(raw) {
  var parts = raw.split(' ');
  if (parts.length < 2) {
    noticeAll('Usage: /setgoal <tokens>');
    return;
  }

  var newTarget = safeInt(parts[1], 0);
  if (newTarget <= 0) {
    noticeAll('Goal must be a positive number.');
    return;
  }

  state.goalTarget = newTarget;
  state.goalProgress = 0;
  state.goalRound = 1;
  noticeAll('Goal updated to ' + newTarget + ' tokens.');
  updateSubject();
}

function canRunCommand(user, commandName) {
  var key = user + '::' + commandName;
  var cooldown = safeInt(cb.settings.command_cooldown_sec, 15);
  if (cooldown <= 0) {
    return true;
  }

  var now = nowSec();
  var last = state.cmdCooldown[key] || 0;
  if ((now - last) < cooldown) {
    return false;
  }

  state.cmdCooldown[key] = now;
  return true;
}

function isController(msg) {
  var user = safeUser(msg && msg.user);
  if (user === cb.room_slug) {
    return true;
  }
  if (msg && msg.is_mod) {
    return true;
  }
  return false;
}

function noticeAll(text) {
  cb.sendNotice(text);
}

function noticeUser(user, text) {
  if (!user) {
    cb.sendNotice(text);
    return;
  }
  cb.sendNotice(text, user);
}

function startsWith(full, prefix) {
  return full.indexOf(prefix) === 0;
}

function safeInt(v, fallback) {
  var n = parseInt(v, 10);
  if (isNaN(n)) {
    return fallback;
  }
  return n;
}

function trim(v) {
  return String(v || '').replace(/^\s+|\s+$/g, '');
}

function safeUser(u) {
  var out = trim(u || '');
  return out || 'anonymous';
}

function nowSec() {
  return Math.floor(new Date().getTime() / 1000);
}