Chaturbate

Bots Home | Create an App
fefdf
Author: rika_song
Description Source Code Launch Bot Current Users
There is 1 other version of this script.
/* Barrier Battle App                                                ___               _         ___       __  __  __
 *                                                                  / _ )___ _________(_)__ ____/ _ )___ _/ /_/ /_/ /__
 * Let your viewers break down barriers from around your goals.    / _  / _ `/ __/ __/ / -_) __/ _  / _ `/ __/ __/ / -_)
 * - by Unaa.                                                     /____/\_,_/_/ /_/ /_/\__/_/ /____/\_,_/\__/\__/_/\_*/
"use strict";
if (typeof cb === "undefined") { // IDE sanity.
    cb = {};
}

// LIVE
const PANEL_BACKGROUND_IMAGE_1_GOAL = "323d26f3-d892-4efe-9abc-5073a2170566";
const PANEL_BACKGROUND_IMAGE_2_GOAL = "e532b196-72e8-46eb-833f-fe13e8e8c2b4";
const PANEL_BACKGROUND_IMAGE_3_GOAL = "0448ee0f-25ec-4890-aff8-848388ca7051";

class Game
{
    constructor()
    {
        // Initialize services when the game starts.
        Users.init();
        GoalState.init();
        Chat.init();
        Panel.init();

        // Register chat commands to enable listening for these commands and also filter any chat messages where any of
        // these commands have been executed to keep the chat clean. The user executing the command will still be able
        // to see the message in chat.
        Chat.registerChatCommand("class");
        Chat.registerChatCommand("classinfo");
        Chat.registerChatCommand("scores");

        // Send a welcome message to a user that joined the room after the game was started.
        Chat.on("user-joined", (user) => {
            this.sendWelcomeMessage(user);
        });

        // Send a message if a user re-joined the room after leaving during the game.
        Chat.on("user-rejoined", (user) => {
            if (user.userClass) {
                Chat.sendMessageToUser([
                    `Welcome back, ${user.name}! You are currently participating in a game of BARRIER BATTLE and are`,
                    `playing as a ${user.userClass.name}. Get smashin'!`
                ].join(" "), user.name);
            } else {
                this.sendWelcomeMessage(user);
            }
        });

        // Proxy the command to the user instance that executed it.
        Chat.on("command", (user, cmd, args) => user.onCommand(cmd, args));

        // Send intro message to all users that are watching right now.
        this.sendWelcomeMessage();
    }

    sendWelcomeMessage(user)
    {
        let send = (message, color, bgColor, weight) => {
            if (user) {
                Chat.sendMessageToUser(message, user.name, color, bgColor, weight);
            } else {
                Chat.sendMessage(message, color, bgColor, weight);
            }
        };

        if (user) {
            send(`Welcome ${user.name}! We are currently playing BARRIER BATTLE!`, `#ffffff`, `#412C7C`, `bolder`);
        } else {
            send(`----------------[ Lets play BARRIER BATTLE! ]----------------`, `#ffffff`, `#412C7C`, `bolder`);
        }

        Object.keys(Settings.classes).forEach((c) => {
            send(`type "/class ${c}" to play as a ${c}, or "/classinfo ${c}" to see detailed information about this class.`, "#574b73", undefined, "bolder");
        });

        send("", "#fff", "#fff");
        GoalState.goals.forEach((goal) => {
            send(` - Tip ${goal.trigger} tokens to attack the barrier around "${goal.title}".`, "#9b82ba", undefined, "normal");
        });
        send("", "#fff", "#fff");
        send(`If you start tipping for a goal without choosing a class, one will be randomly assigned to you instead.`, "#A33", "#eee", "bold");
        send("", "#fff", "#fff");
        send(`Type "/scores" to show the score board.`, "#78a", undefined);
    }

    /**
     * Returns the intro message for the app.
     *
     * @returns {string}
     */
    getIntroMessage()
    {
        let lines = [];

        lines.push(`Each goal is protected by a barrier! You can help bring down those barriers by tipping the right amount of tokens.`);
        GoalState.goals.forEach((goal) => {
            lines.push([
                ` - Tip ${goal.trigger} tokens to attack the barrier around "${goal.title}".`
            ].join(" "));
        });

        lines.push("");
        lines.push(`In order to help bring the barriers down, you have to assign a class to yourself.`);
        lines.push(`Type "/class" to show the list of available classes to choose from. Make sure you pick one before tipping.`);
        lines.push("");
        lines.push("Some classes may have the ability to sometimes heal a goal that was not targeted by a small amount to keep the competition going.");
        lines.push("You can check out the detailed class description of each class before choosing one.");

        Object.keys(Settings.classes).forEach((className) => {
            lines.push(` - Type "/class ${className}" to assume to role of ${className}. Type "/classinfo ${className}" for detailed statistics about this class.`);
        });

        if (!Settings.allowClassSwitch) {
            lines.push("");
            lines.push("Beware that you may not switch to a different class after you've chosen one.");
        }

        return lines.join("\n");
    }
}

/**
 * Enable binding of event listeners to services that emit events.
 */
class EventEmitter
{
    static get _events()
    {
        if (!EventEmitter.__events) {
            EventEmitter.__events = new Map();
        }
        return EventEmitter.__events;
    }

    constructor()
    {
        this.events = new Map();
    }

    /**
     * Executes the given callback when the specified event is triggered.
     *
     * @param {string}   name
     * @param {function} callback
     */
    on(name, callback)
    {
        if (!this.events.has(name)) {
            this.events.set(name, []);
        }
        this.events.get(name).push(callback);
    }

    /**
     * [STATIC] Executes the given callback when the specified event is triggered.
     *
     * @param {string}   name
     * @param {function} callback
     */
    static on(name, callback)
    {
        if (!EventEmitter._events.has(name)) {
            EventEmitter._events.set(name, []);
        }
        EventEmitter._events.get(name).push(callback);
    }

    /**
     * Emits the given event. Any additional specified arguments will be passed on to the executed listeners.
     *
     * @param {string} name
     * @param {*}      args
     */
    emit(name, ...args)
    {
        if (!this.events.has(name)) {
            return;
        }
        this.events.get(name).forEach((callback) => {
            callback(...args);
        });
    }

    /**
     * [STATIC] Emits the given event. Any additional specified arguments will be passed on to the executed listeners.
     *
     * @param {string} name
     * @param {*}      args
     */
    static emit(name, ...args)
    {
        if (!EventEmitter._events.has(name)) {
            return;
        }
        EventEmitter._events.get(name).forEach((callback) => {
            callback(...args);
        });
    }
}

/**
 * Service class that holds the goal state and defines gameplay logic.
 */
class GoalState extends EventEmitter
{
    static init()
    {
        GoalState.goals = [];
        let index       = 0,
            now         = new Date().getTime() / 1000;

        Settings.goals.forEach((goal) => {
            GoalState.goals.push({
                title:           goal.title,
                trigger:         goal.trigger,
                health:          goal.health,
                maxHealth:       goal.health,
                id:              index,
                reviveTokens:    goal.reviveTokens,
                healInterval:    goal.healInterval,
                healPerInterval: goal.healPerInterval,
                lastHealTick:    now
            });
            index++;
        });

        Users.on("user-tip", (user, amount) => {
            GoalState.handleTip(user, amount);
        });

        GoalState.tickGoalHPI();
    }

    /**
     * Shows a score board detailing which goal has had most attacks and lists
     * all users that attacked that barrier, in order of highest tippers to the lowest.
     */
    static showScoreBoard()
    {
        let users = Users.getParticipants();
        let goals = [];

        GoalState.goals.forEach((goal) => {
            let goalScore = {
                title:     goal.title,
                score:     0,
                attackers: []
            };

            // Collect all users that have participated in this goal.
            users.forEach((user) => {
                if (user.tipScore.has(goal.title)) {
                    goalScore.attackers.push({
                        user:   user,
                        tips:   user.tipScore.get(goal.title),
                        damage: user.damageScore.get(goal.title) || 0
                    });

                    // Add the final score to the goal.
                    goalScore.score += (user.damageScore.get(goal.title) || 0);
                }
            });

            // Sort the attacker list based on most damage done.
            goalScore.attackers.sort((u1, u2) => u2.damage - u1.damage);

            goals.push(goalScore);
        });

        // Sort the goals based on damage done.
        goals.sort((a, b) => b.score - a.score);

        // Print the score board.
        Chat.sendMessage(`-----------[ BARRIER BATTLE SCORE BOARD ]-----------`, '#ffffff', '#48318b', 'normal');
        goals.forEach((goal) => {
            Chat.sendMessage(`[${goal.score}] :: ${goal.title}`, '#59429c', undefined, 'bolder');
            goal.attackers.forEach((attacker) => {
                Chat.sendMessage([
                    ` ----- ${attacker.user.userClass.name} ${attacker.user.name} dealt ${attacker.damage} damage with`,
                    `${attacker.tips} tips.`
                ].join(' '), '#9b5fbf', undefined, 'normal');
            });
        });
        Chat.sendMessage(`------------------------------------------------------------------`, '#ffffff', '#48318b', 'normal');
    }

    /**
     * Handles heal-per-interval for goals that have this enabled.
     */
    static tickGoalHPI()
    {
        let needsUpdate = false,
            now         = new Date().getTime() / 1000;

        this.goals.forEach((goal) => {
            // Make sure we need to tick this goal's health up.
            if (goal.health < 1 || goal.healInterval < 1 || goal.healPerInterval < 1) {
                return;
            }

            if (goal.lastHealTick < now && goal.health < goal.maxHealth) {
                goal.health       = Math.min(goal.maxHealth, goal.health + goal.healPerInterval);
                goal.lastHealTick = now + goal.healInterval;
                needsUpdate       = true;
            }
        });

        if (needsUpdate) {
            Panel.update();
        }

        setTimeout(() => GoalState.tickGoalHPI(), 1000);
    }

    /**
     * Handle tip logic.
     *
     * @param {User}   user
     * @param {number} amount
     */
    static handleTip(user, amount)
    {
        // Check if we can revive a goal barrier.
        let goalWasRevived = false;
        GoalState.goals.forEach((g) => {
            if (g.health === 0 && amount === g.reviveTokens) {
                Chat.sendMessage(`The barrier around "${g.title}" was revived by ${user.name}! BRING IT DOWN!`);
                g.health = Settings.goals[g.id].health;
                Panel.update();
                goalWasRevived = true;
            }
        });
        if (goalWasRevived) {
            return;
        }

        // Find the goal that should be triggered by the given amount of tokens.
        let goal = GoalState.getTriggeredGoal(amount);
        if (!goal) {
            return;
        }

        // Make sure the player has selected a class. If not, select and assign one at random.
        if (!user.userClass) {
            user.assignRandomClass();
            Chat.sendMessageToUser([
                `Thank you for your tip ${user.name}! Since you did not choose a class to play, the`,
                `${user.userClass.name} has been randomly assigned to you.`,
                Settings.allowClassSwitch ? `You can switch classes by typing "/class".` : ``
            ].join(" "), user.name);
        }

        // Store last health so we know what it was before the current user attacks it.
        let lastHealth = goal.health;

        // Let the user attack the selected goal.
        user.attack(goal, amount);

        // Send a message notifying users can revive the defeated goal.
        if (lastHealth !== goal.health && goal.health === 0) {
            if (goal.reviveTokens > 0) {
                Chat.sendMessage(`The barrier around ${goal.title} was already destroyed! However, it may be revived by tipping ${goal.reviveTokens} tokens to play another round!`);
            } else {
                Chat.sendMessage(`The barrier around ${goal.title} was already destroyed! Try another one or wait for the performer to start a new round.`);
            }
        }

        // Let all viewers update the panel.
        Panel.update();
    }

    /**
     * Returns the goal that was triggered by the given amount of tokens.
     *
     * @param {number} amount
     */
    static getTriggeredGoal(amount)
    {
        return GoalState.goals.find((g) => g.trigger === amount);
    }
}

/**
 * Service class for handling app settings.
 */
class Settings
{
    static get DEFAULT_GOAL_NAMES() { return ["A very sexy dance", "Seductive striptease", "Sexy cameltoe tease"]; }

    static get DEFAULT_GOAL_TRIGGERS() { return [15, 16, 17]; }

    static get DEFAULT_CLASS_NAMES() { return ["ranger", "wizard", "hacker"]; }

    static get DEFAULT_CLASS_PRIZES() { return ["Boobies flash", "Kisses", "Booty slap"]; }

    static get DEFAULT_CLASS_ATTACK_SKILLS() { return ["shoots an oak tree with some leaves still attached to it", "waves his magic wand with an utmost majestic motion", "grabs a laptop and starts hitting the keys really hard"]; }

    static get DEFAULT_CLASS_MIN_DMG() { return [15, 25, 20]; }

    static get DEFAULT_CLASS_MAX_DMG() { return [25, 50, 35]; }

    static get DEFAULT_CLASS_CRIT_CHANCE() { return [20, 1, 15]; }

    static get DEFAULT_CLASS_HEAL_CHANCE() { return [8, 0, 5]; }

    static get DEFAULT_CLASS_CRIT_MUL() { return [2, 1, 3]; }

    static get DEFAULT_CLASS_SHARE_BOOST_CHANCE() { return [25, 25, 25]; }

    static get DEFAULT_CLASS_MIN_HEAL() { return [5, 5, 5]; }

    static get DEFAULT_CLASS_MAX_HEAL() { return [10, 10, 10]; }

    static get allowClassSwitch() { return cb.settings.allowClassSwitch === "Yes"; }

    /**
     * Returns an array of configured goals.
     *
     * @returns {Array}
     */
    static get goals()
    {
        let goals = [];

        for (let i = 1; i < 4; i++) {
            if (!cb.settings["goalTitle" + i]) {
                continue;
            }

            goals.push({
                title:           cb.settings["goalTitle" + i],
                trigger:         cb.settings["goalTrigger" + i],
                health:          cb.settings["goalHealth" + i],
                reviveTokens:    cb.settings["goalReviveTokens" + i],
                healInterval:    cb.settings["goalHealInterval" + i],
                healPerInterval: cb.settings["goalHealPerInterval" + i]
            });
        }

        return goals;
    }

    /**
     * Returns a dictionary of user classes indexed by name.
     *
     * @returns {{UserClass}}
     */
    static get classes()
    {
        if (typeof Settings.userClasses !== "undefined") {
            return Settings.userClasses;
        }

        Settings.userClasses = {};

        for (let i = 1; i < 4; i++) {
            let name = cb.settings["className" + i];
            cb.log("GOT CLASS: " + name);

            Settings.userClasses[name] = new UserClass({
                name:             name,
                minDamage:        cb.settings["classMinDamage" + i],
                maxDamage:        cb.settings["classMaxDamage" + i],
                critChance:       cb.settings["classCritChance" + i],
                critMultiplier:   cb.settings["classCritMultiplier" + i],
                critPrize:        cb.settings["classCritPrize" + i],
                healChance:       cb.settings["classHealChance" + i],
                minHeal:          cb.settings["classMinHeal" + i],
                maxHeal:          cb.settings["classMaxHeal" + i],
                shareBoostChance: cb.settings["classBoostShareChance" + i],
                attackSkill:      cb.settings["classAttackSkill" + i]
            });
        }

        return Settings.userClasses;
    }

    /**
     * Returns true if the class with the given name exists.
     *
     * @param {string} className
     * @returns {boolean}
     */
    static classExists(className)
    {
        return typeof Settings.userClasses[className] !== "undefined";
    }

    /**
     * Returns the settings form fields to configure the app.
     *
     * @returns {*[]}
     */
    static renderForm()
    {
        return [
            ...Settings._renderGoalForm(1, true),
            ...Settings._renderGoalForm(2),
            ...Settings._renderGoalForm(3),
            ...Settings._renderBoostForm(),
            ...Settings._renderClassForm(1),
            ...Settings._renderClassForm(2),
            ...Settings._renderClassForm(3)
        ];
    }

    static _renderGoalForm(goalId, required = false)
    {
        return [
            {
                name:         "goalTitle" + goalId,
                label:        "Goal #" + goalId + " prize",
                type:         "str",
                required:     required,
                minLength:    1,
                maxLength:    32,
                defaultValue: Settings.DEFAULT_GOAL_NAMES[goalId - 1]
            }, {
                name:         "goalTrigger" + goalId,
                label:        "Goal #" + goalId + " tip trigger",
                type:         "int",
                required:     required,
                minValue:     1,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_GOAL_TRIGGERS[goalId - 1]
            }, {
                name:         "goalHealth" + goalId,
                label:        "Goal #" + goalId + " total health",
                type:         "int",
                required:     required,
                minValue:     1,
                maxValue:     9999,
                defaultValue: 1000
            }, {
                name:         "goalReviveTokens" + goalId,
                label:        "Goal #" + goalId + " tokens required to start over after defeat (0 = disabled)",
                type:         "int",
                required:     required,
                minValue:     0,
                maxValue:     9999,
                defaultValue: 1000
            }, {
                name:         "goalHealInterval" + goalId,
                label:        "Goal #" + goalId + " auto heal interval in seconds (set to 0 to disable)",
                type:         "int",
                required:     required,
                minValue:     0,
                maxValue:     1000,
                defaultValue: 0
            }, {
                name:         "goalHealPerInterval" + goalId,
                label:        "Goal #" + goalId + " auto heal points per interval (force viewers to keep the tips flowing)",
                type:         "int",
                required:     required,
                minValue:     0,
                maxValue:     1000,
                defaultValue: 1
            }
        ];
    }

    static _renderBoostForm()
    {
        return [
            {
                name:         "boostTokens",
                label:        "Tokens needed for time-based damage boost",
                type:         "int",
                minValue:     1,
                maxValue:     1000,
                defaultValue: 100
            }, {
                name:         "boostMultiplier",
                label:        "Boost damage multiplier",
                type:         "int",
                minValue:     1,
                maxValue:     10,
                defaultValue: 2
            }, {
                name:         "boostTimer",
                label:        "Boost timer (in seconds)",
                type:         "int",
                minValue:     10,
                maxValue:     120,
                defaultValue: 30
            }, {
                name:         "allowClassSwitch",
                label:        "Allow switching classes mid-game",
                type:         "choice",
                choice1:      "No",
                choice2:      "Yes",
                defaultValue: "No"
            }
        ];
    }

    static _renderClassForm(classId)
    {
        return [
            {
                name:         "className" + classId,
                label:        "Class #" + classId + " name (1 word, keep it short)",
                type:         "str",
                minLength:    1,
                maxLength:    32,
                defaultValue: Settings.DEFAULT_CLASS_NAMES[classId - 1]
            }, {
                name:         "classCritPrize" + classId,
                label:        "Class #" + classId + " critical hit prize",
                type:         "str",
                minLength:    1,
                maxLength:    128,
                defaultValue: Settings.DEFAULT_CLASS_PRIZES[classId - 1]
            }, {
                name:         "classAttackSkill" + classId,
                label:        "Class #" + classId + " attack text",
                type:         "str",
                minLength:    1,
                maxLength:    128,
                defaultValue: Settings.DEFAULT_CLASS_ATTACK_SKILLS[classId - 1]
            }, {
                name:         "classMinDamage" + classId,
                label:        "Class #" + classId + " min damage points",
                type:         "int",
                minValue:     1,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_CLASS_MIN_DMG[classId - 1]
            }, {
                name:         "classMaxDamage" + classId,
                label:        "Class #" + classId + " max damage points",
                type:         "int",
                minValue:     1,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_CLASS_MAX_DMG[classId - 1]
            }, {
                name:         "classCritChance" + classId,
                label:        "Class #" + classId + " chance to critically hit (percent)",
                type:         "int",
                minValue:     0,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_CLASS_CRIT_CHANCE[classId - 1]
            }, {
                name:         "classCritMultiplier" + classId,
                label:        "Class #" + classId + " critical hit multiplier",
                type:         "int",
                minValue:     1,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_CLASS_CRIT_MUL[classId - 1]
            }, {
                name:         "classHealChance" + classId,
                label:        "Class #" + classId + " chance to heal a goal (percent - 0~50)",
                type:         "int",
                minValue:     0,
                maxValue:     50,
                defaultValue: Settings.DEFAULT_CLASS_HEAL_CHANCE[classId - 1]
            }, {
                name:         "classMinHeal" + classId,
                label:        "Class #" + classId + " min heal points",
                type:         "int",
                minValue:     0,
                maxValue:     50,
                defaultValue: Settings.DEFAULT_CLASS_MIN_HEAL[classId - 1]
            }, {
                name:         "classMaxHeal" + classId,
                label:        "Class #" + classId + " max heal points",
                type:         "int",
                minValue:     0,
                maxValue:     50,
                defaultValue: Settings.DEFAULT_CLASS_MAX_HEAL[classId - 1]
            }, {
                name:         "classBoostShareChance" + classId,
                label:        "Class #" + classId + " chance to share boost with another participant (percent)",
                type:         "int",
                minValue:     1,
                maxValue:     100,
                defaultValue: Settings.DEFAULT_CLASS_SHARE_BOOST_CHANCE[classId - 1]
            }
        ];
    }
}

/**
 * Service class for rendering the panel.
 */
class Panel
{
    static init()
    {
        cb.onDrawPanel(() => Panel.getPanelData());
        Panel.update();
    }

    static update()
    {
        cb.drawPanel();
    }

    /**
     * Returns the data to draw the panel below the cam frame.
     *
     * @returns {{}}
     */
    static getPanelData()
    {
        if (GoalState.goals.length === 1) {
            return Panel.renderOneGoalPanel();
        }
        if (GoalState.goals.length === 2) {
            return Panel.renderTwoGoalsPanel();
        }
        if (GoalState.goals.length === 3) {
            return Panel.renderThreeGoalsPanel();
        }
    }

    /**
     * Renders the panel that shows one configured goal.
     *
     * @returns {{template: string, layers: *[]}}
     */
    static renderOneGoalPanel()
    {
        let layers = [...Panel.renderGoal(GoalState.goals[0], 26)];

        return {
            "template": "image_template",
            "layers":   [
                {"type": "image", "fileID": PANEL_BACKGROUND_IMAGE_1_GOAL},
                ...layers
            ]
        };
    }

    /**
     * Renders the panel that shows two configured goals.
     *
     * @returns {{template: string, layers: *[]}}
     */
    static renderTwoGoalsPanel()
    {
        let layers = [
            ...Panel.renderGoal(GoalState.goals[0], 14),
            ...Panel.renderGoal(GoalState.goals[1], 37)
        ];

        return {
            "template": "image_template",
            "layers":   [
                {"type": "image", "fileID": PANEL_BACKGROUND_IMAGE_2_GOAL},
                ...layers
            ]
        };
    }

    /**
     * Renders the panel that shows three configured goals.
     *
     * @returns {{template: string, layers: *[]}}
     */
    static renderThreeGoalsPanel()
    {
        let layers = [
            ...Panel.renderGoal(GoalState.goals[0], 4),
            ...Panel.renderGoal(GoalState.goals[1], 26),
            ...Panel.renderGoal(GoalState.goals[2], 48)
        ];

        return {
            "template": "image_template",
            "layers":   [
                {"type": "image", "fileID": PANEL_BACKGROUND_IMAGE_3_GOAL},
                ...layers
            ]
        };
    }

    /**
     * Returns the layers for the given goal.
     *
     * @param {Object<*>} goal
     * @param {number}    top
     * @returns {*[]}
     */
    static renderGoal(goal, top)
    {
        return [
            {
                "type":        "text",
                "top":         top,
                "left":        5,
                "text":        goal.title + " (" + goal.trigger + " tks)",
                "font-size":   12,
                "font-family": "Monotype Corsiva, Comic Sans MS, cursive",
                "color":       goal.health > 0 ? "#e2beff" : "#ffffff",
                "max-width":   190
            }, {
                "type":        "text",
                "text":        goal.health > 0 ? (goal.health + " hp") : "DONE!",
                "top":         top,
                "left":        205,
                "font-family": "Monotype Corsiva, Comic Sans MS, cursive",
                "font-size":   12,
                "max-width":   66,
                "color":       goal.health > 0 ? "#e2beff" : "#ffffff"
            }
        ];
    }
}

/**
 * Service class for the Chat API.
 */
class Chat extends EventEmitter
{
    static init()
    {
        Chat.commandNames = [];
        cb.onMessage((msg) => Chat._handleMessage(msg));
    }

    /**
     * Registers a chat command.
     *
     * This allows events to be emitted for the given command and will also hide any chat messages from users executing
     * these commands to keep the chat clean.
     *
     * @param command
     */
    static registerChatCommand(command)
    {
        if (!Chat.commandNames) {
            Chat.commandNames = [];
        }

        Chat.commandNames.push(command);
    }

    /**
     * Sends a message to the given recipient. If the recipient is omitted, the message is broadcast to all users in
     * the general chat.
     *
     * @param {string} message
     * @param {string} color
     * @param {string} backgroundColor
     * @param {string} weight
     * @param {string} recipient
     */
    static sendMessage(message, color = "#57219C", backgroundColor = undefined, weight = "bold", recipient = undefined)
    {
        cb.sendNotice(message, recipient, backgroundColor, color, weight);
    }

    /**
     * Alias for sendMessage but with easier access to the recipient argument.
     *
     * @param {string} message
     * @param {string} color
     * @param {string} backgroundColor
     * @param {string} weight
     * @param {string} recipient
     */
    static sendMessageToUser(message, recipient, color = "#4721CC", backgroundColor = undefined, weight = "bold")
    {
        Chat.sendMessage(message, color, backgroundColor, weight, recipient);
    }

    /**
     * Handles incoming chat messages.
     *
     * @param {*} msg
     * @private
     */
    static _handleMessage(msg)
    {
        let user = Users.get(msg.user, msg);

        if (msg.m.startsWith("/")) {
            msg["background"] = "#FFF";
            msg["color"]      = "#aaa";
            if (Chat._handleCommand(user, msg.m)) {
                msg["X-Spam"] = true;
            }
        }

        if (user.userClass) {
            msg.user = user.userClass.name + " " + msg.user;
        }

        return msg;
    }

    /**
     * Emits the "command" event if the user executed a command that was properly formatted.
     *
     * @param {User}   user
     * @param {string} message
     * @private
     */
    static _handleCommand(user, message)
    {
        // Grab the command from the chat in the format of '/command [optional args]'.
        let m = /^\/(\w+)\s?(.+)?$/.exec(message);

        // Make sure the chat command is properly formatted.
        if (!m || m.length !== 3) {
            return false;
        }

        let command = m[1],
            args    = m[2] || "";

        if (Chat.commandNames.indexOf(command) !== -1) {
            Chat.emit("command", user, command, args);
            return true;
        }

        return false;
    }
}

/**
 * Service class for managing users.
 */
class Users extends EventEmitter
{
    static init()
    {
        Users.users = new Map();

        cb.onEnter((u) => {
            if (Users.users.has(u.user)) {
                // Update the user.
                Users.users.get(u.user).update(u);
                Users.emit("user-rejoined", Users.users.get(u.user));
            } else {
                let user = new User(u);
                Users.users.set(u.user, user);
                Users.emit("user-joined", user);
            }
        });

        cb.onLeave((u) => {
            Users.emit("user-left", Users.users.get(u.user));
            // Users.users.delete(u.user); // @FIXME: Make this configurable?
        });

        cb.onTip((tip) => {
            let amount = tip.amount,
                user   = Users.get(tip.from_user, {
                    user:       tip.from_user,
                    gender:     tip.from_user_gender,
                    has_tokens: tip.from_user_has_tokens,
                    in_fanclub: tip.from_user_in_fanclub,
                    is_mod:     tip.from_user_is_mod
                });

            user.onTip(amount);
            this.emit("user-tip", user, amount);
        });
    }

    /**
     * Returns a User instance from the player pool.
     *
     * @param {string} username
     * @param {object} userData
     * @returns {User}
     */
    static get(username, userData)
    {
        if (Users.users.has(username) === false) {
            Users.users.set(username, new User(userData));
        }

        return Users.users.get(username);
    }

    /**
     * Returns all participants that have assigned a class and have tipped at least once.
     */
    static getParticipants()
    {
        let p = [];
        Users.users.forEach((u) => {
            if (u.userClass && u.damageScore.size > 0 && u.tipScore.size > 0) {
                p.push(u);
            }
        });

        return p;
    }

    /**
     * Picks a random user that is not the given user.
     *
     * @param {User} forUser
     */
    static getRandomUserForUser(forUser)
    {
        let u = Array.from(this.users.keys()),
            i = 0;

        if (u.length === 1) {
            return;
        }

        let user;
        do {
            user = u[Math.floor(Math.random() * u.length) - 1];
            cb.log('RAND: ' + user);
            i++;
        } while (i < 10 && !(user && user !== forUser.name && this.users.get(user).userClass));

        if (!user || user === forUser.name || ! this.users.get(user).userClass) {
            return;
        }

        return Users.users.get(user);
    }
}

class User
{
    constructor(u)
    {
        cb.log("New user added to the pool: " + u.user + " (" + u.gender + ")");

        this.isTicking   = false;
        this.userClass   = undefined;
        this.boostTimer  = 0;
        this.tipScore    = new Map();
        this.damageScore = new Map();

        this.update(u);
    }

    /**
     * Updates the user data.
     *
     * @param {object} data
     */
    update(data)
    {
        this.name            = data.user;
        this.gender          = data.gender;
        this.hasTokens       = data.has_tokens;
        this.isFanclubMember = data.in_fanclub;
        this.isModerator     = data.is_mod;
    }

    /**
     * Assign a random class to this user if it did not choose one yet.
     */
    assignRandomClass()
    {
        // Don't overwrite if the user already made a choice.
        if (this.userClass) {
            return;
        }

        let names     = Object.keys(Settings.classes),
            className = names[Math.floor(Math.random() * names.length)];

        this.userClass = Settings.classes[className];
        Chat.sendMessage(`${this.name} has assumed the role of ${this.userClass.name}!`);
    }

    /**
     * Executed every second to keep track of timers.
     */
    tick()
    {
        let now = new Date().getTime() / 1000;

        if (this.isBoosted && this.boostTimer <= now) {
            Chat.sendMessage([
                `${this.name}'s boost just ran out, but ${this.gender === "m" ? "he" : "she"} can reapply one by tipping`,
                `${cb.settings.boostTokens} tokens. Get down those barriers!`
            ].join(" "));
            this.isTicking = false;
            return;
        }

        this.isBoosted = this.boostTimer > now;
        setTimeout(() => this.tick(), 1000);
    }

    /**
     * Attacks the given goal.
     *
     * @param {*}      goal
     * @param {number} tipAmount
     */
    attack(goal, tipAmount)
    {
        if (!this.userClass) {
            return;
        }

        if (!this.tipScore.has(goal.title)) {
            this.tipScore.set(goal.title, 0);
        }
        this.tipScore.set(goal.title, this.tipScore.get(goal.title) + tipAmount);

        // If the goal was already achieved, let the user know that it can be revived (if applicable).
        if (goal.health === 0) {
            if (goal.reviveTokens > 0) {
                Chat.sendMessageToUser(
                    `The barrier around "${goal.title}" is already down. You can revive it by tipping ${goal.reviveTokens} tokens.`,
                    this.name
                );
            }
            return;
        }

        let damage     = Math.round(this.userClass.minDamage + (Math.random() * (this.userClass.maxDamage - this.userClass.minDamage)));
        let isCritical = (Math.random() * 100 <= this.userClass.critChance);
        let message    = [`${this.userClass.name} ${this.name} ${this.userClass.attackSkill}`];
        let heShe      = this.gender === "m" ? "he" : (this.gender === "f" ? "she" : "has");

        // Modify damage based on boost status & critical hit.
        damage = this.isBoosted ? damage * cb.settings.boostMultiplier : damage;
        damage = isCritical ? damage * this.userClass.critMultiplier : damage;

        // Apply damage to goal.
        goal.health = Math.max(0, goal.health - damage);

        // Compose the rest of the chat message.
        if (goal.health > 0) {
            if (isCritical) {
                message.push(`and deals a critical strike of ${damage} damage points on the barrier around "${goal.title}"!`);
                message.push(`With that ${heShe} earned ${this.userClass.critPrize}!`);
            } else {
                message.push(`and deals ${damage} damage points on the barrier around "${goal.title}"!`);
            }

            Chat.sendMessage(message.join(" "), "#7741AC", undefined, "normal");
        } else {
            if (isCritical) {
                message = [
                    `${this.name.toUpperCase()} ${this.userClass.attackSkill.toUpperCase()} AND DEALT A DEVASTATING`,
                    `FINAL BLOW ON THE BARRIER OF "${goal.title}" WITH A CRITICAL STRIKE OF ${damage} DAMAGE POINTS!`
                ];
            } else {
                message = [
                    `${this.name.toUpperCase()} ${this.userClass.attackSkill.toUpperCase()} AND DEALT THE FINAL BLOW`,
                    `ON THE BARRIER OF "${goal.title}" WITH ${damage} DAMAGE POINTS!`
                ];
            }

            Chat.sendMessage(message.join(" "), "#ffffff", "#57219c", "bolder");
        }

        if (!this.damageScore.has(goal.title)) {
            this.damageScore.set(goal.title, 0);
        }
        this.damageScore.set(goal.title, this.damageScore.get(goal.title) + damage);

        // Check if we can heal another goal barrier.
        let doHeal = GoalState.goals.length > 1 && (Math.random() * 100) <= this.userClass.healChance;
        if (!doHeal) {
            return;
        }

        let healPoints         = Math.round(this.userClass.minHeal + (Math.random() * (this.userClass.maxHeal - this.userClass.minHeal)));
        let hGoal, maxAttempts = 0;

        do {
            hGoal = GoalState.goals[Math.round(Math.random() * GoalState.goals.length)];
            maxAttempts++;
        } while (maxAttempts < 10 && (!hGoal || hGoal === goal || hGoal.health === 0));

        // Check if we found a qualified goal that we can heal up a bit.
        if (!(hGoal && hGoal !== goal && hGoal.health > 0)) {
            return;
        }

        // Don't attempt to heal if it's already at full health.
        if (hGoal.health === Settings.goals[hGoal.id].health) {
            return;
        }

        hGoal.health = Math.min(Settings.goals[hGoal.id].health, hGoal.health + healPoints);
        Chat.sendMessage(
            `${this.name} has healed the barrier around "${hGoal.title}" by ${healPoints} points.`,
            "#218C22", undefined, "normal"
        );
    }

    /**
     * Applies a boost to this user.
     */
    applyBoost(giftedFrom)
    {
        let now    = new Date().getTime() / 1000;
        let hisHer = this.gender === "m" ? "his" : (this.gender === "f" ? "her" : "the");
        let su,
            shareWith;

        // Roll the dice - but only if this boost was not gifted from somebody else. Can't have a chain reaction going
        // on by tipping for one boost...let along having a chance of recursion happening :')
        if (!giftedFrom && ((Math.random() * 100) < this.userClass.shareBoostChance)) {
            shareWith = Users.getRandomUserForUser(this);
        }

        if (this.boostTimer > now) {
            this.boostTimer = this.boostTimer + cb.settings.boostTimer;
            // Notify a 'gifted from' message if this boost was a gift.
            if (giftedFrom) {
                return Chat.sendMessage(`${this.name} got ${hisHer} boost timer extended by a gift from ${giftedFrom.name}!`);
            }

            // Notify on chat that this user extended the boost timer.
            Chat.sendMessage([
                `${this.name} has extended ${hisHer} boost timer with ${cb.settings.boostTimer} seconds`,
                shareWith ? ` and gave a free boost to ${shareWith.name} as well!` : `!`
            ].join(""));

            if (shareWith) {
                shareWith.applyBoost(this);
            }
            return;
        }

        this.boostTimer = now + cb.settings.boostTimer;

        if (!this.isTicking) {
            this.isTicking = true;
            this.tick();
        }

        if (giftedFrom) {
            Chat.sendMessage(`${this.name} activated a boost that was gifted by ${giftedFrom.name}! Let's rumble!`);
        } else {
            Chat.sendMessage([
                `${this.name} has applied a boost for ${cb.settings.boostTimer} seconds`,
                shareWith ? ` and gave a free boost to ${shareWith.name} as well!` : `!`
            ].join(""));
        }

        if (shareWith) {
            shareWith.applyBoost(this);
        }
    }

    /**
     * Executed when this user tipped some tokens.
     *
     * @param {number} amount
     */
    onTip(amount)
    {
        if (amount === cb.settings.boostTokens) {
            if (! this.userClass) {
                this.assignRandomClass();
            }
            this.applyBoost();
        }
    }

    /**
     * Executed when this user executes a command in chat.
     *
     * @param {string} command
     * @param {string} args
     */
    onCommand(command, args)
    {
        switch (command) {
            case "scores":
                GoalState.showScoreBoard();
                break;
            // Send class information about the given class to this user.
            case "classinfo":
                if (!args || args === "") {
                    return Chat.sendMessageToUser([
                        `Please specify a class name to see the detailed statistics of. You can choose from the following: `,
                        Object.keys(Settings.classes).join(", ")
                    ].join(" "), this.name);
                }
                if (!Settings.classExists(args)) {
                    return Chat.sendMessageToUser([
                        `I'm sorry ${this.name}, but that class does not exist. Type "/class" to see a list of`,
                        `available classes to choose from.`
                    ].join(" "), this.name);
                }
                return Chat.sendMessageToUser(Settings.classes[args].getDetailsMessage(), this.name);

            // Select the class for this user.
            case "class":
                // If no arguments were given, show the list of available classes.
                if (!args || args.length === 0) {
                    let lines = [];
                    Object.keys(Settings.classes).forEach((className) => {
                        lines.push([
                            `Type "/class ${className}" to assume to role of ${className}. Type "/classinfo`,
                            `${className}" for detailed statistics about this class.`
                        ].join(" "));
                    });
                    Chat.sendMessageToUser(lines.join("\n"), this.name);
                    return;
                }

                // Don't allow switching to another class mid-game if the broadcaster does not permit it.
                if (!Settings.allowClassSwitch && typeof this.userClass !== "undefined") {
                    return Chat.sendMessageToUser(
                        `I'm sorry ${this.name}, but you are only allowed to choose a class once per game.`,
                        this.name
                    );
                }

                // Make sure the selected class exists.
                if (!Settings.classExists(args)) {
                    return Chat.sendMessageToUser([
                        `I'm sorry ${this.name}, but that class does not exist. Type "/class" to see a list of`,
                        `available classes to choose from.`
                    ].join(" "), this.name);
                }

                this.userClass = Settings.classes[args];
                Chat.sendMessage(`${this.name} has assumed the role of ${this.userClass.name}!`);
                break;
        }
    }
}

/**
 * Represents the selected class for a user.
 */
class UserClass
{
    constructor(options)
    {
        this.name             = options.name;
        this.minDamage        = options.minDamage;
        this.maxDamage        = options.maxDamage;
        this.critChance       = options.critChance;
        this.critMultiplier   = options.critMultiplier;
        this.critPrize        = options.critPrize;
        this.healChance       = options.healChance;
        this.minHeal          = options.minHeal;
        this.maxHeal          = options.maxHeal;
        this.shareBoostChance = options.shareBoostChance;
        this.attackSkill      = options.attackSkill || "attacks";
    }

    /**
     * Returns the detailed statistics message for this class.
     *
     * @returns {string}
     */
    getDetailsMessage()
    {
        let message = [
            `The ${this.name} class ${this.attackSkill} and may deal between ${this.minDamage} and ${this.maxDamage}`,
            `points of damage.\n`
        ];

        if (this.critChance > 0 && this.critMultiplier > 1) {
            message.push(...[
                `There is a ${this.critChance}% chance that an attack will result in a critical hit. If this happens`,
                `the damage done may range between ${this.minDamage * this.critMultiplier} and `,
                `${this.maxDamage * this.critMultiplier}. You will be rewarded with the prize: "${this.critPrize}".`
            ]);
        }

        if (this.healChance > 0) {
            message.push(...[
                `\n`,
                `This class has a ${this.healChance}% chance to heal a different goal than the one that was targeted`,
                `last by ${this.minHeal}~${this.maxHeal} points.`
            ]);
        }

        message.push(...[
            `\nYou may apply a boost to yourself by tipping ${cb.settings.boostTokens} tokens to increase your base damage`,
            `to ${this.minDamage * cb.settings.boostMultiplier}~${this.maxDamage * cb.settings.boostMultiplier} points.`,
            `A boost will last for ${cb.settings.boostTimer} seconds.`
        ]);
        if (this.shareBoostChance > 0) {
            message.push(...[
                `There is also a ${this.shareBoostChance}% chance of you sharing your boost with another player!`
            ]);
        }

        return message.join(" ");
    }
}

// ------------------------------------------------------------------------------------------------------------------ //

// Render the settings form for the app.
cb.settings_choices = Settings.renderForm();

// Run the game.
new Game();