Chaturbate

Apps Home | Create an App
all112
Author: gonch
Description Source Code Launch App Current Users
Created by: Gonch
There is 1 other version of this script.
// Constants ///////////////////////////////////////////////////////////////////

const LISS = 'myliss';

const APP_AUTHOR = 'smoker919';

const EMOJI = '💕';

// fonts
const BOLD = 'bold';

// spacing
const LINE_ENDING = ''; // no padding
// const LINE_ENDING = '\u00A0'; // NBSP

// K-V keys
const BROADCASTER_KEY                  = 'broadcaster';
const BROADCAST_STOP_TIME_KEY          = 'broadcast_stop_time';
const GOALS_KEY                        = 'goals';
const CURRENT_GOAL_INDEX_KEY           = 'current_goal_index';
const CURRENT_GOAL_TOKENS_RECEIVED_KEY = 'current_goal_tokens_received';
const SETGOAL_GOAL_KEY                 = 'setgoal_goal';
const LAST_TIP_KEY                     = 'last_tip';
const HIGHEST_TIP_KEY                  = 'highest_tip';
const PANEL_UPDATE_COUNTER_KEY         = 'panel_update_counter';
const SETTINGS_KEY                     = 'settings';

// callbacks
const PANEL_UPDATE_LABEL      = 'panel_update';
const CLOSE_GOAL_NOTICE_LABEL = 'close_goal_notice';

// regex
const TEST_COMMAND_REGEX = /^\/(test|testanon) ([1-9][0-9]*)$/;

// misc
const MAX_GOALS        = 15;
const ANONYMOUS_USER   = 'anonymous user';
const PROGRESS_SLOTS   = 12;
const PROGRESS_SYMBOLS = { full: '♥ ', partial: '❤ ', empty: '♡ ' };
const SETGOAL_INDEX    = 999;


// Commands ////////////////////////////////////////////////////////////////////

const SKIP_GOAL_COMMAND = {
  name:        '/skipgoal',
  description: 'Skip to the next goal if there is one.',
  usage:       '/skipgoal',
  regex:       /^ ?\/skipgoal(?: (.*))?$/i
};
const RESET_GOALS_COMMAND = {
  name:        '/resetgoals',
  description: 'Start all the goals from the beginning again.  Goals set using the /setgoal command are discarded.',
  usage:       '/resetgoals',
  regex:       /^ ?\/resetgoals(?: (.*))?$/i
}
const SET_GOAL_COMMAND = {
  name:        '/setgoal',
  description: 'Sets a new goal, replacing the current one if it is still running.',
  usage:       '/setgoal [goal description] : [tokens]',
  regex:       /^ ?\/setgoal(?: (.+?) ?: ?([1-9]\d*) ?|.*)$/i
};
const TEST_COMMAND = {
  name:        '/test',
  description: 'Simulates tipping for test purposes only.',
  usage:       '/test [username] [tokens]',
  regex:       /^ ?\/test (?:@?(\w{3,30}) )?([1-9]\d*) ?$/i
};
const TEST_ANON_COMMAND = {
  name:        '/testanon',
  description: 'Simulates anonymous tipping for testing purposes only.',
  usage:       '/testanon [username] [tokens]',
  regex:       /^ ?\/testanon (?:@?(\w{3,30}) )?([1-9]\d*) ?$/i
};


// Functions ///////////////////////////////////////////////////////////////////

function randomInt(min, max, inclusive) {
  return min + Math.floor(Math.random() * (max - min + (inclusive ? 1 : 0)));
}

// centralize this process so it's easy to change if CB reverts their changes
function padLine(line) {
  return LINE_ENDING ? line + LINE_ENDING : line;
}

function padLines(lines) {
  return LINE_ENDING ? lines.split('\n').map(line => padLine(line)).join('\n') : lines;
}

function capitalizeUsername(username) {
  // capitalize the leading character of each part of the username
  return username
    .split('_')
    .map(part => {
      switch (part.length) {
        case 0: return '';
        case 1: return part.toUpperCase();
        default: return part[0].toUpperCase() + part.substring(1);
      }
    })
    .join('_');
}

function isTestbed() {
  return $app.version === 'Testbed';
}

function isAuthorized(fromChatMessageTransformHandler = false) {
  let broadcaster = fromChatMessageTransformHandler ? $kv.get(BROADCASTER_KEY, null) : $room.owner;
  return broadcaster === LISS || broadcaster === APP_AUTHOR || isTestbed();
}

function log(message) {
  message = '[' + $app.name + '] ' + message;
  $room.sendNotice(message, $room.owner);
}

function announceAppStarted() {
  $room.sendNotice(EMOJI + ' ' + $app.name + ' (v' + $app.version + ') for Liss by Smoker919 has started.');
}

function announceAppStopped() {
  $room.sendNotice(EMOJI + ' ' + $app.name + ' has stopped.');
}

function announceAppSettingsChanged() {
  $room.sendNotice(EMOJI + ' ' + $app.name + ' has settings changed.');
}

function announceGoalStarted() {
  $room.sendNotice(padLine(EMOJI + ' Goal started: ' + getCurrentGoal().description), {
    color: $settings.primary_colour,
    bgColor: $settings.secondary_colour,
    fontWeight: BOLD
  });
}

function announceGoalCompleted() {
  let message = padLines(EMOJI + ' Goal completed: ' + getCurrentGoal().description + '\n:stitchlicked ');
  $room.sendNotice(message, {
    color: $settings.primary_colour,
    bgColor: $settings.secondary_colour,
    fontWeight: BOLD
  });
}

function announceGoalDescriptionChanged() {
  let message = padLine(EMOJI + ' Goal description changed: ' + getCurrentGoal().description);
  $room.sendNotice(message, {
    color: $settings.primary_colour,
    bgColor: $settings.secondary_colour,
    fontWeight: BOLD
  });
}

function initKeyValueStore() {
  $kv.set(BROADCASTER_KEY, $room.owner);
  $kv.set(PANEL_UPDATE_COUNTER_KEY, 0);
  resetGoals();
}

function resetTipStats() {
  $kv.remove(LAST_TIP_KEY);
  $kv.remove(HIGHEST_TIP_KEY);
}

function loadSettings() {
  $kv.set(GOALS_KEY, getGoalsFromSettings());
  storeSettings();
}

function reloadSettings() {
  let currentGoals = $kv.get(GOALS_KEY);
  let currentGoal = getCurrentGoal();
  let currentSettings = $kv.get(SETTINGS_KEY);
  let tokensReceived = $kv.get(CURRENT_GOAL_TOKENS_RECEIVED_KEY);
  let currentGoalCompleted = tokensReceived === currentGoals[currentGoal.index].amount;
  let newGoals = getGoalsFromSettings();

  let resetGoals = false;
  let currentGoalDescriptionChanged = false;

  if (newGoals.length <= currentGoal.index) {
    // less goals than where the progression is, so reset the progression
    resetGoals = true;
    if (isTestbed()) {
      log('Less goals were set than where the current goal is, so reset the goals.');
    }
  } else if (currentGoal.index === currentGoals.length - 1 && currentGoalCompleted && newGoals.length > currentGoals.length) {
    // new goals added after the last goal was completed, so reset the progression
    resetGoals = true;
    if (isTestbed()) {
      log('New goals were added after the last goal was completed, so reset the goals.');
    }
  } else {
    // check if any of the previous goals or the current goals changed amount and reset the progression
    for (let i = 0; i <= currentGoal.index; i++) {
      if (newGoals[i].amount !== currentGoals[i].amount) {
        resetGoals = true;
        if (isTestbed()) {
          log('A amount of a previous or the current goal changed, so reset the goals.');
        }
        break;
      }
    }
    // check if the current goal description changed and update the room and load the panel
    if (newGoals[currentGoal.index].description !== currentGoals[currentGoal.index].description) {
      currentGoalDescriptionChanged = true;
      if (isTestbed()) {
        log('The current goal description was changed, so update the room subject and reload the broadcast panel.');
      }
    }
  }

  let subsequentGoalsRemoved = currentGoals.length > newGoals.length && newGoals.length - 1 === currentGoal.index;

  let roomSettingsChanged = false;
  if ($settings.hashtags !== currentSettings.hashtags || $settings.greeting !== currentSettings.greeting) {
    roomSettingsChanged = true;
    if (isTestbed()) {
      log('Room settings changed, so update the room subject.');
    }
  }

  let colourSettingsChanged = false;
  if ($settings.primary_colour !== currentSettings.primary_colour || $settings.secondary_colour !== currentSettings.secondary_colour) {
    colourSettingsChanged = true;
    if (isTestbed()) {
      log('Colour settings changed, so reload the broadcast panel.');
    }
  }

  let startCloseGoalCallback = $settings.send_close_goal_notices && !currentSettings.send_close_goal_notices;
  let stopCloseGoalCallback = !$settings.send_close_goal_notices && currentSettings.send_close_goal_notices;

  loadSettings();

  return { 
    resetGoals: resetGoals,
    currentGoalDescriptionChanged: currentGoalDescriptionChanged,
    subsequentGoalsRemoved: subsequentGoalsRemoved,
    roomSettingsChanged: roomSettingsChanged,
    colourSettingsChanged: colourSettingsChanged,
    startNextGoal: currentGoalCompleted,
    startCloseGoalCallback: startCloseGoalCallback,
    stopCloseGoalCallback: stopCloseGoalCallback
  };
}

function storeSettings() {
  let settings = {
    primary_colour: $settings.primary_colour,
    secondary_colour: $settings.secondary_colour,
    greeting: $settings.greeting,
    hashtags: $settings.hashtags,
    send_close_goal_notices: $settings.send_close_goal_notices
  };
  for (let i = 1; i <= MAX_GOALS; i++) {
    settings['goal_' + i + '_description'] = $settings['goal_' + i + '_description'];
    settings['goal_' + i + '_amount'] = $settings['goal_' + i + '_amount'];
  }
  $kv.set(SETTINGS_KEY, settings);
}

function getGoalsFromSettings() {
  let goals = [];
  for (let i = 1; i <= MAX_GOALS; i++) {
    let description = $settings['goal_' + i + '_description'];
    let amount = parseInt($settings['goal_' + i + '_amount']);
    if (description && !isNaN(amount)) {
      goals.push({ description: description, amount: parseInt(amount) });
    }
  }
  return goals;
}

function startCallbacks() {
  $callback.create(PANEL_UPDATE_LABEL, 4, true);
  if ($settings.send_close_goal_notices) {
    $callback.create(CLOSE_GOAL_NOTICE_LABEL, isTestbed() ? 60 : 480 + randomInt(1, 30, true));
  }
}

function stopCallbacks() {
  $callback.cancel(PANEL_UPDATE_LABEL);
}

function sendCloseGoalNotice() {
  let currentGoal = getCurrentGoal();
  let tokensReceived = $kv.get(CURRENT_GOAL_TOKENS_RECEIVED_KEY);
  let tokensLeft = Math.max(0, currentGoal.amount - tokensReceived);
  if (tokensLeft > 0) {
    let message = EMOJI + ' Only ' + (tokensLeft === 1 ? '1 token' : tokensLeft + ' tokens') + ' left for: ' + currentGoal.description +
      '\n' + EMOJI + ' Click here to [cb:tip amount=' + tokensLeft + ' message="COMPLETE THE GOAL!"]'; 
    $room.sendNotice(padLines(message), {
      color: $settings.primary_colour,
      bgColor: $settings.secondary_colour,
      fontWeight: BOLD
    });
  }
}

function sendCommandsToBroadcaster() {
  let message = 'Commands for ' + $app.name + ' (for ' + capitalizeUsername($room.owner) + ' only):'
    + '\n/skipgoal - Skip to the next goal, if there is one (broadcaster only)'
    + '\n/resetgoals - Restart the goals from the beginning (broadcaster only)';
  $room.sendNotice(padLines(message), {
    toUsername: $room.owner,
    color: $settings.primary_colour,
    bgColor: $settings.secondary_colour
  });
}

function getOfflineTimeForBroadcastResetInMillis() {
  return 3600000;
}

function resetBroadcastData() {
  resetTipStats();
  $room.sendNotice('[' + $app.name + '] Tip data reset for new broadcast.', { toUsername: $room.owner });
}

function handleTip(username, isAnon, tokens) {
  updateTipStats(username, isAnon, tokens);
  let addTokensResult = addTokens(tokens);
  switch (addTokensResult) {
    case 0: // goal completed
      announceGoalCompleted();
      if (hasMoreGoals()) {
        prepareForNextGoal();
        startGoal(); // calls updateRoomSubject() and $room.reloadPanel()
      } else {
        updateRoomSubject();
        $room.reloadPanel();
      }
      break;
    case 1: // goal not completed
      $room.reloadPanel();
      break;
    case 2: // goal already completed
    default:
      // do nothing
  }
}

function addTokens(tokens) {
  let currentGoal = getCurrentGoal();
  let tokensReceived = $kv.get(CURRENT_GOAL_TOKENS_RECEIVED_KEY);
  if (tokensReceived < currentGoal.amount) {
    tokensReceived = Math.min(tokensReceived + tokens, currentGoal.amount);
    $kv.set(CURRENT_GOAL_TOKENS_RECEIVED_KEY, tokensReceived);
    if (tokensReceived === currentGoal.amount) {
      return 0; // goal completed
    }
    return 1; // goal not completed
  }
  return 2; // goal already completed
}

function prepareForNextGoal() {
  $kv.incr(CURRENT_GOAL_INDEX_KEY);
  $kv.set(CURRENT_GOAL_TOKENS_RECEIVED_KEY, 0);
}

function startGoal() {
  updateRoomSubject();
  $room.reloadPanel();
  announceGoalStarted();
}

function getCurrentGoal() {
  let currentGoalIndex = $kv.get(CURRENT_GOAL_INDEX_KEY);
  if (currentGoalIndex === SETGOAL_INDEX) {
    return $kv.get(SETGOAL_GOAL_KEY, null);
  } else {
    return $kv.get(GOALS_KEY)[currentGoalIndex];
  }
}

function hasMoreGoals() {
  return $kv.get(CURRENT_GOAL_INDEX_KEY) < $kv.get(GOALS_KEY).length - 1;
}

function resetGoals() {
  $kv.set(CURRENT_GOAL_INDEX_KEY, 0);
  $kv.set(CURRENT_GOAL_TOKENS_RECEIVED_KEY, 0);
}

function updateTipStats(username, isAnon, tokens) {
  username = formatUsername(username, isAnon);
  $kv.set(LAST_TIP_KEY, { username: username, amount: tokens });
  let highTip = $kv.get(HIGHEST_TIP_KEY, null);
  if (!highTip || tokens > highTip.amount) {
    $kv.set(HIGHEST_TIP_KEY, { username: username, amount: tokens });
  }
}

function updateRoomSubject(showGoal = true) {
  let newSubject;
  if (showGoal) {
    newSubject = getGoalText(false);
    if ($settings.greeting) {
      newSubject = $settings.greeting + ' // ' + newSubject;
    }
  } else {
    newSubject = $settings.greeting;
  }
  if ($settings.hashtags) {
    if (newSubject) {
      newSubject += ' // ';
    }
    newSubject += $settings.hashtags;
  }
  console.log('Changing room subject to: ' + newSubject);
  $room.setSubject(newSubject);
}

function formatUsername(username, isAnon) {
  return isAnon ? ANONYMOUS_USER : username.substring(0, 18);
}

function formatTip(tip) {
  return tip ? tip.username + ' (' + tip.amount + ')' : '--'  
}

function getGoalText(includeTokens) {
  let currentGoal = getCurrentGoal();
  let tokensReceived = $kv.get(CURRENT_GOAL_TOKENS_RECEIVED_KEY);
  if ((currentGoal && tokensReceived < currentGoal.amount) || hasMoreGoals()) {
    let goalText = 'Goal: ' + currentGoal.description;
    if (includeTokens) {
      goalText += ' [' + (currentGoal.amount - tokensReceived) + ']';
    }
    return goalText;
  } else {
    if ($kv.get(GOALS_KEY).length === 1) {
      return 'Goal completed!';
    } else {
      return 'All goals completed!';
    }
  }
}

function getRow1Value() {
  return getGoalText(true);
}

function getRow2Value() {
  let currentGoal = getCurrentGoal();
  let tokensReceived = $kv.get(CURRENT_GOAL_TOKENS_RECEIVED_KEY);
  if (tokensReceived >= currentGoal.amount) {
    return 'Thanks to all tippers!';
  }
  let percent = Math.min(100.0 * tokensReceived / currentGoal.amount, 100);
  let fullSlots = Math.floor(PROGRESS_SLOTS * percent / 100.0);
  let partialSlot = tokensReceived > (fullSlots / PROGRESS_SLOTS * currentGoal.amount);
  let emptySlots = PROGRESS_SLOTS - fullSlots - (partialSlot ? 1 : 0);
  let result = '';
  if (fullSlots) {
    result += PROGRESS_SYMBOLS.full.repeat(fullSlots);
  }
  if (partialSlot) {
    result += PROGRESS_SYMBOLS.partial;
  }
  if (emptySlots) {
    result += PROGRESS_SYMBOLS.empty.repeat(emptySlots);
  }
  return result += '• ' + Math.floor(percent) + '%';
}

function getRow3Value() {
  switch ($kv.get(PANEL_UPDATE_COUNTER_KEY) % 2) {
    case 0: // last tip
      return 'Last tip: ' + formatTip($kv.get(LAST_TIP_KEY, null));

    case 1: // highest tip
    default:
      return 'Highest tip: ' + formatTip($kv.get(HIGHEST_TIP_KEY, null));
  }
}

// command handling

const CommandUtils = {

  ERROR_TEXT_COLOUR: 'FireBrick',
  BACKGROUND_COLOUR: 'WhiteSmoke',

  /**
   * Command-handling abstraction.
   * 
   * @param command An object with a 'regex' attribute with the regular expression for the command.
   * @param action A callback function that accepts the regex match result.
   * @return Returns whether the message matched the regex and was therefore handled.
   */
  handleCommand(command, action) {
    let match = $message.orig.match(command.regex);
    if (match) {
      action(match);
      return true;
    }
    return false;
  },

  sendCommandResponse(response) {
    $message.setBody(EMOJI + ' ' + response);
  },

  sendInvalidCommandFormatResponse(command) {
    this.sendCommandErrorResponse('Invalid command format: ' + $message.orig + '\nUsage: ' + command.usage);
  },

  sendNotPermittedResponse(command) {
    this.sendCommandErrorResponse('You do not have permission to execute the ' + command.name + ' command.');
  },

  sendCommandErrorResponse(response) {
    $message.setBody('[' + $app.name + '] ' + response);
    $message.setColor(this.ERROR_TEXT_COLOUR);
  }
};

const ChatMessageTransformCommandHandler = {
  handleCommand() {
    if ($message.orig.startsWith('/')) {
      if (this.handleSkipGoalCommand() ||
        this.handleRestartGoalsCommand() ||
        this.handleSetGoalCommand() ||
        this.handleTestCommand() ||
        this.handleTestAnonCommand()
      ) {
        $message.setSpam(true);
        $message.setBgColor(CommandUtils.BACKGROUND_COLOUR);
        return true;
      }
    }
    return false;
  },
  handleSkipGoalCommand() {
    return CommandUtils.handleCommand(SKIP_GOAL_COMMAND, (match) => {
      if ($user.isOwner) {
        if (match[1]) {
          CommandUtils.sendInvalidCommandFormatResponse(SKIP_GOAL_COMMAND);
        }
      } else {
        CommandUtils.sendNotPermittedResponse(SKIP_GOAL_COMMAND);
      }
    });
  },
  handleRestartGoalsCommand() {
    return CommandUtils.handleCommand(RESET_GOALS_COMMAND, (match) => {
      if ($user.isOwner) {
        if (match[1]) {
          CommandUtils.sendInvalidCommandFormatResponse(RESET_GOALS_COMMAND);
        }
      } else {
        CommandUtils.sendNotPermittedResponse(RESET_GOALS_COMMAND);
      }
    });
  },
  handleSetGoalCommand() {
    return CommandUtils.handleCommand(SET_GOAL_COMMAND, (match) => {
      if ($user.isOwner) {
        if (!match[1] && !match[2]) {
          CommandUtils.sendInvalidCommandFormatResponse(SET_GOAL_COMMAND);
        }
      } else {
        CommandUtils.sendNotPermittedResponse(SET_GOAL_COMMAND);
      }
    });
  },
  handleTestCommand() {
    return CommandUtils.handleCommand(TEST_COMMAND, (match) => {
      if (!isTestbed() && $kv.get(BROADCASTER_KEY) !== APP_AUTHOR) {
        CommandUtils.sendNotPermittedResponse(TEST_COMMAND);
      } else if (!match[2]) {
        CommandUtils.sendInvalidCommandFormatResponse(TEST_COMMAND);
      }
    });
  },
  handleTestAnonCommand() {
    return CommandUtils.handleCommand(TEST_ANON_COMMAND, (match) => {
      if (!isTestbed() && $kv.get(BROADCASTER_KEY) !== APP_AUTHOR) {
        CommandUtils.sendNotPermittedResponse(TEST_ANON_COMMAND);
      } else if (!match[2]) {
        CommandUtils.sendInvalidCommandFormatResponse(TEST_ANON_COMMAND);
      }
    });
  }
};

const ChatMessageCommandHandler = {
  handleCommand() {
    if ($message.orig.startsWith('/')) {
      return this.handleSkipGoalCommand() ||
        this.handleRestartGoalsCommand() ||
        this.handleSetGoalCommand() ||
        this.handleTestCommand() ||
        this.handleTestAnonCommand()
    }
    return false;
  },
  handleSkipGoalCommand() {
    return CommandUtils.handleCommand(SKIP_GOAL_COMMAND, (match) => {
      if ($user.isOwner && !match[1]) {
        if (hasMoreGoals()) {
          prepareForNextGoal();
        }
        startGoal();
      }
    });
  },
  handleRestartGoalsCommand() {
    return CommandUtils.handleCommand(RESET_GOALS_COMMAND, (match) => {
      if ($user.isOwner && !match[1]) {
        resetGoals();
        startGoal();
      }
    });
  },
  handleSetGoalCommand() {
    return CommandUtils.handleCommand(SET_GOAL_COMMAND, (match) => {
      if ($user.isOwner && match[1] && match[2] && !hasMoreGoals()) {
        // TODO
      }
    });
  },
  handleTestCommand() {
    return CommandUtils.handleCommand(TEST_COMMAND, (match) => {
      if ($room.owner === APP_AUTHOR || isTestbed())  {
        let username = match[1];
        if (username === 'me') {
          username = $user.username;
        }
        let tokens = parseInt(match[2]);
        handleTip(username, false, tokens);
      }
    });
  },
  handleTestAnonCommand() {
    return CommandUtils.handleCommand(TEST_ANON_COMMAND, (match) => {
      if ($room.owner === APP_AUTHOR || isTestbed())  {
        let username = match[1];
        if (username === 'me') {
          username = $user.username;
        }
        let tokens = parseInt(match[2]);
        handleTip(username, true, tokens);
      }
    });
  }
};