Chaturbate

Bots Home | Create an App
Roxi's Tip Manager
Author: dopender1
Description Source Code Launch Bot Current Users
There are 6 other versions of this script.
(function (factory) {
  typeof define === 'function' && define.amd ? define(factory) :
  factory();
}((function () { 'use strict';

  // themes
  const THEME$1 = {
    DEFAULT: {
      BG: '#ffe0e9',
      TEXT: '#ff006e',
      WEIGHT: 'bold',
    },
    ALT: {
      DEFAULT: {
        BG: '#fff',
        TEXT: '#000',
        WEIGHT: 'bolder',
      },
    },
  };

  const SHOW_MENU = 'tipmenu';

  class CommandParser {
    constructor(cb, module) {
      this.cb = cb;
      this.module = module;
    }

    get CMD_PREFIX() {
      return '/'
    }

    get Commands() {
      return { SHOW_MENU }
    }

    clean(cmd) {
      if (cmd.length < 1) {
        return cmd
      }

      if (cmd.startsWith(this.CMD_PREFIX)) {
        cmd = cmd.substring(1, cmd.length);
      }

      return cmd
    }

    isCommand(cmd) {
      return Object.keys(this.Commands).some(
        (key) => this.Commands[key] === this.clean(cmd)
      )
    }

    handleCommand(cmd, forUser) {
      this.cb.chatNotice(cmd + ' ' + this.isCommand(cmd) + ' ' + this.clean(cmd));

      if (!this.isCommand(cmd)) {
        return false
      }

      switch (this.clean(cmd)) {
        case SHOW_MENU:
          this.module.print(forUser);
          break
      }
    }
  }

  const ENV = {
    totalMenuItems: 20,
  };

  const L$1 = {
    ES: {
      ADMIN: {
        LABELS: {
          TIP_ITEM: 'Articulo #$no',
        },
      },
    },
  };

  const ITEM_PREFIX = 'tipitem_';

  const getSettings$1 = () => {
    const tipItemsSettings = [];
    for (let i = 1; i <= ENV.totalMenuItems; i++) {
      tipItemsSettings.push({
        name: getTipId(i),
        type: 'str',
        defaultValue: defaults$1[i - 1],
        label: getTipLabel(i),
        required: false,
      });
    }

    return tipItemsSettings
  };

  function getTipId(id) {
    return `${ITEM_PREFIX}_${id}`
  }

  function getTipLabel(suff) {
    return L$1.ES.ADMIN.LABELS.TIP_ITEM.replace('$no', suff)
  }

  const defaults$1 = [
    '3--Hi, tell me about you',
    '4--Kiss Me :kissy',
    '10--Flash Feet :feetemoji',
    '12--Suck Feet :feetemoji',
    '13--Spank Ass',
    '16--Dance on a Song',
    "25--I'll show Tits",
    '35--Holy Ass',
    '45--Oil in my sweet tits',
    '50--Admire my Pussy',
    '101--No cloth on my body',
    '333--Watch me ride a dildo',
    '499--Help for my school',
    '888--Be my sugar daddy',
    "500--I'll cum for you",
    '999--Be my first and only love',
    '2222--Smile, lol',
  ];

  class TipMenu {
    constructor(cb) {
      this.cb = cb;
      this._cmdParser = new CommandParser(cb, this);
    }

    get Commands() {
      return this._cmdParser.Commands
    }

    get CommandParser() {
      return this._cmdParser
    }

    get Settings() {
      return getSettings$1()
    }

    get Theme() {
      return THEME$1
    }

    get Menu() {
      return this._menu
    }

    init() {
      this._menu = {};
      this.constructMenu();
    }

    /**
     * contruct Menu object from bot settings
     */
    constructMenu() {
      const itemKeys = this.getMenuItemKeys();
      for (let itemKey of itemKeys) {
        const [amount, task] = this.cb.settings[itemKey].split('--');
        this._menu[amount] = task;
      }
    }

    /**
     * print Menu
     */
    print(forUser = '') {
      this.sendNotice(`:heart7 My Tip Menu :heart7`, forUser, true);
      const msg =
        this.toString() +
        `\n\nType /${this.Commands.SHOW_MENU} to display tip menu.`;
      this.sendNotice(msg, forUser);
    }

    getMenuItemKeys() {
      const itemKeys = Object.keys(this.cb.settings).filter(
        (key) => key.startsWith(ITEM_PREFIX) && this.cb.settings[key]
      );
      return itemKeys
    }

    sendNotice(msg, forUser = '', altTheme = false) {
      const theme = altTheme ? this.Theme.ALT.DEFAULT : this.Theme.DEFAULT;
      this.cb.sendNotice(msg, forUser, theme.BG, theme.TEXT, theme.WEIGHT);
    }
  }

  // prototypes
  TipMenu.prototype.toString = function () {
    let msg = '';
    const maxLabelBuffer = Object.keys(this.Menu).reduce((maxLbl, tip) => {
      const val = String(tip);
      if (maxLbl < val.length) {
        return val.length
      }
      return maxLbl
    }, 0);

    for (let tip in this.Menu) {
      msg += `(${tip})${getSep(tip, maxLabelBuffer)}${this.Menu[tip]}\n`;
    }
    msg = msg.substring(0, msg.length - 1);
    return msg
  };

  const getSep = (tip, maxBuff) => {
    let l = '..........................................';
    const val = String(tip);
    for (let i = 0; i <= maxBuff - val.length; i++) {
      l += '.';
    }
    return l
  };

  // themes
  const THEME = {
    DEFAULT: {
      BG: '#ffe0e9',
      TEXT: '#ff006e',
      WEIGHT: 'bolder',
    },
    ALT: {
      DEFAULT: {
        BG: '#ff00cc',
        TEXT: '#fff1ec',
        WEIGHT: 'bolder',
      },
    },
    EMOJI: {
      DEFAULT: {
        BG: '#FFF',
        TEXT: '#FFF',
        WEIGHT: 'normal',
      },
    },
  };

  const L = {
    ES: {
      ADMIN: {
        LABELS: {
          RESPONSE_TEMPLATE: 'Respuesta del Artículo #$no',
          RESPONSE_EMOJI: 'Respuesta Emoji del Artículo #$no',
        },
      },
    },
  };

  const RESPONSE_TEMPLATE_PREFIX = 'tipitemresponse_';
  const RESPONSE_EMOJI_PREFIX = 'tipitemresponseemoji_';

  const getSettings = () => {
    const tipResponsSettings = [];

    for (let i = 1; i <= ENV.totalMenuItems; i++) {
      tipResponsSettings.push(
        ...[
          {
            name: getResponseTemplateId(i),
            type: 'str',
            defaultValue: defaultres[i - 1],
            label: getResponseTemplateLabel(i),
            required: false,
          },
          {
            name: getResponseEmojiId(i),
            type: 'str',
            defaultValue: defaults[i - 1],
            label: getResponseEmojiLabel(i),
            required: false,
          },
        ]
      );
    }

    return tipResponsSettings
  };

  function getResponseTemplateId(id) {
    return `${RESPONSE_TEMPLATE_PREFIX}_${id}`
  }

  function getResponseTemplateLabel(suff) {
    return L.ES.ADMIN.LABELS.RESPONSE_TEMPLATE.replace('$no', suff)
  }

  function getResponseEmojiId(id) {
    return `${RESPONSE_EMOJI_PREFIX}_${id}`
  }

  function getResponseEmojiLabel(suff) {
    return L.ES.ADMIN.LABELS.RESPONSE_EMOJI.replace('$no', suff)
  }

  const defaults = [
    ':hiiii8898',
    ':kiss7',
    ':feethappy',
    ':roxi_thanks_2',
    ':spank00',
    ':DoTheShortCake21',
    ':TITs',
    ':ASS',
    ':oilboobs',
    ':pussy',
    ':nakedbanana',
    ':ridedildo5005',
    ':schoolgirl_bv',
    ':roxi_thnaks_2',
    ':fingerpussy0',
    ':LOve',
    ':roxi_thanks_2',
  ];

  const defaultres = [
    '',
    'Thanks my $user, Muahh',
    'My feet for $user',
    'Feel my feet $user, Muahh',
    ':blushhh Uffff it makes me feel naughty, my $user',
    'I love it, enjoy my moves $user',
    "I'll tease you $user, Hehehe",
    'It makes me feel naught for you $user, be gentle',
    'Enjoy the show',
    'Mmmm my $user, do you want to touch?',
    'You give me what I want bb',
    'I want to ride you my $user',
    'Thank you so much, you are the best $user',
    "Mmmmm Daddy $user, let's have some fun",
    "Thanks $user, I was feeling horney, make me feel good and I'll end with a squirt for you bb",
    "I feel butterflies. $user, let's get to know each other.",
    "Hahah it's a Joke",
  ];

  class TipResponder {
    constructor(cb, tipMenu) {
      this.cb = cb;
      this._tipmenu = tipMenu;
    }

    get Settings() {
      return getSettings()
    }

    get Theme() {
      return THEME
    }

    set TipMenu(tipMenu) {
      this._tipmenu = tipMenu;
    }

    init() {
      if (this._tipmenu === null || this._tipmenu === undefined) {
        throw new Error('TipMenu must be set before initialization')
      }
    }

    onTip(tip) {
      if (tip.amount in this._tipmenu.Menu) {
        const emoji = this.getEmoji(tip.amount);
        const responseTemplate = this.getResponseTemplate(tip.amount);

        if (responseTemplate) {
          this.sendResponse(tip, responseTemplate);
        }

        if (emoji) {
          this.sendEmoji(emoji);
        } else {
          this.sendNotice(':roxi_thanks2');
        }
      }
    }

    getIndexOfTipItem(amount) {
      return Object.keys(this._tipmenu.Menu).findIndex(
        (item) => String(item) === String(amount)
      )
    }

    getEmoji(amount) {
      const itemIndex = this.getIndexOfTipItem(amount);

      const emojiKey = this.Settings.filter(({ name }) =>
        name.startsWith(RESPONSE_EMOJI_PREFIX)
      )[itemIndex];

      return this.cb.settings[emojiKey.name]
    }

    getResponseTemplate(amount) {
      const itemIndex = this.getIndexOfTipItem(amount);

      const responseKey = this.Settings.filter(({ name }) =>
        name.startsWith(RESPONSE_TEMPLATE_PREFIX)
      )[itemIndex];

      return this.cb.settings[responseKey.name]
    }

    sendNotice(msg, forUser = '', altTheme = false) {
      const theme = altTheme ? this.Theme.ALT.DEFAULT : this.Theme.DEFAULT;
      this.cb.sendNotice(msg, forUser, theme.BG, theme.TEXT, theme.WEIGHT);
    }

    sendEmoji(msg, forUser = '') {
      const theme = this.Theme.EMOJI.DEFAULT;
      this.cb.sendNotice(msg, forUser, theme.BG, theme.TEXT, theme.WEIGHT);
    }

    sendResponse(tip, template, forUser = '', altTheme = false) {
      if (tip.amount in this._tipmenu.Menu) {
        const task = this._tipmenu.Menu[tip.amount];
        const msg = template
          .replace('$task', task)
          .replace('$user', tip.from_user);

        this.sendNotice(msg, forUser, altTheme);
      }
    }
  }

  const mishmashTipSettings = (menuSettings, responderSettings) => {
    const mergedMenu = menuSettings.reduce((final, menuSetting, idx) => {
      let fi = idx * 2;
      let si = fi + 1;

      final.push(menuSetting, responderSettings[fi], responderSettings[si]);
      return final
    }, []);

    return mergedMenu
  };

  /* eslint-disable no-undef */

  const gTipMenu = new TipMenu(cb);
  const gTipResponder = new TipResponder(cb, gTipMenu);

  // commands
  const CMD = {
    _PREFIX: '/',
  };
  /**
   * Command Helpers
   */
  const isCommand = (msg) => msg.m.startsWith(CMD._PREFIX);

  const handleCommand = (msg) => {
    if (gTipMenu.CommandParser.isCommand(msg.m)) {
      gTipMenu.CommandParser.handleCommand(msg.m, msg.u);
      return true
    }
    return false
  };
  /** */

  // function callme() {
  //   gTipMenu.print()
  //   cb.setTimeout(callme, 240000)
  // }

  function init() {
    gTipMenu.init();
    gTipResponder.init();
    // cb.setTimeout(callme, 240000)
  }

  cb.settings_choices = [
    ...mishmashTipSettings(gTipMenu.Settings, gTipResponder.Settings),
  ];

  /**
   * lifecycle
   */
  cb.onStart(() => {
    init();
  });

  cb.onMessage((message) => {
    if (isCommand(message)) {
      const handled = handleCommand(message);
      if (handled) {
        message['X-Spam'] = true;
      }
    }
    return message
  });

  cb.onTip((tip) => {
    gTipResponder.onTip(tip);
  });

})));