Chaturbate

Bots Home | Create an App
dice4fun
Author: phonzotar
Description Source Code Launch Bot Current Users
There are 66 other versions of this script.
// Version: 0.0.1 of 2018-10-24 inspired by kingchris_ and zingknaat

cb.settings_choices = [
  {
    label: 'How much do you charge per roll?',
    name: 'tokens', type: 'int', minValue: 1, defaultValue: 13
  },
  {
    label: 'Wait how many minutes before touting again? 0 for never',
    name: 'notice_wait_time', type: 'int', minValue: 0, defaultValue: 8
  },
  {
    label: 'Minimum lines of normal chat before touting again?',
    name: 'notice_wait_lines', type: 'int', minValue: 0, defaultValue: 20
  },
  {
    label: 'Change command prefix if other bots use the same prefix.',
    name: 'cmd_prefix', type: 'str', minLength: 1, defaultValue: '#'
  },
];

const uni = {
  hands: "\u{1f64f}",
  dice: ["\u{1f3b2}","\u2680","\u2681","\u2682","\u2683","\u2684","\u2685"],
  heard: "\u{1f49c}",
  heart: "\u2764",
  stern: "\u2b50",
  coins: "\u26c1",
  arrov: "\u2192",
  arruw: "\u2b62",
  arrow: "\u279c",
}

var waitAlarm = false; // wait for the alarm clock before touting again
var chatLines = 0;     // number of normal lines seen after last touting
const numOfDice = 3;

const cmdPrefix = cb.settings.cmd_prefix;

var banner = ""; // This announces those of our services that are active.

// The objects "menu" and "dice" share and extend a common basic structure which describes a service.
// Each of these services offers various tasks to be performed by the slug, depending on a key.
// For both services that key will be a number, and the current implementation may depend on that fact.
// The main task of a service object is to map keys to tasks. It will present the tasks to clients.
// It will show them how they can select a task to be performed. Usually they have to pay tokens.
// And it will, once a task has been selected, celebrate and write the task into the chat window,
// so everyody know what the slug is about to do, including the slug who read the chat window as well.
//
// Actually, each service deals with three lists of tasks, to be used in in three different phases.
// Phase 1: Chaturbate runs the Bot just in order to preset the cb.settings_choices, and then ends the Bot.
// Phase 2: The slug choses the cb.settings, Chaturbate launches the Bot again, the Bot reads the settings.
// Phase 3: The Bot keeps running and Chaturbate occasionally calls the callbacl functions cb.on*().
//
// Thus, the Bot will run twice, and it does not even know in which phase it is being called.
// Our solution is that each time we run, we both preset the cb.settings_choices and read the cb.settings.
// Each time we process some useless information, but apart from wasting CPU time that does no harm.
//
// Phase 1 expects us to preset the cb.settings_choices. We fill in a few special items like "tokens",
// which is the price a client must pay in order to roll the dice, and two lists of choices.
// Each such list consists of several items numbered consecutively from .mini to .maxi - these numbers
// are part of the service object, and they also appear in the name and labels ob the cb.settings_choices.
// For dice, the consecutive numbers are the possible results of throwing the dice, e.g. 3...18 for 3 dice.
// for menu, the consecutive numbers are just 1... to the number of possible entries in the Tip Menu.
// We preset the cb.settings_choices by using the content of the array .preset plus, if needed, empy lines.
//
// Phase 2 expects us to read the cb.settings and prepare our internal structures to be ready for Phase 3.
// That means we maintain a map from keys to tasks, plus a list of these keys, plus a list of counters.
// Thus we create 3 arrays per service during intialization. The main array .tasks maps keys to tasks.
// Here a key may be any data type, but for now it's always a positive integer. Maybe we rely on that.
// The array .tasks maps each key to a plain text describing a task. Both key and task will be visible.
// The array .keys just contains the sequential list of keys, which allows us to process them in order.
// The array .count maps keys to numbers counting how often the corresponting taks has been performed.
// Creating the keys and tasks is not completely simple, as the cb.settings just give us test strings.
// Now what is the key and what is the task? The honest answer is that in general, we have no idea.
// Fortunately, the service has that knowledge, implemented in the function .scan() which gets a line
// from cb.settings and returns both the key and the task. The details are up to the service.
// In Phase 2 we also prepare a banner, which is used to tout our services, that is, announce them.
//
// Phase 3 starts after our code has been executed the 2nd time and Chaturbate considered the start done.
// In Phase 3 only our callback functions will be called. Now they utilize the objects prepared in Phase 2.
// In cb.onTip() there is some code that determines which service, if any, should process a tip.
// Then cb.onTip() calls .act() which receives an amount tipped and the name of the client who tipped.
// The function .act() returns the key to be used to determine the task to be performed by the slug
// plus a description of the process that determined the key, but not the actual task to be performed.
// The Bot can simply look up the task in the map .tasks and it celebtrates the event by showing a line
// which consist of the description produced by .act(), a celebration symbol and the task to be run.
//
// The banner must be handled with care. It should contain enough information, but not flood the screen.
// Many Apps ans Bots fulfill neither of these two requirements, especially if they roll dice.
// Many popular dice rollers flush lots of lines into the chat window, explaining how dice work
// and that the client may throw dice and how much to pay for throwing and that he may pay even more,
// and that he will win a prize after he tipped the amount needed and the dice have been thrown,
// and that a client can get a list of prizes, and that all prizes stay on the list, whatever that means,
// and they repeat all that every few minutes, regardless how much text has been written by clients.
// Thus if the clients are quiet for a while, it may happen that the whole screen is full these lines.
// Yet they don't list the prizes. Instead, they write how to get that list, e.g. by typing "!prizes".
// And if a client runs that command to see the list of prizes, if fills the screen even more.
// Most Bots present prizes on Dice Rolling in one line per prize, which wastes lots of screen space.
// Each such line contains a number a dice can roll and the corresponding task. So this long list
// maps numbers rolled by dice to tasks, e.g. 13 -> "Blow a kiss", or whatever the slug should do then.
// Tip Menu Bots maintain a similar map. Here the key is simply an amount of tokens tipped by the client.
// In contrast to dice rollers, most Tip Menu bots write that map into one single very long line.
// Usually the chat window wraps around that long line, thus it consumes several real lines.
// Thus the map may consume several real lines, but far less real lines than 1 line per task.
// Technically either way is possible. I prefer the compact presetation of the whole map in one line.
// I also don't want the Bot to blab around all the time when nobody write in the chat window.
// A clients is typically male. Thus he wants everybody else to confirm that he, the client,
// is the most important person in the world, extraordinary interesting, smart and entertaining.
// This claim is not compatible with a Bot which by pushing the Client's lines out of the window
// states that the 13h repetition of the same notice is more important than what the Client writes.
// Thus my banner presents both services in a similar design, less dominant than other Bots,
// and won't repeat it unless a certain number of normal lines has been written in between.
// The result is that a few simple and pretty lines, obviously describing two similar services,
// present all the information needed, but don't disturb the chat flow more than neccessary.
//
// The banner consist of up to 2 lines, each describing a service. Each such line consists of a title
// and a sequence of task descriptions. Each task description consists of a separator, a numeric key,
// a right arrow and the actual task. The service object defines the .title and the .separ string.
//
// The style of a banner service description is similar to other Tip Menu bots, with a few differences.
// Our banner does not use a coloured background. The banner should never dominate the chat window.
// It's very visile anyway, thus there is no need to make it even more prominent. The clients matter!
// Also, we drop the usual style of postponing the price: "Blow a Kiss (10)" - that is quite ugly,
// and clients that are new to chaturbate may think the (10) refers the the next taks, not the previous.
// Instead, we describe the task as "10 -> Blow a Kiss" using a pretty unicode arrow chjaracter.
// That not even looks better, but also makes clear that 10 is the price for "Blow a Kiss".
// Also, the same style applies to both services, menu and dice, showing that the same Bot drives them.
// They use different separators, though, a heart for the menu and Dice for dice, to avoid confusion.
// And they use some synergy: The last two items of the Tip Menu are "Roll Dice" and "Roll 5 times",
// and these items contain the dice separator, the Dice, once or 5 times, which is very expressive.
// It shows that the Tip Menu and Roll the Dice are aware of each other, and how they are connected:
// Tipping the tokens for "Roll the Dice" or "Roll 5 times" triggers 1 or 5 dice rolls.
//
// Moderators and the slug can use the commands #stat so see statistics, or #roll to roll the dice.
// Other users neither know these commands, nor can they use them. The results use coloured background.
// It's obvious that #stat can be useful for a slug: Which task occures how often? But is #roll useful?
// Why should a slug commit herself to execute a task without getting any tokens for that? Simple:
// Imagine roll the dice costs 15 tokens. A clients wants to roll 3 times and tips 45 tokens.
// Nothing happens, and the clients is disappointed and expresses his disappointment.
// At that point, the slug better type #roll 3 times and tells the client that for tipping 60 tokens,
// the price of 4 dice rolls, he'll even get 5 dice rolls, thus one dice roll for free.
// The slug received her tokens, she performs the tasks determined by dice, and the client is happy.
//
// Apart from that, there are no special commands. Nothing like "/prizes" or "!lol" as in other Bots.
// Instead of instructions on how to display a list of prizes, the clients see the list of prizes.

var menu = {
  name: "Tip Menu",
  mini: 1,
  maxi: 25,
  cname: "tipme1_",
  title: "Tip tokens for a Task",
  separ: uni.heard,
  preset: [
    "5 PM",
    "30 Hand Bra 5min",
    ".99 invisible entry",
  ],
  hint: function(index) {
    return "Price and Task for Tip Menu";
  },
  scan: function(line) { // split "10 P M" or " 10: P M" or " 10--P M " into 10 and "P M"
    var split = /^\s*(\d+)\W+(\w.*\S)\s*$/.exec(line); // ignore blank in some places
    if (split == null) return [];
    var amt=parseInt(split[1]);
    if (amt===dice.roll1) return []; // roll1 is reserved to roll Dice. roll5 is yet unknown.
    return [amt,split[2]];
  },
  act: function(amount, uname) { // What triggers the task? Simple: Tipping the amount!
    return [amount, uname + " tipped " + amount];
  },
  alive: 0, // "Tip Menu" active
}

var dice = {
  name: "Roll the Dice",
  mini: numOfDice,
  maxi: numOfDice*6,
  cname: "prize1_",
  title: "Roll Dice and win",
  separ: uni.dice[0],
  preset: [
    "cream pussy",
    "cream boobs",
    "5 min naked",
    "5 min hand bra",
    "5 min hair bra",
    "5 min undress 1 piece",
    "lick lips",
    "blow a kiss",
    "flash feet",
    "flash butt",
    "dance",
    "shake naked boobs",
    "your name on boobs",
    "spank butt",
    "spank boobs",
    "spank pussy",
  ],
  points: numOfDice,
  hint: function() {
    const dice = numOfDice;
    const vals= 6;
    const full = Math.pow(vals,dice);
    var digs = 2;
    var dezi = 100;
    while (2*dezi<full) digs++,dezi*=10;
    var hits = [1];
    for (let i=0; i<dice; i++) { // This approach scales well even for many dice
      var sums = Array(hits.length+vals-1).fill(0);
      for (let i=0; i<hits.length; i++) for (let j=0; j<vals; j++) sums[i+j]+=hits[i];
      hits = sums;
    }
    hits = Array(dice).fill(0).concat(hits);
    return function (index) {
      const rate = hits[index];
      var prop = Math.round(dezi*rate/full);
      var line = "%";
      for (var i=digs; i; i--) {
        line = prop%10+line, prop=Math.floor(prop/10);
        if (i==3) line = "."+line;
      }
      return "Task for sum "+index+", chance is "+rate+"/"+full+" = "+line;
    };
  } (),
  scan: function(line) { // get the task, no key, and return key and task
    var p=this.points++; // The key is simply the next available dice result.
    return [p, line.length?line:"Thank You"]; // task is empty? Be friendly!
  },
  act: function(amount, uname) { // What triggers a task? We have to roll the dice!
    var line = ""; // describes the process and result of rolling dice.
    var sum = 0; // The key, which here is the result of rolling the dice.
    for (var i = 0; i < numOfDice; i++) {
      var iacta = Math.floor(Math.random()*6) + 1;
      line += "[" + iacta + "] ";
      sum += iacta;
    }	
    return [sum, line + uname + " rolled " + sum];
  },
  roll1: parseInt(cb.settings.tokens), // 1x dice roll
  roll5: 0, // discount price for 5 dice rolls
}

// This function both sets cb.settings_choices and reads cb.settings.
// How can that work, especially in a loop like this? I don't really know.
// I guess that Chaturbate runs the whole Bot twice, including init();
// Between both invocations, the slug will submit her cb.settings.
// During 1st run, the 1st half inside the for loop will be useful.
// During 2nd run, the 2nd half inside the for loop will be useful.
function setTasks(service) { // preset cb.settings_choices and read cb.settings
  service.keys = [];   // tip amounts for "menu", dice roll results for "dice"
  service.tasks = [];
  service.count = [];
  service.total = 0;
  var j = 0;
  for (let i=service.mini; i<=service.maxi; i++, j++) {
    pName = service.cname + i;
    cb.settings_choices.push({
      name: pName,
      type: 'str',
      label: service.hint(i),
      defaultValue: j<service.preset.length ? service.preset[j] : "",
      required: false
    });
    if(!(pName in cb.settings)) continue;
    const filled = service.scan(cb.settings[pName]);
    if (filled.length!=2) continue;
    var key = filled[0];
    if (key in service.tasks) return;
    service.keys.push(key);
    service.tasks[key] = filled[1];
    service.count[key] = 0;
  }
}

function toutOnce(uname) {
  cb.sendNotice(banner,uname,'','#CC66FF');
}

function toutAgain() {
  if (chatLines<parseInt(cb.settings.notice_wait_lines) || waitAlarm) return;  
  toutOnce();
  chatLines = 0;
  setAlarm();
}

function setAlarm() {
  function timedOut() {
    waitAlarm = false;
    toutAgain();
  }
  waitAlarm = true;
  const wait = parseInt(cb.settings.notice_wait_time);
  if (wait > 0) cb.setTimeout(timedOut, wait*60000);
}

function doTask (service,amount,uname) {
  const arr = service.act(amount,uname);
  amount = arr[0];
  cb.sendNotice (arr[1] + "  " + uni.stern + "  " + service.tasks[amount], '', '', '', "bold");
  service.count[amount]++;
  service.total++;
}

function doCommand (msg) {
 const uname = msg.user;
  if (!msg.is_mod && uname != cb.room_slug) return;
  var line = msg.m;
  const head = line.indexOf(cmdPrefix); // We can't just use the begin of the line because ...
  if (head < 0) return; // ... some bots decorate lines by prefixes before we see them.
  var args = line.substring(head+cmdPrefix.length).split(" ");
  line = "";
  function allStats() {
    function oneStats(service) {
      if (line.length) line += "\n";
      line += service.name + " statistics:";
      for (let i = 0; i < service.keys.length; i++) {
        const j = service.keys[i];
        const k = service.count[j];
        if (k == 0) continue;
        line += " "+k+"#"+j;
      } line += " total: " + service.total;
    }
    if (menu.alive) oneStats(menu);
    if (dice.roll1) oneStats(dice);
    cb.sendNotice(line, uname, '#DBFBFF');
  }
  switch (args[0]) {
    case 'stat':
      allStats();
      break;
    case 'roll':
      doTask(dice,0,uname);
      break;
    default:
      return;
  }
  msg["X-Spam"] = true;  // Don't print command messages to chat.
}

cb.onEnter (function(usr) {
  const uname = usr.user;
	toutOnce(uname);
  if (!usr.is_mod && uname != cb.room_slug) return;
  cb.sendNotice("Moderators and the slug use " + cmdPrefix + "stat to see statistics and " + cmdPrefix + "roll to roll dice. ", uname);
});

cb.onTip (function(tip) {
  const amount = parseInt(tip.amount);
  var rounds = 0;
  if (amount==dice.roll1) rounds = 1; else
  if (amount==dice.roll5) rounds = 5; else
  if (amount in menu.tasks) doTask(menu,amount,tip.from_user);
  while (rounds--) doTask(dice,amount,tip.from_user);
});

cb.onMessage (function(msg) {
  doCommand(msg);
  if(!msg["X-Spam"]) {
      chatLines++;
      toutAgain();
  }
  return msg;
});

function init() {
  setTasks(menu);
  setTasks(dice);
  menu.alive = menu.tasks.length;
  function discount() {
    for (let i=0; i*2<dice.roll1; i++) for (let j=-1; j<2; j+=2) {
      const k = 4*dice.roll1+i*j;
      if (!(k in menu.tasks)) return k;
    }
    return 0;
  }
  dice.roll5 = discount();    
  if (menu.alive) {
    function tipMenuRoll(amount,count,task) {
      if (!amount) return;
      while (count--) task = uni.dice[0] + task;
      menu.tasks[amount] = task;
      menu.keys.push(amount);
      menu.count[amount] = 0;
    }
    tipMenuRoll(dice.roll1, 1, " Roll dice");
    tipMenuRoll(dice.roll5, 5, " Roll 5 times");
  } else if (dice.roll1) {
    banner += "Tip " + dice.roll1 + " to roll dice."
    if (dice.roll5) banner += " Tip " + dice.roll5 + " to roll them 5 times."
    banner += "\n";
  }
  function showSet(service) {
    var line = service.title + ":";
    for (let i=0; i<service.keys.length; i++) {
      const k = service.keys[i];
      line += " " + service.separ + " " + k + " " + uni.arrow + " " + service.tasks[k];
    }
    return line;
  }
  if (menu.alive) banner += showSet(menu);
  if (menu.alive&&dice.roll1) banner += "\n";
  if (dice.roll1) banner += showSet(dice);
  toutOnce();
  setAlarm();
  return;
}

init();