Freesexcam - Free Sex Cam

Apps Home | Create an App
Easy Hidden Room
Author: lolteachz
You are viewing version 1139230. There is a newer version of this app. See the latest version of this app.

Description Source Code Launch App Current Users
There are 12 other versions of this script.
/** Code by Lolteachz 2020 */
/** ------------------------------------------------------------------------------ */
/**
 *  Valid commands
 *  /start [users]  - Start the limited broadcast with optional comma separated users
 *  /stop           - Stop the limited broadcast
 *  /add [users]    - Add a comma separated set of usernames to the broadcast
 *  /remove [users] - Remove a comma separated set of usernames from the broadcast
 *  /reset          - Removes all users and stops limiting
 *  /status         - Output the current status
 */
const commands = ['/start', '/stop', '/add', '/remove', '/reset', '/status', '/clear'];

// This needed to stop the autostart from occuring when the broadcast hasnt started
// The limit cam functions dont throw error and mark as limiting when not broadcasting 
// but in reality they dont actually work so it ruins everything. We need this variable to control
let isBroadcasting = false;

// The awesome settings for the app
cb.settings_choices = [
  {
    name: 'cam_message',
    label: 'Cam Message (when hidden)',
    type: 'str',
    minLength: 1,
    maxLength: 256,
    defaultValue: 'This room is private',
  },
  {
    name: 'auto_start',
    label: 'Automatically Hidden',
    type: 'choice',
    choice1: 'Yes',
    choice2: 'No',
    defaultValue: 'Yes',
  },
  {
    name: 'colourize_enter',
    label: 'Colourize Whitelisted Entries',
    type: 'choice',
    choice1: 'Yes',
    choice2: 'No',
    defaultValue: 'Yes',
  },
  {
    name: 'colourize_messages',
    label: 'Colourize Whitelisted Messages',
    type: 'choice',
    choice1: 'Yes',
    choice2: 'No',
    defaultValue: 'No',
  },
  {
    name: 'pm_only',
    label: 'Blocks Chat and Requests PM only',
    type: 'choice',
    choice1: 'Yes',
    choice2: 'No',
    defaultValue: 'No',
  },
];

// Just simplify lame message stuff back to broadcaster
const sendNotice = (text, args, bg) => {
  const message = `${text}${args ? args.join(', ') : ''}`;
  cb.sendNotice(message, cb.room_slug, bg, null, 'bold');
};

// Check if is broadcaster (message) => bool
const isBroadcaster = ({ user }) => cb.room_slug === user;

// Check if message is a command
const isCommand = ({ m: text }) => commands.some((cmd) => text.startsWith(cmd));

const hasAccess = ({ user }) => cbjs.arrayContains(cb.limitCam_allUsersWithAccess(), user);

// Output the current status, running, users etc
const status = () => {
  cb.log('Outputting status');
  sendNotice(`Limit Running:  ${cb.limitCam_isRunning() ? 'Yes' : 'No'}`);
  sendNotice(
    `Has Access:  ${cb.limitCam_allUsersWithAccess().join(', ') || 'No Users'}`
  );
};

// Just delay helper, the async notices annoyed me
const delay = (fn, ms = 500) => {
  const id = cb.setTimeout(() => {
    fn();
    cb.cancelTimeout(id);
  }, ms);
}

// Split arguments from commands
const parseCommand = ({ m: text }) => {
  // Get the command part
  const command = text.split(' ')[0].trim();

  // Get the args
  const args = text
    .replace(/^\/[a-z]+ ?/gi, '')
    .split(',')
    .map((token) => token.trim())
    .filter(Boolean);

  cb.log(`Parsing command: ${command}\t args: ${args}`);
  return { command: command.trim(), args };
};

// Start limiting
const start = (usernames) => {
  sendNotice('------ Starting ------');

  delay(() => {
    cb.limitCam_start(cb.settings.cam_message, usernames);
    isBroadcasting = true;
    status();
  });
};

// Stop limiting
const stop = () => {
  sendNotice('------ Stopping ------');

  delay(() => {
    cb.limitCam_stop();
    isBroadcasting = false;
    status();
  });
};

// Add allowed usernames
const add = (usernames) => {
  cb.limitCam_addUsers(usernames);
  sendNotice('Added ', usernames);
};

// Remove allowed usernames
const remove = (usernames) => {
  cb.limitCam_removeUsers(usernames);
  sendNotice('Removed ', usernames);
};

// Remove allowed usernames
const clear = () => {
  cb.limitCam_removeAllUsers();
  sendNotice('Users cleared');
};

// Reset limiting state, similar to stop but removes all access
const reset = () => {
  cb.limitCam_removeAllUsers();
  stop();
};

// Process a command
const processCommand = ({ command, args = [] }) => {
  cb.log(`Processing command ${command}, ${args}`);
  switch (command) {
    case '/start':
      return start(args);
    case '/stop':
      return stop();
    case '/add':
      return add(args);
    case '/remove':
      return remove(args);
    case '/reset':
      return reset();
    case '/status':
      return status();
    case '/clear':
      return clear();
  }
};

const colourizeMessage = (message) =>
  hasAccess(message)
    ? Object.assign(message, {
        background: '#7efcbd',
      })
    : message;

const colourizeEntry = ({ user }) => {
  cb.log(`Checking ${user} ${hasAccess({ user })}`);
  if (cb.settings.colourize_enter === 'Yes' && hasAccess({ user })) {
    sendNotice(`User '${user}' JOINED`, null, '#7efcbd');
  }
}

// In PM only mode chat is disabled and the user gets a notification to let them know
// that they can only use the PM tab to communicate
const pmOnly = (message) => {
  if (cb.settings.pm_only === 'No') return message;

  cb.sendNotice(
    `PM ONLY - Your message was not sent and is not visible to other users, use the PM tab`,
    message.user,
    '#f78888',
    null,
    'bolder'
  );

  return Object.assign(message, { 'X-Spam': true });
}

// Handle a given message
const handleMessage = (message) => {
  if (!isCommand(message)) return pmOnly(cb.settings.colourize_messages === 'Yes' ? colourizeMessage(message) : message);
  if (!isBroadcaster(message)) return message; // Exit handler if its a command and not the broadcaster

  // Process commands
  processCommand(parseCommand(message));

  // Return as spam to remove the command from display
  return Object.assign(message, { 'X-Spam': true });
};

const autostart = () => {
  if (cb.settings.auto_start === 'No' || !isBroadcasting) return;

  start();
}

const autostop = () => cb.limitCam_isRunning() && stop();

// CB Handlers
cb.onMessage(handleMessage);
cb.onEnter(colourizeEntry);
cb.onStart(autostart);
cb.onBroadcastStart(() => {
  isBroadcasting = true; // See variable comment at top ^
  autostart();
});
cb.onBroadcastStop(() => {
  isBroadcasting = false;
  autostart();
});