Chaturbate

Bots Home | Create an App
ALPHA SYSTEM v1
Author: juliusmasters
You are viewing version 2226966. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch Bot Current Users
There are 2 other versions of this script.
(function () {
  "use strict";

  // =========================
  // Settings
  // =========================
  cb.settings_choices = [
    {
      name: "menu_input",
      type: "str",
      label: "Tip Menu (format: '5 GREAT MASTER; 15 PM ME; ...')",
      required: false,
      defaultValue: "5 GREAT MASTER; 15 PM ME; 20 SPIT; 25 SHOW FEET;"
    },
    {
      name: "menu_command",
      type: "str",
      label: "Menu command (default /menu). Bot accepts both / and !",
      required: true,
      defaultValue: "/menu"
    },
    {
      name: "help_command",
      type: "str",
      label: "Help command",
      required: true,
      defaultValue: "/help"
    },
    {
      name: "tags_command",
      type: "str",
      label: "Tags command",
      required: true,
      defaultValue: "/tags"
    },
    {
      name: "rank_command",
      type: "str",
      label: "Rank command",
      required: true,
      defaultValue: "/rank"
    },
    {
      name: "goal_title",
      type: "str",
      label: "Goal title",
      required: true,
      defaultValue: "GOAL"
    },
    {
      name: "goal_target",
      type: "int",
      label: "Goal target (tokens)",
      required: true,
      defaultValue: 500,
      minValue: 1
    },
    {
      name: "goal_auto_reset",
      type: "choice",
      label: "Auto reset goal when reached?",
      required: true,
      choices: ["yes", "no"],
      defaultValue: "yes"
    },
    {
      name: "privileged_minutes",
      type: "int",
      label: "Privileged Mode duration (minutes)",
      required: true,
      defaultValue: 10,
      minValue: 1
    },
    {
      name: "privileged_trigger_tip",
      type: "int",
      label: "Privileged Mode trigger tip (0 = off). Example: 777",
      required: true,
      defaultValue: 0,
      minValue: 0
    },
    {
      name: "hashtags",
      type: "str",
      label: "Hashtags (max 5, separated by comma or space)",
      required: false,
      defaultValue: "#alpha #vip #privileged #rank #goal"
    },
    {
      name: "rank_thresholds",
      type: "str",
      label: "Rank thresholds (comma separated tokens, ascending). Example: 100,500,1000,5000,10000",
      required: true,
      defaultValue: "100,500,1000,5000,10000"
    },
    {
      name: "rank_names",
      type: "str",
      label: "Rank names (comma separated, must match thresholds count). Example: Bronze,Silver,Gold,Elite,Supreme",
      required: true,
      defaultValue: "Bronze,Silver,Gold,Elite,Supreme"
    },
    {
      name: "rank_notify_room",
      type: "choice",
      label: "Notify room on rank up?",
      required: true,
      choices: ["yes", "no"],
      defaultValue: "yes"
    },
    {
      name: "rank_notify_private",
      type: "choice",
      label: "Notify user privately on rank up?",
      required: true,
      choices: ["yes", "no"],
      defaultValue: "yes"
    },
    {
      name: "broadcast_interval_min",
      type: "int",
      label: "Auto broadcast interval (minutes). 0 = off",
      required: true,
      defaultValue: 10,
      minValue: 0
    },
    {
      name: "command_cooldown_sec",
      type: "int",
      label: "Cooldown for commands (seconds) to reduce spam",
      required: true,
      defaultValue: 8,
      minValue: 0
    },
    {
      name: "blocked_terms",
      type: "str",
      label: "Blocked terms in menu (comma separated). Items containing these are ignored.",
      required: false,
      defaultValue: "f4g,f@g"
    }
  ];

  // =========================
  // State
  // =========================
  var state = {
    menu: [],
    goalProgress: 0,
    privilegedUntilMs: 0,
    lastGoalMilestone: 0,
    hashtags: [],
    rankThresholds: [],
    rankNames: [],
    userTotals: Object.create(null),
    userRankIndex: Object.create(null),
    lastCmdAtMs: Object.create(null), // per-user cooldown
    lastBroadcastAtMs: 0
  };

  // =========================
  // Utilities (defensive)
  // =========================
  function nowMs() { return Date.now(); }

  function safeInt(x, fallback) {
    var n = parseInt(x, 10);
    return (isFinite(n) ? n : fallback);
  }

  function normalizeCommand(cmd) {
    return (cmd || "").trim().toLowerCase();
  }

  function altCommand(cmd) {
    cmd = normalizeCommand(cmd);
    if (!cmd) return "";
    if (cmd[0] === "/") return "!" + cmd.slice(1);
    if (cmd[0] === "!") return "/" + cmd.slice(1);
    return "/" + cmd;
  }

  function clampHashtags(raw) {
    if (!raw) return [];
    var parts = raw.split(/[, ]+/).map(function (s) { return (s || "").trim(); }).filter(Boolean);
    var out = [];
    var seen = Object.create(null);

    for (var i = 0; i < parts.length && out.length < 5; i++) {
      var tag = parts[i];
      if (tag[0] !== "#") tag = "#" + tag;
      tag = tag.replace(/[^#A-Za-z0-9_]/g, "");
      if (tag.length < 2) continue;
      var key = tag.toLowerCase();
      if (seen[key]) continue;
      seen[key] = true;
      out.push(tag);
    }
    return out;
  }

  function parseBlockedTerms(raw) {
    if (!raw) return [];
    return raw.split(",").map(function (s) { return (s || "").trim().toLowerCase(); }).filter(Boolean);
  }

  function containsBlocked(text, blockedTerms) {
    if (!text) return false;
    var t = text.toLowerCase();
    for (var i = 0; i < blockedTerms.length; i++) {
      var b = blockedTerms[i];
      if (b && t.indexOf(b) !== -1) return true;
    }
    return false;
  }

  function parseMenu(raw, blockedTerms) {
    var items = [];
    if (!raw) return items;

    var chunks = raw.split(";").map(function (s) { return (s || "").trim(); }).filter(Boolean);
    for (var i = 0; i < chunks.length; i++) {
      var line = chunks[i];
      var m = line.match(/^(\d+)\s+(.+)$/);
      if (!m) continue;

      var price = safeInt(m[1], 0);
      var text = (m[2] || "").trim();
      if (price <= 0 || !text) continue;
      if (containsBlocked(text, blockedTerms)) continue;

      items.push({ price: price, text: text });
    }

    // sort ascending
    items.sort(function (a, b) { return a.price - b.price; });
    return items;
  }

  function parseRanks(thresholdsRaw, namesRaw) {
    var thresholds = (thresholdsRaw || "")
      .split(",")
      .map(function (s) { return safeInt((s || "").trim(), NaN); })
      .filter(function (n) { return isFinite(n) && n > 0; });

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

    var names = (namesRaw || "")
      .split(",")
      .map(function (s) { return (s || "").trim(); })
      .filter(Boolean);

    if (names.length !== thresholds.length) {
      names = thresholds.map(function (t, idx) { return "Rank " + (idx + 1) + " (" + t + ")"; });
    }
    return { thresholds: thresholds, names: names };
  }

  function getRankIndex(total) {
    var idx = -1;
    for (var i = 0; i < state.rankThresholds.length; i++) {
      if (total >= state.rankThresholds[i]) idx = i;
      else break;
    }
    return idx;
  }

  function isPrivilegedActive() {
    return nowMs() < state.privilegedUntilMs;
  }

  function sendRoom(msg) {
    try {
      cb.sendNotice(msg);
    } catch (e) {}
  }

  function sendToUser(msg, user) {
    try {
      cb.sendNotice(msg, user);
    } catch (e) {}
  }

  function formatGoalLine() {
    var target = safeInt(cb.settings.goal_target, 1);
    var prog = state.goalProgress;
    if (prog < 0) prog = 0;
    if (prog > target) prog = target;
    var pct = Math.floor((prog / target) * 100);
    return cb.settings.goal_title + ": " + prog + "/" + target + " (" + pct + "%)";
  }

  function maybeGoalMilestones() {
    var target = safeInt(cb.settings.goal_target, 1);
    var pct = Math.floor((state.goalProgress / target) * 100);

    var milestones = [25, 50, 75, 100];
    for (var i = 0; i < milestones.length; i++) {
      var m = milestones[i];
      if (pct >= m && state.lastGoalMilestone < m) {
        state.lastGoalMilestone = m;
        if (m < 100) {
          sendRoom(formatGoalLine());
        } else {
          sendRoom(cb.settings.goal_title + " reached. PRIVILEGED MODE is now OPEN.");
        }
      }
    }
  }

  function openPrivilegedMode(minutes) {
    var mins = Math.max(1, safeInt(minutes, 10));
    var durMs = mins * 60 * 1000;
    state.privilegedUntilMs = nowMs() + durMs;

    cb.setTimeout(function () {
      if (!isPrivilegedActive()) {
        sendRoom("PRIVILEGED MODE closed.");
      }
    }, durMs + 250);
  }

  function resetGoalIfNeeded() {
    if (cb.settings.goal_auto_reset === "yes") {
      state.goalProgress = 0;
      state.lastGoalMilestone = 0;
      sendRoom("Goal reset. " + formatGoalLine());
    }
  }

  // Split long messages safely
  function sendChunked(prefix, parts, joiner, maxLen) {
    joiner = joiner || " | ";
    maxLen = maxLen || 380; // conservative

    var base = prefix ? (prefix + " ") : "";
    var current = base;

    for (var i = 0; i < parts.length; i++) {
      var piece = parts[i];
      if (!piece) continue;

      var candidate = (current === base ? current + piece : current + joiner + piece);

      if (candidate.length > maxLen) {
        // flush current if it has content beyond base
        if (current.length > base.length) {
          sendRoom(current);
        }
        // start new line with base + piece (if still too long, hard cut)
        current = base + piece;
        if (current.length > maxLen) {
          sendRoom(current.slice(0, maxLen));
          current = base;
        }
      } else {
        current = candidate;
      }
    }

    if (current.length > base.length) {
      sendRoom(current);
    }
  }

  function postMenu(shortMode) {
    if (!state.menu.length) {
      sendRoom("Menu is empty. Configure it in bot settings.");
      return;
    }
    var max = shortMode ? Math.min(6, state.menu.length) : state.menu.length;
    var lines = [];
    for (var i = 0; i < max; i++) {
      lines.push(state.menu[i].price + " " + state.menu[i].text);
    }
    sendChunked("MENU:", lines, " | ", 380);
  }

  function postTags() {
    if (!state.hashtags.length) {
      sendRoom("Tags: (none configured)");
      return;
    }
    sendRoom("Tags: " + state.hashtags.join(" "));
  }

  function postTop() {
    var arr = [];
    for (var u in state.userTotals) {
      if (Object.prototype.hasOwnProperty.call(state.userTotals, u)) {
        arr.push({ user: u, total: state.userTotals[u] });
      }
    }
    if (!arr.length) return;

    arr.sort(function (a, b) { return b.total - a.total; });
    var top = arr.slice(0, 3).map(function (x, idx) {
      return (idx + 1) + ") " + x.user + " (" + x.total + ")";
    }).join(" | ");

    sendRoom("Top supporters: " + top);
  }

  function commandAllowed(user) {
    var cd = Math.max(0, safeInt(cb.settings.command_cooldown_sec, 8)) * 1000;
    if (cd === 0) return true;

    var t = nowMs();
    var last = state.lastCmdAtMs[user] || 0;
    if (t - last < cd) return false;
    state.lastCmdAtMs[user] = t;
    return true;
  }

  // =========================
  // Init
  // =========================
  function init() {
    state.hashtags = clampHashtags(cb.settings.hashtags);

    var ranks = parseRanks(cb.settings.rank_thresholds, cb.settings.rank_names);
    state.rankThresholds = ranks.thresholds;
    state.rankNames = ranks.names;

    var blocked = parseBlockedTerms(cb.settings.blocked_terms);
    state.menu = parseMenu(cb.settings.menu_input, blocked);

    sendRoom("ALPHA PRIVILEGE SYSTEM loaded. " + formatGoalLine());
    if (state.hashtags.length) sendRoom("Tags: " + state.hashtags.join(" "));
    if (state.menu.length) postMenu(true);

    var intervalMin = safeInt(cb.settings.broadcast_interval_min, 0);
    if (intervalMin > 0) scheduleBroadcast(intervalMin);
  }

  function scheduleBroadcast(intervalMin) {
    var ms = Math.max(1, intervalMin) * 60 * 1000;
    cb.setTimeout(function () {
      // anti spam: do not broadcast too frequently if timers duplicate
      var t = nowMs();
      if (t - state.lastBroadcastAtMs >= ms - 500) {
        state.lastBroadcastAtMs = t;
        sendRoom(formatGoalLine());
        postTop();
        postMenu(true);
      }
      scheduleBroadcast(intervalMin);
    }, ms);
  }

  // =========================
  // Handlers
  // =========================
  cb.onMessage(function (msg) {
    try {
      var m = (msg.m || "").trim();
      if (!m) return msg;

      var user = msg.user || "";
      if (user && !commandAllowed(user)) return msg;

      var lower = m.toLowerCase();

      var menuCmd = normalizeCommand(cb.settings.menu_command);
      var menuCmdAlt = altCommand(menuCmd);

      var helpCmd = normalizeCommand(cb.settings.help_command);
      var helpCmdAlt = altCommand(helpCmd);

      var tagsCmd = normalizeCommand(cb.settings.tags_command);
      var tagsCmdAlt = altCommand(tagsCmd);

      var rankCmd = normalizeCommand(cb.settings.rank_command);
      var rankCmdAlt = altCommand(rankCmd);

      // MENU
      if (lower === menuCmd || lower === menuCmdAlt) {
        postMenu(false);
        msg.m = "";
        return msg;
      }
      if (lower === (menuCmd + " short") || lower === (menuCmdAlt + " short")) {
        postMenu(true);
        msg.m = "";
        return msg;
      }

      // TAGS
      if (lower === tagsCmd || lower === tagsCmdAlt) {
        postTags();
        msg.m = "";
        return msg;
      }

      // RANK (self) or (user)
      if (lower.indexOf(rankCmd) === 0 || lower.indexOf(rankCmdAlt) === 0) {
        var parts = m.split(/\s+/);
        var targetUser = (parts.length >= 2) ? parts[1] : user;
        var total = state.userTotals[targetUser] || 0;
        var idx = getRankIndex(total);
        var rankName = (idx >= 0) ? state.rankNames[idx] : "Unranked";
        sendRoom("Rank for " + targetUser + ": " + rankName + " (" + total + " total tokens)");
        msg.m = "";
        return msg;
      }

      // HELP
      if (lower === helpCmd || lower === helpCmdAlt) {
        sendRoom(
          "Commands: " +
          menuCmd + " | " + menuCmd + " short | " +
          tagsCmd + " | " +
          rankCmd + " (or " + rankCmd + " username)"
        );
        msg.m = "";
        return msg;
      }

      return msg;
    } catch (e) {
      return msg;
    }
  });

  cb.onTip(function (tip) {
    try {
      var user = tip.from_user;
      var amt = safeInt(tip.amount, 0);
      if (!user || amt <= 0) return;

      // Totals (non-persistent)
      if (!state.userTotals[user]) state.userTotals[user] = 0;
      state.userTotals[user] += amt;

      // Rank up detection
      var prevIdx = (state.userRankIndex[user] === undefined) ? -1 : state.userRankIndex[user];
      var newIdx = getRankIndex(state.userTotals[user]);
      state.userRankIndex[user] = newIdx;

      if (newIdx > prevIdx) {
        var rankName = state.rankNames[newIdx] || ("Rank " + (newIdx + 1));
        if (cb.settings.rank_notify_room === "yes") {
          sendRoom("STATUS UPGRADE: " + user + " is now " + rankName + ".");
        }
        if (cb.settings.rank_notify_private === "yes") {
          sendToUser("STATUS UPGRADE: You reached " + rankName + ". Total: " + state.userTotals[user], user);
        }
      }

      // Privileged trigger tip (optional)
      var trigger = safeInt(cb.settings.privileged_trigger_tip, 0);
      if (trigger > 0 && amt >= trigger) {
        openPrivilegedMode(cb.settings.privileged_minutes);
        sendRoom("PRIVILEGED MODE is now OPEN (triggered).");
      }

      // Goal progress
      state.goalProgress += amt;
      maybeGoalMilestones();

      // Goal reached
      if (state.goalProgress >= safeInt(cb.settings.goal_target, 1)) {
        openPrivilegedMode(cb.settings.privileged_minutes);
        resetGoalIfNeeded();
      }

      // Tip menu reaction on exact match
      for (var i = 0; i < state.menu.length; i++) {
        if (state.menu[i].price === amt) {
          var line = state.menu[i].text;
          if (isPrivilegedActive()) {
            sendRoom("PRIVILEGED: " + user + " -> " + line);
          } else {
            sendRoom(user + " -> " + line);
          }
          break;
        }
      }
    } catch (e) {
      // do nothing (avoid stopping bot)
    }
  });

  init();

})();