monks-tokenbar.js

import { registerSettings } from "./settings.js";
import { TokenBar } from "./apps/tokenbar.js";
import { AssignXP, AssignXPApp } from "./apps/assignxp.js";
import { SavingThrow, SavingThrowApp } from "./apps/savingthrow.js";
import { ContestedRoll } from "./apps/contestedroll.js";
import { LootablesApp } from "./apps/lootables.js";
import { MonksTokenBarAPI } from "./monks-tokenbar-api.js";

import { BaseRolls } from "./systems/base-rolls.js";
import { DnD5eRolls } from "./systems/dnd5e-rolls.js";
import { DnD4eRolls } from "./systems/dnd4e-rolls.js";
import { D35eRolls } from "./systems/d35e-rolls.js";
import { PF1Rolls } from "./systems/pf1-rolls.js";
import { PF2eRolls } from "./systems/pf2e-rolls.js";
import { Tormenta20Rolls } from "./systems/tormenta20-rolls.js";
import { OSERolls } from "./systems/ose-rolls.js";
import { SFRPGRolls } from "./systems/sfrpg-rolls.js";
import { SwadeRolls } from "./systems/swade-rolls.js";
import { SW5eRolls } from "./systems/sw5e-rolls.js";
import { CoC7Rolls } from "./systems/coc7-rolls.js";

export let debug = (...args) => {
    if (debugEnabled > 1) console.log("DEBUG: monks-tokenbar | ", ...args);
};
export let log = (...args) => console.log("monks-tokenbar | ", ...args);
export let warn = (...args) => {
    if (debugEnabled > 0) console.warn("monks-tokenbar | ", ...args);
};
export let error = (...args) => console.error("monks-tokenbar | ", ...args);
export let i18n = key => {
    return game.i18n.localize(key);
};
export let setting = key => {
    return game.settings.get("monks-tokenbar", key);
};

export const MTB_MOVEMENT_TYPE = {
    FREE: 'free',
    NONE: 'none',
    COMBAT: 'combat'
}

/*
export let manageTokenControl = (token, isShiftPressed) => {
    if (!token) return;

    const options = { releaseOthers: !isShiftPressed };
    const testControl = token._controlled && isShiftPressed;
    testControl ? token.release(options) : token.control(options);
}*/

export class MonksTokenBar {
    static tracker = false;
    static tokenbar = null;

    static init() {
	    log("initializing");
        // element statics
        //CONFIG.debug.hooks = true;

        MonksTokenBar.SOCKET = "module.monks-tokenbar";

        registerSettings();

        if (setting('stats') == undefined) {
            //check and see if the user has selected something other than the default
            if (setting('stat1-icon') != undefined || setting('stat1-resource') != undefined || setting('stat2-icon') != undefined || setting('stat2-resource') != undefined) {
                let oldstats = {};
                if (setting('stat1-resource') != undefined)
                    oldstats[setting('stat1-resource')] = setting('stat1-icon');
                if (setting('stat2-resource') != undefined)
                    oldstats[setting('stat2-resource')] = setting('stat2-icon');
                game.settings.set('monks-tokenbar', 'stats', oldstats);
            }
        }

        let canDrag = function (wrapped, ...args) {
            let result = wrapped(...args);
            return (MonksTokenBar.allowMovement(this, false) ? result : false);
        }

        if (game.modules.get("lib-wrapper")?.active) {
            libWrapper.register("monks-tokenbar", "Token.prototype._canDrag", canDrag, "WRAPPER");
        } else {
            const oldCanDrag = Token.prototype._canDrag;
            Token.prototype._canDrag = function (event) {
                return canDrag.call(this, oldCanDrag.bind(this), ...arguments);
            }
        }

        let oldView = Scene.prototype.view;
        Scene.prototype.view = async function () {
            if (MonksTokenBar.tokenbar) {
                MonksTokenBar.tokenbar.tokens = [];
                MonksTokenBar.tokenbar.render(true);
            }
            return oldView.call(this);
        }

    }

    static async chatCardAction(event) {
        if (!setting('capture-savingthrows'))
            return;

        let _getChatCardActor = async function(card) {
            // Case 1 - a synthetic actor from a Token
            if (card.dataset.tokenId) {
                const token = await fromUuid(card.dataset.tokenId);
                if (!token) return null;
                return token.actor;
            }

            // Case 2 - use Actor ID directory
            const actorId = card.dataset.actorId;
            return game.actors.get(actorId) || null;
        }

        let _getChatCardTargets = function(card) {
            let targets = canvas.tokens.controlled.filter(t => !!t.actor);
            if (!targets.length && game.user.character) targets = targets.concat(game.user.character.getActiveTokens());
            if (!targets.length) ui.notifications.warn(game.i18n.localize("DND5E.ActionWarningNoToken"));
            return targets;
        }

        // Extract card data
        const button = event.currentTarget;
        const card = button.closest(".chat-card");
        const messageId = card.closest(".message").dataset.messageId;
        const message = game.messages.get(messageId);
        const action = button.dataset.action;

        if (action === 'save') {
            if (!(game.user.isGM || message.isAuthor)) return;

            const actor = await _getChatCardActor(card);
            if (!actor) return;

            const storedData = message.getFlag("dnd5e", "itemData");
            const item = storedData ? new this(storedData, { parent: actor }) : actor.items.get(card.dataset.itemId);

            const targets = _getChatCardTargets(card);
            if (targets.length) {
                let savingthrow = new SavingThrowApp(targets, { request: 'save:' + button.dataset.ability, dc: item.data.data.save.dc });
                savingthrow.requestRoll();

                event.preventDefault();
                event.stopImmediatePropagation();
                return;
            }
        }
    }

    static get stats() {
        return setting('stats') || MonksTokenBar.system.defaultStats;
    }

    static ready() {
        game.socket.on(MonksTokenBar.SOCKET, MonksTokenBar.onMessage);

        MonksTokenBar.system = new BaseRolls();
        switch (game.system.id.toLowerCase()) {
            case 'dnd5e':
                MonksTokenBar.system = new DnD5eRolls(); break;
            case 'sw5e':
                MonksTokenBar.system = new SW5eRolls(); break;
            case 'd35e':
                MonksTokenBar.system = new D35eRolls(); break;
            case 'dnd4ebeta':
                MonksTokenBar.system = new DnD4eRolls(); break;
            case 'pf1':
                MonksTokenBar.system = new PF1Rolls(); break;
            case 'pf2e':
                MonksTokenBar.system = new PF2eRolls(); break;
            case 'tormenta20':
                MonksTokenBar.system = new Tormenta20Rolls(); break;
            case 'sfrpg':
                MonksTokenBar.system = new SFRPGRolls(); break;
            case 'ose':
                MonksTokenBar.system = new OSERolls(); break;
            case 'swade':
                MonksTokenBar.system = new SwadeRolls(); break;
            case 'coc7':
                MonksTokenBar.system = new CoC7Rolls(); break;
        }

        MonksTokenBar.system.constructor.activateHooks();

        game.settings.settings.get("monks-tokenbar.stats").default = MonksTokenBar.system.defaultStats;

        if ((game.user.isGM || setting("allow-player")) && !setting("disable-tokenbar")) {
            MonksTokenBar.tokenbar = new TokenBar();
            MonksTokenBar.tokenbar.refresh();
        }

        if (game.user.isGM && setting('loot-sheet') != 'none' && game.modules.get(setting('loot-sheet'))?.active) {
            let npcObject = (CONFIG.Actor.sheetClasses.npc || CONFIG.Actor.sheetClasses.minion);
            if (npcObject != undefined) {
                let npcSheetNames = Object.values(npcObject)
                    .map((sheetClass) => sheetClass.cls)
                    .map((sheet) => sheet.name);

                npcSheetNames.forEach((sheetName) => {
                    Hooks.on("render" + sheetName, (app, html, data) => {
                        // only for GMs or the owner of this npc
                        if (app?.token?.actor?.getFlag('monks-tokenbar', 'converted') && app.element.find(".revert-lootable").length == 0) {
                            const link = $('<a class="revert-lootable"><i class="fas fa-backward"></i>Revert Lootable</a>');
                            link.on("click", () => LootablesApp.revertLootable(app));
                            app.element.find(".window-title").after(link);
                        }
                    });
                });
            }
        }
    }

    static onMessage(data) {
        switch (data.msgtype) {
            case 'rollability': {
                if (game.user.isGM) {
                    let message = game.messages.get(data.msgid);
                    const revealDice = game.dice3d ? game.settings.get("dice-so-nice", "immediatelyDisplayChatMessages") : true;
                    for (let response of data.response) {
                        let r = Roll.fromData(response.roll);
                        response.roll = r;
                    }
                    if (data.type == 'savingthrow')
                        SavingThrow.updateMessage(data.response, message, revealDice);
                    else if (data.type == 'contestedroll')
                        ContestedRoll.updateMessage(data.response, message, revealDice);
                }
            } break;
            case 'finishroll': {
                if (game.user.isGM) {
                    let message = game.messages.get(data.msgid);
                    if (data.type == 'savingthrow')
                        SavingThrow.finishRolling(data.response, message);
                    else if (data.type == 'contestedroll')
                        ContestedRoll.finishRolling(data.response, message);
                }
            } break;
            case 'assignxp': {
                let message = game.messages.get(data.msgid);
                AssignXP.onAssignXP(data.actorid, message);
            } break;
            case 'assigndeathst': {
                let message = game.messages.get(data.msgid);
                SavingThrow.onAssignDeathST(data.tokenid, message);
            } break;
            case 'movementchange': {
                if (data.tokenid == undefined || canvas.tokens.get(data.tokenid)?.isOwner) {
                    ui.notifications.warn(data.msg);
                    log('movement change');
                    if (MonksTokenBar.tokenbar != undefined) {
                        MonksTokenBar.tokenbar.render(true);
                    }
                }
            }
            case 'refreshsheet': {
                if (game.user.id != data.senderId) {
                    let actor = canvas.tokens.get(data.tokenid)?.actor;
                    if (actor) {
                        actor._sheet = null;
                    }
                }
            }
        }
    }

    static manageTokenControl(tokens, options) {
        let { shiftKey, force } = options;
        
        //if !shift then release all currently selected
        if (!shiftKey || force)
            canvas.tokens.releaseAll();

        if (!tokens) return;
        tokens = (tokens instanceof Array ? tokens : [tokens]);

        //select all token for control
        const controlOptions = { releaseOthers: !shiftKey && !force };
        tokens.forEach(token => (token._controlled && shiftKey && tokens.length == 1 ? token.release(controlOptions) : token.control(controlOptions)));

        //document.getSelection().removeAllRanges();

        return !shiftKey;
    }

    static isMovement(movement) {
        return movement != undefined && MTB_MOVEMENT_TYPE[movement.toUpperCase()] != undefined;
    }

    static getDiceSound(hasMaestroSound = false) {
        const has3DDiceSound = game.dice3d ? game.settings.get("dice-so-nice", "settings").enabled : false;
        const playRollSounds = true; //game.settings.get("betterrolls5e", "playRollSounds")

        if (playRollSounds && !has3DDiceSound && !hasMaestroSound) {
            return CONFIG.sounds.dice;
        }

        return null;
    }

    static async changeGlobalMovement(movement) {
        if (movement == MTB_MOVEMENT_TYPE.COMBAT && (game.combat == undefined || !game.combat.started))
            return;

        log('Changing global movement', movement);
        await game.settings.set("monks-tokenbar", "movement", movement);
        //clear all the tokens individual movement settings
        if (MonksTokenBar.tokenbar != undefined) {
            let tokenbar = MonksTokenBar.tokenbar;
            for (let i = 0; i < tokenbar.tokens.length; i++) {
                await tokenbar.tokens[i].token.setFlag("monks-tokenbar", "movement", null);
                tokenbar.tokens[i].token.unsetFlag("monks-tokenbar", "notified");
            };
            tokenbar.render(true);
        }

        MonksTokenBar.displayNotification(movement);
    }

    static async changeTokenMovement(movement, tokens) {
        if (tokens == undefined)
            return;

        if (!MonksTokenBar.isMovement(movement))
            return;

        tokens = tokens instanceof Array ? tokens : [tokens];

        log('Changing token movement', tokens);

        let newMove = (game.settings.get("monks-tokenbar", "movement") != movement ? movement : null);
        for (let token of tokens) {
            if (token instanceof Token)
                token = token.document;
            let oldMove = token.getFlag("monks-tokenbar", "movement");
            if (newMove != oldMove) {
                await token.setFlag("monks-tokenbar", "movement", newMove);
                await token.unsetFlag("monks-tokenbar", "notified");

                let dispMove = token.getFlag("monks-tokenbar", "movement") || game.settings.get("monks-tokenbar", "movement") || MTB_MOVEMENT_TYPE.FREE;
                MonksTokenBar.displayNotification(dispMove, token);

                /*if (MonksTokenBar.tokenbar != undefined) {
                    let tkn = MonksTokenBar.tokenbar.tokens.find(t => { return t.id == token.id });
                    if (tkn != undefined)
                        tkn.movement = newMove;
                } */
            }
        }

        //if (MonksTokenBar.tokenbar != undefined)
        //    MonksTokenBar.tokenbar.render(true);
    }

    static async changeTokenPanning(tokens) {
        if (tokens == undefined)
            return;

        tokens = tokens instanceof Array ? tokens : [tokens];

        log('Changing token panning', tokens);

        for (let token of tokens) {
            let oldPanning = token.getFlag("monks-tokenbar", "nopanning");
            await token.setFlag("monks-tokenbar", "nopanning", !oldPanning);
        }
    }

    static displayNotification(movement, token) {
        if (game.settings.get("monks-tokenbar", "notify-on-change")) {
            let msg = (token != undefined ? token.name + ": " : "") + i18n("MonksTokenBar.MovementChanged") + (movement == MTB_MOVEMENT_TYPE.FREE ? i18n("MonksTokenBar.FreeMovement") : (movement == MTB_MOVEMENT_TYPE.NONE ? i18n("MonksTokenBar.NoMovement") : i18n("MonksTokenBar.CombatTurn")));
            ui.notifications.warn(msg);
            log('display notification');
            game.socket.emit(
                MonksTokenBar.SOCKET,
                {
                    msgtype: 'movementchange',
                    senderId: game.user.id,
                    msg: msg,
                    tokenid: token?.id
                },
                (resp) => { }
            );
        }
    }

    static allowMovement(token, notify = true) {
        let blockCombat = function (token) {
            //combat movement is only acceptable if the token is the current token.
            //or the previous token
            //let allowPrevMove = game.settings.get("combatdetails", "allow-previous-move");

            let curCombat = game.combats.active;
            if (setting('debug'))
                log('checking on combat ', curCombat, (curCombat && curCombat.started));

            if (curCombat && curCombat.started) {
                let entry = curCombat.combatant;
                let allowNpc = false;
                if (game.settings.get("monks-tokenbar", "free-npc-combat")) {
                    let curPermission = entry.actor?.data.permission ?? {};
                    let tokPermission = token.actor?.data.permission ?? {};
                    let ownedUsers = Object.keys(curPermission).filter(k => curPermission[k] === 3);
                    allowNpc = ownedUsers.some(u => tokPermission[u] === 3 && !game.users.get(u).isGM)
                        && curCombat.turns.every(t => { return t._token.id !== token.id; });
                }

                log('Checking movement', entry.name, token.name, entry, token.id, token, allowNpc);
                return !(entry._token.id == token.id || allowNpc || (setting("allow-after-movement") && curCombat.previous.tokenId == token.id));
            }

            return true;
        }

        if (!game.user.isGM && token != undefined) {
            let movement = token.document.getFlag("monks-tokenbar", "movement") || game.settings.get("monks-tokenbar", "movement") || MTB_MOVEMENT_TYPE.FREE;
            if (setting('debug'))
                log('movement ', movement, token);
            if (movement == MTB_MOVEMENT_TYPE.NONE ||
                (movement == MTB_MOVEMENT_TYPE.COMBAT && blockCombat(token))) {
                //prevent the token from moving
                if (setting('debug'))
                    log('blocking movement');
                if (notify && (!token.getFlag("monks-tokenbar", "notified") || false)) {
                    ui.notifications.warn(movement == MTB_MOVEMENT_TYPE.COMBAT ? i18n("MonksTokenBar.CombatTurnMovementLimited") : i18n("MonksTokenBar.NormalMovementLimited"));
                    token.setFlag("monks-tokenbar", "notified", true);
                    setTimeout(function (token) {
                        log('unsetting notified', token);
                        token.unsetFlag("monks-tokenbar", "notified");
                    }, 30000, token);
                }
                return false;
            }
        }

        return true;
    }

    static async onDeleteCombat(combat) {
        if (game.user.isGM) {
            if (combat.started == true) {
                let axpa;
                if (game.settings.get("monks-tokenbar", "show-xp-dialog") && MonksTokenBar.system.showXP) {
                    axpa = new AssignXPApp(combat);
                    await axpa.render(true);
                }
                /*
                if (game.settings.get("monks-tokenbar", "show-xp-dialog") && (game.system.id !== "sw5e" || (game.system.id === "sw5e" && !game.settings.get('sw5e', 'disableExperienceTracking')))) {
                    axpa = new AssignXPApp(combat);
                    await axpa.render(true);
                }*/

                if (setting("loot-sheet") != 'none' && game.modules.get(setting("loot-sheet"))?.active) {
                    let lapp = new LootablesApp(combat);
                    await lapp.render(true);

                    if (axpa != undefined) {
                        setTimeout(function () {
                            $(axpa.element).addClass('dual');
                            $(lapp.element).addClass('dual');
                            /*
                            axpa.position.left += 204;
                            axpa.render();
                            lapp.position.left -= 204;
                            lapp.render();*/
                        }, 200);
                    }
                }
            }

            if (game.combats.combats.length == 0) {
                //set movement to free movement
                let movement = setting("movement-after-combat");
                if (movement != 'ignore')
                    MonksTokenBar.changeGlobalMovement(movement);
            }
        }
    }

    static getRequestName(requestoptions, requesttype, request) {
        let name = '';
        switch (requesttype) {
            case 'ability': name = i18n("MonksTokenBar.AbilityCheck"); break;
            case 'save': name = i18n("MonksTokenBar.SavingThrow"); break;
            case 'dice': name = i18n("MonksTokenBar.Roll"); break;
            default:
                name = (request != 'death' && request != 'init' ? i18n("MonksTokenBar.Check") : "");
        }
        let rt = requestoptions.find(o => {
            return o.id == (requesttype || request);
        });
        let req = (rt?.groups && rt?.groups[request]);
        let flavor = i18n(req || rt?.text);
        switch (game.i18n.lang) {
            case "pt-BR":
            case "es":
                name = name + ": " + flavor;
                break;
            case "en":
            default:
                name = flavor + " " + name;
        }
        return name;
    }

    static setGrabMessage(message, event) {
        if (MonksTokenBar.grabmessage != undefined) {
            $('#chat-log .chat-message[data-message-id="' + MonksTokenBar.grabmessage.id + '"]').removeClass('grabbing');
        }

        if (MonksTokenBar.grabmessage == message)
            MonksTokenBar.grabmessage = null;
        else {
            MonksTokenBar.grabmessage = message;
            if(message != undefined)
                $('#chat-log .chat-message[data-message-id="' + MonksTokenBar.grabmessage.id + '"]').addClass('grabbing');
        }

        if (event.stopPropagation) event.stopPropagation();
        if (event.preventDefault) event.preventDefault();
        event.cancelBubble = true;
        event.returnValue = false;
    }

    static selectActors(message, filter, event) {
        let tokens = Object.entries(message.data.flags['monks-tokenbar'])
            .map(([k, v]) => { return (k.startsWith('token') ? v : null) })
            .filter(filter)
            .map(t => { return canvas.tokens.get(t?.id); })
            .filter(t => t);

        MonksTokenBar.manageTokenControl(tokens, { shiftKey: event?.originalEvent?.shiftKey, force: true });

        if (event) {
            if (event.stopPropagation) event.stopPropagation();
            if (event.preventDefault) event.preventDefault();
            event.cancelBubble = true;
            event.returnValue = false;
        }
    }

    static onClickMessage(message, html) {
        if (MonksTokenBar.grabmessage != undefined) {
            //make sure this message matches the grab message
            let roll = {};
            if (game.system.id == 'pf2e') {
                let [abilityId, type] = message.data.flags.pf2e.context.type.split('-');
                roll = { type: (type == 'check' ? 'attribute': type), abilityId: abilityId };
            } else
                roll = message.getFlag(game.system.id, 'roll');
            if (roll && MonksTokenBar.grabmessage.getFlag('monks-tokenbar', 'requesttype') == roll.type &&
                MonksTokenBar.grabmessage.getFlag('monks-tokenbar', 'request') == (roll.skillId || roll.abilityId)) {
                let tokenId = message.data.speaker.token;
                let msgtoken = MonksTokenBar.grabmessage.getFlag('monks-tokenbar', 'token' + tokenId);

                if (msgtoken != undefined) {
                    let r = Roll.fromJSON(message.data.roll);
                    SavingThrow.updateMessage([{ id: tokenId, roll: r }], MonksTokenBar.grabmessage);
                    if (setting('delete-after-grab'))
                        message.delete();
                    MonksTokenBar.grabmessage = null;
                }
            }
        }
    }

    static toggleMovement(combatant, event) {
        event.preventDefault();
        event.stopPropagation();

        let movement = (combatant.token.getFlag('monks-tokenbar', 'movement') == MTB_MOVEMENT_TYPE.FREE ? MTB_MOVEMENT_TYPE.COMBAT : MTB_MOVEMENT_TYPE.FREE);
        this.changeTokenMovement(movement, combatant.token.object);
        $(event.currentTarget).toggleClass('active', movement);
    }
}

Hooks.once('init', async function () {
    log('Initializing Combat Details');
    // Assign custom classes and constants here
    // Register custom module settings
    MonksTokenBar.init();
    MonksTokenBarAPI.init();

    //$('body').on('click', $.proxy(MonksTokenBar.setGrabMessage, MonksTokenBar, null));
});

Hooks.on("deleteCombat", MonksTokenBar.onDeleteCombat);

Hooks.on("updateCombat", function (combat, delta) {
    if (game.user.isGM) {
        if (MonksTokenBar.tokenbar) {
            $(MonksTokenBar.tokenbar.tokens).each(function () {
                this.token.unsetFlag("monks-tokenbar", "nofified");
            });
        }

        if (delta.round === 1 && combat.turn === 0 && combat.started === true && setting("change-to-combat")) {
            MonksTokenBar.changeGlobalMovement(MTB_MOVEMENT_TYPE.COMBAT);
        }
    }
});

Hooks.on("ready", MonksTokenBar.ready);

Hooks.on('preUpdateToken', (document, update, options, userId) => {
    if ((update.x != undefined || update.y != undefined) && !game.user.isGM) {
        let token = document.object;
        let allow = MonksTokenBar.allowMovement(token);
        if (!allow) {
            delete update.x;
            delete update.y;
        }
    }
});

Hooks.on("getSceneControlButtons", (controls) => {
    if (game.user.isGM && setting('show-lootable-menu') && game.modules.get("lootsheetnpc5e")?.active) {
        let tokenControls = controls.find(control => control.name === "token")
        tokenControls.tools.push({
            name: "togglelootable",
            title: "MonksTokenBar.Lootables",
            icon: "fas fa-dolly-flatbed",
            onClick: () => {
                new LootablesApp().render(true);
            },
            toggle: false,
            button: true
        });
    }
});

Hooks.on("renderSettingsConfig", (app, html, data) => {
    let btn = $('<button>')
        .addClass('file-picker')
        .attr('type', 'button')
        .attr('data-type', "imagevideo")
        .attr('data-target', "img")
        .attr('title', "Browse Files")
        .attr('tabindex', "-1")
        .html('<i class="fas fa-file-import fa-fw"></i>')
        .click(function (event) {
            const fp = new FilePicker({
                type: "audio",
                current: $(event.currentTarget).prev().val(),
                callback: path => {
                    $(event.currentTarget).prev().val(path);
                }
            });
            return fp.browse();
        });

    btn.clone(true).insertAfter($('input[name="monks-tokenbar.request-roll-sound-file"]', html));
});

Hooks.on("renderCombatTracker", (app, html, data) => {
    if (setting("show-on-tracker") && game.user.isGM) {
        $('.combatant', html).each(function () {
            let id = this.dataset.combatantId;
            let combatant = app.viewed.combatants.find(c => c.id == id);
            if (combatant && combatant.hasPlayerOwner) {
                $($('<a>')
                    .addClass('combatant-control')
                    .toggleClass('active', combatant.token.getFlag('monks-tokenbar', 'movement') == MTB_MOVEMENT_TYPE.FREE)
                    .attr('title', 'Allow Movement')
                    .attr('data-control', 'toggleMovement')
                    .html('<i class="fas fa-running"></i>')
                    .click(MonksTokenBar.toggleMovement.bind(MonksTokenBar, combatant))
                ).insertBefore($('.token-effects', this));
            }
        })

    }
});

Hooks.on("renderTokenConfig", (app, html, data) => {
    if (game.user.isGM) {
        let include = app.token.getFlag('monks-tokenbar', 'include') || 'default';
        include = (include === true ? 'include' : (include === false ? 'exclude' : include || 'default'));
            //(app.object.actor != undefined && app.object.actor?.hasPlayerOwner && (game.user.isGM || app.object.actor?.isOwner) && (app.object.actor?.data.type != 'npc' || app.object.data.disposition == 1));
        $('<div>')
            .addClass('form-group')
            .append($('<label>').html('Show on Tokenbar'))
            .append($('<select>').attr('name', 'flags.monks-tokenbar.include')
                .append($('<option>').attr('value', 'default').html('Default').prop('selected', include == 'default'))
                .append($('<option>').attr('value', 'include').html('Include').prop('selected', include == 'include'))
                .append($('<option>').attr('value', 'exclude').html('Exclude').prop('selected', include == 'exclude')))
            .insertAfter($('[name="disposition"]', html).parent());

        app.setPosition();
    }
});

Hooks.on("renderChatMessage", (message, html, data) => {
    $('.item-card button[data-action="save"]', html).click(MonksTokenBar.chatCardAction.bind(message));
});

Hooks.on("setupTileActions", (actions) => {
    return Object.assign(actions, {
        'setmovement': {
            name: 'Change Movement Mode',
            stop: true,
            ctrls: [
                {
                    id: "entity",
                    name: "Select Entity",
                    type: "select",
                    subtype: "entity",
                    options: { showToken: true, showWithin: true, showPlayers: true, showPrevious: true },
                    restrict: (entity) => { return (entity instanceof Token); }
                },
                {
                    id: "movement",
                    name: "Allow Movement",
                    list: "movement",
                    type: "list"
                }
            ],
            values: {
                'movement': {
                    "none": 'MonksTokenBar.NoMovement',
                    "free": 'MonksTokenBar.FreeMovement',
                    "combat": 'MonksTokenBar.CombatTurn'
                }
            },
            fn: async (args = {}) => {
                const { action } = args;
                let entities = await game.MonksActiveTiles.getEntities(args);

                MonksTokenBar.changeTokenMovement((typeof action.data.movement == 'boolean' ? (action.data.movement ? MTB_MOVEMENT_TYPE.FREE : MTB_MOVEMENT_TYPE.NONE) : action.data.movement), entities);

                return { tokens: entities };
            },
            content: (trigger, action) => {
                return trigger.name + ' of ' + action.data.entity.name + ' to ' + i18n(trigger.values.movement[action.data?.movement]);
            }
        },
        'requestroll': {
            name: 'Request Roll',
            ctrls: [
                {
                    id: "entity",
                    name: "Select Entity",
                    type: "select",
                    subtype: "entity",
                    options: { showTile: false, showToken: true, showWithin: true, showPlayers: true },
                    restrict: (entity) => { return (entity instanceof Token); }
                },
                {
                    id: "request",
                    name: "Request",
                    list: () => { return MonksTokenBar.system._requestoptions; },
                    type: "list"
                },
                {
                    id: "dc",
                    name: "DC",
                    type: "text"
                },
                {
                    id: "rollmode",
                    name: "Roll Mode",
                    list: "rollmode",
                    type: "list"
                },
                {
                    id: "silent",
                    name: "Bypass Dialog",
                    type: "checkbox"
                },
                {
                    id: "fastforward",
                    name: "Auto Roll",
                    type: "checkbox"
                },
                {
                    id: "usetokens",
                    name: "Continue with",
                    list: "usetokens",
                    type: "list"
                },
                {
                    id: "continue",
                    name: "Continue if",
                    list: "continue",
                    type: "list"
                }
            ],
            values: {
                'rollmode': {
                    "roll": i18n('MonksTokenBar.PublicRoll'),
                    "gmroll": i18n('MonksTokenBar.PrivateGMRoll'),
                    "blindroll": i18n('MonksTokenBar.BlindGMRoll'),
                    "selfroll": i18n('MonksTokenBar.SelfRoll')
                },
                'usetokens': {
                    "all": "All Tokens",
                    "fail": "Tokens that Fail",
                    "succeed": "Tokens that Succeed"
                },
                'continue': {
                    "always": "Always",
                    "failed": "Any Failed",
                    "passed": "Any Passed",
                    "allfail": "All Failed",
                    "allpass": "All Passed"
                }
            },
            fn: async (args = {}) => {
                const { action, tile } = args;
                let entities = await game.MonksActiveTiles.getEntities(args);

                if (entities.length == 0)
                    return;

                entities = entities.map(e => e.object);

                let savingthrow = new SavingThrowApp(entities, { rollmode: action.data.rollmode, request: action.data.request, dc: action.data.dc });
                savingthrow['active-tiles'] = { id: args._id, tile: args.tile.uuid, action: action };
                if (action.data.silent === true) {
                    let msg = await savingthrow.requestRoll();
                    if (action.data.fastforward === true) {
                        //need to delay slightly so the original action has time to save a state properly.
                        window.setTimeout(function () {
                            SavingThrow.onRollAll('all', msg);
                        }, 100);
                        //let result = await SavingThrow.onRollAll('all', msg);
                        /*
                        if (action.data.usetokens == 'fail' || action.data.usetokens == 'succeed') {
                            result.tokens = result.tokenresults.filter(r => r.passed == (action.data.usetokens == 'succeed'));
                            for (let i = 0; i < result.tokens.length; i++) {
                                result.tokens[i] = await fromUuid(result.tokens[i].uuid);
                            }
                        }

                        result.continue = action.data.continue == 'always' ||
                            (action.data.continue == 'passed' && result.passed > 0) ||
                            (action.data.continue == 'failed' && result.failed > 0) ||
                            (action.data.continue == 'allpass' && result.passed == result.tokenresults.length) ||
                            (action.data.continue == 'allfail' && result.failed == result.tokenresults.length);
                        //(action.data.continue == 'passed' ? !result.passed : (action.data.checkdc == 'fail' ? result.passed : null));
                        return result;*/
                    }
                }
                else
                    savingthrow.render(true);

                //if we got here then we need to pause before continuing and wait until the request has been fulfilled
                return { pause: true };
            },
            content: (trigger, action) => {
                let parts = action.data?.request.split(':');
                let requesttype = (parts.length > 1 ? parts[0] : '');
                let request = (parts.length > 1 ? parts[1] : parts[0]);
                let name = MonksTokenBar.getRequestName(MonksTokenBar.system.requestoptions, requesttype, request);
                return name + (action.data?.dc ? ', DC' + action.data?.dc : '') + (action.data?.usetokens != 'all' || action.data?.continue != 'always' ? ", Continue " + (action.data?.continue != 'always' ? ' if ' + trigger.values.continue[action.data?.continue] : '') + (action.data?.usetokens != 'all' ? ' with ' + trigger.values.usetokens[action.data?.usetokens] : '') : '');
            }
        },
        'filterrequest': {
            name: 'Filter Request Results',
            group: 'filters',
            ctrls: [
                {
                    id: "passed",
                    name: "Passed Tokens Goto",
                    type: "text"
                },
                {
                    id: "failed",
                    name: "Failed Tokens Goto",
                    type: "text"
                },
            ],
            fn: async (args = {}) => {
                const { action, value } = args;

                let goto = [];
                if (action.data.failed) {
                    goto.push({ tokens: await Promise.all(value.tokenresults.filter(r => !r.passed).map(async (t) => { return await fromUuid(t.uuid); })), tag: action.data.failed });
                }
                if (action.data.passed)
                    goto.push({ tokens: await Promise.all(value.tokenresults.filter(r => r.passed).map(async (t) => { return await fromUuid(t.uuid); })), tag: action.data.passed });
                return { goto: goto };
            },
            content: (trigger, action) => {
                return trigger.name;
            }
        }
    });
})