v1.3.3

MaterialDeck.js

@@ -9,6 +9,7 @@ import {SoundboardControl} from "./src/soundboard.js";
 import {OtherControls} from "./src/othercontrols.js";
 import {ExternalModules} from "./src/external.js";
 import {SceneControl} from "./src/scene.js";
+import {compatibleCore} from "./src/misc.js";
 export var streamDeck;
 export var tokenControl;
 var move;
@@ -25,6 +26,11 @@ export var selectedTokenId;
 
 let ready = false;
 let activeSounds = [];
+
+export let hotbarUses = false;
+export let calculateHotbarUses;
+
+
        
 //CONFIG.debug.hooks = true;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -53,19 +59,27 @@ async function analyzeWSmessage(msg){
     //console.log("Received",data);
 
     if (data.type == "connected" && data.data == "SD"){
+        const msg = {
+            target: "SD",
+            type: "init",
+            system: game.system.id
+        }
+        ws.send(JSON.stringify(msg));
+        
+
+        console.log("streamdeck connected to server");
+        streamDeck.resetImageBuffer();
+    }
+
+    if (data.type == "version" && data.source == "SD") {
         /*
         console.log(data);
         const minimumSDversion = game.modules.get("MaterialDeck").data.minimumSDversion.replace('v','');
         const minimumMSversion = game.modules.get("MaterialDeck").data.minimumMSversion;
-        console.log('SD',minimumSDversion,minimumMSversion)
-        if (data.SDversion < minimumSDversion) console.log('SD: nope')
+        console.log('SD',minimumSDversion,data.version)
+        if (data.version < minimumSDversion) console.log('SD: nope')
         else console.log('SD: yes');
-        if (data.MSversion < minimumMSversion) console.log('MS: nope')
-        else console.log('MS: yes');
         */
-
-        console.log("streamdeck connected to server");
-        streamDeck.resetImageBuffer();
     }
 
     if (data == undefined || data.payload == undefined) return;
@@ -74,13 +88,13 @@ async function analyzeWSmessage(msg){
     const event = data.event;
     const context = data.context;
     const coordinates = data.payload.coordinates;
-    if (coordinates == undefined) coordinates = 0;
     const settings = data.payload.settings;
 
     if (data.data == 'init'){
 
     }
     if (event == 'willAppear' || event == 'didReceiveSettings'){
+        if (coordinates == undefined) return;
         streamDeck.setScreen(action);
         streamDeck.setContext(action,context,coordinates,settings);
 
@@ -107,7 +121,8 @@ async function analyzeWSmessage(msg){
     }
     
     else if (event == 'willDisappear'){
-        streamDeck.clearContext(action,coordinates);
+        if (coordinates == undefined) return;
+        streamDeck.clearContext(action,coordinates,context);
     }
 
     else if (event == 'keyDown'){
@@ -169,7 +184,8 @@ function startWebsocket() {
         ws.send(JSON.stringify(msg));
         const msg2 = {
             target: "SD",
-            type: "init"
+            type: "init",
+            system: game.system.id
         }
         ws.send(JSON.stringify(msg2));
         clearInterval(wsInterval);
@@ -195,6 +211,22 @@ export function sendWS(txt){
         ws.send(txt);
 }
 
+export function isEmpty(obj) {
+    for(var key in obj) {
+        if(obj.hasOwnProperty(key))
+            return false;
+    }
+    return true;
+}
+
+export function getPermission(action,func) {
+    const role = game.user.role-1;
+    const settings = game.settings.get(moduleName,'userPermission');
+    if (action == 'ENABLE') return settings.enable[role];
+    else return settings.permissions?.[action]?.[func]?.[role];
+}
+
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // Hooks
@@ -205,25 +237,10 @@ export function sendWS(txt){
  * Ready hook
  * Attempt to open the websocket
  */
-Hooks.once('ready', ()=>{
+Hooks.once('ready', async()=>{
+    registerSettings();
     enableModule = (game.settings.get(moduleName,'Enable')) ? true : false;
     
-    game.socket.on(`module.MaterialDeck`, (payload) =>{
-        //console.log(payload);
-        if (payload.msgType != "playSound") return;
-        playTrack(payload.trackNr,payload.src,payload.play,payload.repeat,payload.volume);  
-    });
-
-    for (let i=0; i<64; i++)
-        activeSounds[i] = false;
-
-    if (enableModule == false) return;
-    if (game.user.isGM == false) {
-        ready = true;
-        return;
-    }
-    
-    startWebsocket();
     soundboard = new SoundboardControl();
     streamDeck = new StreamDeck();
     tokenControl = new TokenControl();
@@ -235,6 +252,63 @@ Hooks.once('ready', ()=>{
     externalModules = new ExternalModules();
     sceneControl = new SceneControl();
 
+    game.socket.on(`module.MaterialDeck`, async(payload) =>{
+        //console.log(payload);
+        if (payload.msgType == "playSound") soundboard.playSound(payload.trackNr,payload.src,payload.play,payload.repeat,payload.volume);  
+        else if (game.user.isGM && payload.msgType == "playPlaylist") {
+            const playlist = playlistControl.getPlaylist(payload.playlistNr);
+            playlistControl.playPlaylist(playlist,payload.playlistNr);
+        }
+        else if (game.user.isGM && payload.msgType == "playTrack") {
+            const playlist = playlistControl.getPlaylist(payload.playlistNr);
+            const sounds = playlist.data.sounds;
+            for (let track of sounds)
+                if (track._id == payload.trackId)
+                    playlistControl.playTrack(track,playlist,payload.playlistNr)
+        }
+        else if (game.user.isGM && payload.msgType == "stopAllPlaylists")
+            playlistControl.stopAll(payload.force);
+        else if (game.user.isGM && payload.msgType == "soundboardUpdate") {
+            await game.settings.set(moduleName,'soundboardSettings',payload.settings);
+            const payloadNew = {
+                "msgType": "soundboardRefresh"
+            };
+            game.socket.emit(`module.MaterialDeck`, payloadNew);
+        }
+        else if (game.user.isGM == false && payload.msgType == "soundboardRefresh" && enableModule)
+            soundboard.updateAll();
+        else if (game.user.isGM && payload.msgType == "macroboardUpdate") {
+            await game.settings.set(moduleName,'macroSettings',payload.settings);
+            const payloadNew = {
+                "msgType": "macroboardRefresh"
+            };
+            game.socket.emit(`module.MaterialDeck`, payloadNew);
+        }
+        else if (game.user.isGM == false && payload.msgType == "macroboardRefresh" && enableModule)
+            macroControl.updateAll();
+        else if (game.user.isGM && payload.msgType == "playlistUpdate") {
+            await game.settings.set(moduleName,'playlists',payload.settings);
+            const payloadNew = {
+                "msgType": "playlistRefresh"
+            };
+            game.socket.emit(`module.MaterialDeck`, payloadNew);
+        }
+        else if (game.user.isGM == false && payload.msgType == "playlistRefresh" && enableModule)
+            playlistControl.updateAll();
+            
+    });
+
+    for (let i=0; i<64; i++)
+        activeSounds[i] = false;
+
+    if (enableModule == false) return;
+    if (getPermission('ENABLE') == false) {
+        ready = true;
+        return;
+    }
+
+    startWebsocket();
+
     let soundBoardSettings = game.settings.get(moduleName,'soundboardSettings');
     let macroSettings = game.settings.get(moduleName, 'macroSettings');
     let array = [];
@@ -261,35 +335,20 @@ Hooks.once('ready', ()=>{
             volume: arrayVolume
         });
     }
+
+    const hotbarUsesTemp = game.modules.get("illandril-hotbar-uses");
+    if (hotbarUsesTemp != undefined) {
+        hotbarUses = true;
+    }
     
 });
 
-export function playTrack(soundNr,src,play,repeat,volume){
-    if (play){
-        volume *= game.settings.get("core", "globalInterfaceVolume");
-
-        let howl = new Howl({src, volume, loop: repeat, onend: (id)=>{
-            if (repeat == false){
-                activeSounds[soundNr] = false;
-            }
-        },
-        onstop: (id)=>{
-            activeSounds[soundNr] = false;
-        }});
-        howl.play();
-        activeSounds[soundNr] = howl;
-   }
-   else {
-        activeSounds[soundNr].stop();
-        activeSounds[soundNr] = false;
-   }
-}
-
 Hooks.on('updateToken',(scene,token)=>{
     if (enableModule == false || ready == false) return;
     let tokenId = token._id;
     if (tokenId == selectedTokenId)
         tokenControl.update(selectedTokenId);
+    if (macroControl != undefined) macroControl.updateAll();
 });
 
 Hooks.on('updateActor',(scene,actor)=>{
@@ -302,6 +361,7 @@ Hooks.on('updateActor',(scene,actor)=>{
                 tokenControl.update(selectedTokenId);
         }
     }
+    if (macroControl != undefined) macroControl.updateAll();
 });
 
 Hooks.on('controlToken',(token,controlled)=>{
@@ -313,13 +373,26 @@ Hooks.on('controlToken',(token,controlled)=>{
         selectedTokenId = undefined;
     }
     tokenControl.update(selectedTokenId);
+    if (macroControl != undefined) macroControl.updateAll();
 });
 
+Hooks.on('updateOwnedItem',()=>{
+    if (macroControl != undefined) macroControl.updateAll();
+})
+
 Hooks.on('renderHotbar', (hotbar)=>{
+    if (compatibleCore("0.8.1")) return;
     if (enableModule == false || ready == false) return;
     if (macroControl != undefined) macroControl.hotbar(hotbar.macros);
 });
 
+Hooks.on('render', (app)=>{
+    if (enableModule == false || ready == false) return;
+    if (compatibleCore("0.8.1") == false) return;
+    if (app.id == "hotbar" && macroControl != undefined)  macroControl.hotbar(app.macros);
+    
+});
+
 Hooks.on('renderCombatTracker',()=>{
     if (enableModule == false || ready == false) return;
     if (combatTracker != undefined) combatTracker.updateAll();
@@ -342,10 +415,27 @@ Hooks.on('pauseGame',()=>{
     otherControls.updateAll();
 });
 
-Hooks.on('renderSidebarTab',()=>{
+Hooks.on('renderSidebarTab',(app)=>{
+    const options = {
+        sidebarTab: app.tabName,
+        renderPopout: app.popOut
+    }
+    if (enableModule == false || ready == false) return;
+    if (otherControls != undefined) otherControls.updateAll(options);
+    if (sceneControl != undefined) sceneControl.updateAll();
+});
+
+Hooks.on('closeSidebarTab',(app)=>{
+    const options = {
+        sidebarTab: app.tabName,
+        renderPopout: false
+    }
+    if (otherControls != undefined) otherControls.updateAll(options);
+});
+
+Hooks.on('changeSidebarTab',()=>{
     if (enableModule == false || ready == false) return;
     if (otherControls != undefined) otherControls.updateAll();
-    if (sceneControl != undefined) sceneControl.updateAll();
 });
 
 Hooks.on('updateScene',()=>{
@@ -358,6 +448,7 @@ Hooks.on('updateScene',()=>{
 Hooks.on('renderSceneControls',()=>{
     if (enableModule == false || ready == false || otherControls == undefined) return;
     otherControls.updateAll();
+    externalModules.updateAll();
 });
 
 Hooks.on('targetToken',(user,token,targeted)=>{
@@ -380,14 +471,30 @@ Hooks.on('closeCompendium',()=>{
     otherControls.updateAll();
 });
 
-Hooks.on('renderJournalSheet',()=>{
+Hooks.on('renderCompendiumBrowser',()=>{
     if (enableModule == false || ready == false) return;
-    otherControls.updateAll();
+    otherControls.updateAll({renderCompendiumBrowser:true});
 });
 
-Hooks.on('closeJournalSheet',()=>{
+Hooks.on('closeCompendiumBrowser',()=>{
     if (enableModule == false || ready == false) return;
-    otherControls.updateAll();
+    otherControls.updateAll({renderCompendiumBrowser:false});
+});
+
+Hooks.on('renderJournalSheet',(sheet)=>{
+    if (enableModule == false || ready == false) return;
+    otherControls.updateAll({
+        hook:'renderJournalSheet',
+        sheet:sheet
+    });
+});
+
+Hooks.on('closeJournalSheet',(sheet)=>{
+    if (enableModule == false || ready == false) return;
+    otherControls.updateAll({
+        hook:'closeJournalSheet',
+        sheet:sheet
+    });
 });
 
 Hooks.on('gmScreenOpenClose',(html,isOpen)=>{
@@ -395,9 +502,29 @@ Hooks.on('gmScreenOpenClose',(html,isOpen)=>{
     externalModules.updateAll({gmScreen:isOpen});
 });
 
+Hooks.on('ShareVision', ()=>{
+    if (enableModule == false || ready == false) return;
+    externalModules.updateAll();
+})
+
+Hooks.on('NotYourTurn', ()=>{
+    if (enableModule == false || ready == false) return;
+    externalModules.updateAll();
+})
+
+Hooks.on('pseudoclockSet', ()=>{
+    if (enableModule == false || ready == false) return;
+    externalModules.updateAll();
+})
+
+Hooks.on('about-time.clockRunningStatus', ()=>{
+    if (enableModule == false || ready == false) return;
+    externalModules.updateAll();
+})
+
 Hooks.once('init', ()=>{
     //CONFIG.debug.hooks = true;
-    registerSettings(); //in ./src/settings.js
+    //registerSettings(); //in ./src/settings.js
 });
 
 Hooks.once('canvasReady',()=>{

changelog.md

@@ -1,4 +1,115 @@
 # Changelog Material Deck Module
+## v1.3.3
+Additions:
+<ul>
+<li>Other Actions => Open Sidebar Tab: Action now indicates which sidebar tab is open (only works on Foundry 0.8.x)</li>
+<li>Other Actions => Open Sidebar Tab: Added option to create an pop-out (doesn't work for the chat)</li>
+<li>Other Actions: Added option to open the pf2e compendium browser</li>
+<li>Macro Action: Can now call macros by name</li>
+<li>Token Action => On Click: Added option to call a macro. Currently the macro will be applied to the selected token</li>
+<li>Token Action => Display Stats: Added saving throws and skill modifiers for most systems</li>
+<li>Token Action => OnClick: Added 'Dice Roll' option, which allows you to roll ability checks, saving throws and other things (depending on game system)</li>
+<li>Token Action => Stats => Display HP: Made the heart icon dynamic, so the amount that the heart is filled with red depends on the relative amount of hit points of the token. 25% hp means the lower 25% of the heart is red, 50% hp means the lower 50% of the heart is red, etc</li>
+<li>Token Action => Stats => Added a '+' before all modifier stats that are bigger than 0</li>
+<li>Token Action => Custom OnClick: Added support for calling macros. For instructions, please refer to the documentation: https://github.com/CDeenen/MaterialDeck/wiki/Token-Action#custom-on-click-function</li>
+</ul>
+
+Fixes:
+<ul>
+<li>Other Actions => Pause Game: Pause is now transmitted to all connected clients</li>
+<li>Token Action => Display Stats: Fixed movement speed for pf2e</li>
+</ul>
+
+Other:
+<ul>
+<li>Should be compatible with Foundry 0.8.1. Only tested on DnD5e. Please note that any functions that rely on other modules do not work if the other modules are not compatible with 0.8.1</li>
+</ul>
+
+<br>
+<b>Compatible server app and SD plugin:</b><br>
+Material Server v1.0.2 (unchanged): https://github.com/CDeenen/MaterialServer/releases <br>
+SD plugin v1.3.4 (<b>must be updated!</b>): https://github.com/CDeenen/MaterialDeck_SD/releases<br>
+
+## v1.3.2 - 11-03-2021
+Additions:
+<ul>
+<li>Added support for the Multi Action provided by the SD app</li>
+<li>External Modules Action => Added support for About Time</li>
+<li>Token Action => Stats: Added 'Ability Scores', 'Ability Score Modifiers', 'Ability Score Saves' (dnd5e only) and 'Proficiency Bonus'</li>
+<li>Token Action => Stats: Added 'HP (box)' option that displays a box with color that changes depending on the HP</li>
+<li>Move Action: You can now choose what token should be moved, similar to the Token Action</li>
+</ul>
+
+Fixes:
+<ul>
+<li>Playlist Action => Relative Offset: Fixed issue with displaying the target playlist name</li>
+<li>Macro Action: Fixed Hotbar Uses for Shadow of the Demonlord</li>
+</ul>
+
+Other:
+<ul>
+<li>Macro Action: Improved the way Hotbar Uses are displayed, it is now displayed in a box similar to how the module looks in Foundry</li>
+<li>Made the way images are generated more flexible to make future additions easier</li>
+<li></li>
+</ul>
+
+<br>
+<b>Compatible server app and SD plugin:</b><br>
+Material Server v1.0.2 (unchanged): https://github.com/CDeenen/MaterialServer/releases <br>
+SD plugin v1.3.2 (<b>must be updated!</b>): https://github.com/CDeenen/MaterialDeck_SD/releases<br>
+
+### v1.3.1 - 27-02-2021
+Additions:
+<ul>
+<li>Token Action: You can now choose what token should be targeted with the action using: 'Selected Token', 'Token Name', 'Actor Name', 'Token Id' or 'Actor Id'. Added relevant user permissions to the permission configuration</li>
+<li>Token Action => On Click: Added options 'Select Token' and 'Center on Token and Select Token'</li>
+<li>Playlist Action: Added relative offset mode, with the option to display the offset target name for playlists</li>
+<li>Playlist Action => Stop All: Added option to display the name of the playlist at the current offset</li>
+</ul>
+
+Fixes:
+<ul>
+<li>Default user permissions would not be loaded if no previously saved permissions were present, resulting in MD assuming nobody has any permissions</li>
+<li>Other Actions => Control Buttons => Lighting Controls: Would create a button for ambient sound instead of lighting</li>
+<li>Token Action => Display Token Icon: It used to show the icon, even if unchecked, if no stat with default icon was selected</li>
+</ul>
+
+<br>
+<b>Compatible server app and SD plugin:</b><br>
+Material Server v1.0.2 (unchanged): https://github.com/CDeenen/MaterialServer/releases <br>
+SD plugin v1.3.1 (<b>must be updated!</b>): https://github.com/CDeenen/MaterialDeck_SD/releases<br>
+
+### v1.3.0 - 25-02-2021
+Additions:
+<ul>
+<li>Material Deck can now be used by players. A 'User Permission Configuration' screen has been added to the module settings where the GM can deside what Material Deck functions are available to users</li>
+<li>Macro Action: Added support for Illandril's Hotbar Uses (only requires the module to be installed, does not have to be active)</li>
+<li>Token Action => OnClick: Added support for CUB conditions</li>
+<li>External Modules => Added support for the 'Trigger Happy' module</li>
+<li>External Modules => Added support for the 'MookAI' module</li>
+<li>External Modules => Added support for the 'Shared Vision' module</li>
+<li>External Modules => Added support for the 'Lock View' module</li>
+<li>External Modules => Added support for the 'Not Your Turn' module</li>
+<ul>
+Fixes:
+<ul>
+<li>Token Action => OnClick: Fixed conditions for pf1e and dnd3.5e</li>
+</ul>
+Other Changes:
+<ul>
+<li>Token and Combat Tracker Actions now autodetect the game system</li>
+<li>Game-system related settings in the SD app unified and improved</li>
+<li>Image Cache setting is no longer considered experimental</li>
+</ul>
+
+<b>Note 1: </b>Because the module can now be used by players, some settings have been moved from 'world' settings to 'client' settings. This means that previous settings have been deleted, and they have to be set up again in the module settings.<br>
+<b>Note 2: </b>You can give users access to the playlists, macro board and soundboard. Currently, everyone has to share the same configuration, so be careful with giving players permission to configure one of them.<br>
+<b>Note 3: </b>Because of the new game system autodetection, some settings for non dnd5e systems might be deleted. You'll have to reconfigure them.<br>
+<br>
+<b>Compatible server app and SD plugin:</b><br>
+Material Server v1.0.2 (unchanged): https://github.com/CDeenen/MaterialServer/releases <br>
+SD plugin v1.3.0 (<b>must be updated!</b>): https://github.com/CDeenen/MaterialDeck_SD/releases<br>
+
 ### v1.2.3 - 03-02-2021
 Fixes:
 <ul>

lang/en.json

@@ -2,6 +2,9 @@
     "MaterialDeck.Notifications.Disconnected": "Disconnected from Material Server, attempting to reconnect",
     "MaterialDeck.Notifications.ConnectFail": "Can't connect to Material Server, retrying",
     "MaterialDeck.Notifications.Connected": "Connected",
+    "MaterialDeck.Notifications.Soundboard.NoPermission": "You do not have permission to configure the soundboard",
+    "MaterialDeck.Notifications.Macroboard.NoPermission": "You do not have permission to configure the macro board",
+    "MaterialDeck.Notifications.Playlist.NoPermission": "You do not have permission to configure the playlists",
     
     "MaterialDeck.Sett.Enable": "Enable module",
     "MaterialDeck.Sett.Model": "Stream Deck Model",
@@ -10,12 +13,13 @@
     "MaterialDeck.Sett.Model_Normal": "Normal or Mobile",
     "MaterialDeck.Sett.Model_XL": "XL",
     "MaterialDeck.Sett.Help": "Help",
+    "MaterialDeck.Sett.Permission": "User Permission Configuration",
     "MaterialDeck.Sett.PlaylistConfig": "Playlist Configuration",
     "MaterialDeck.Sett.MacroConfig": "Macro Configuration",
     "MaterialDeck.Sett.SoundboardConfig": "Soundboard Configuration",
     "MaterialDeck.Sett.ServerAddr": "Material Server Address",
     "MaterialDeck.Sett.ServerAddrHint": "The IP address and port of Material Server. The default value will work for 99% of people, only change this if you know what you're doing. Must follow the format [ip_address]:[port], for example: 'localhost:3001' or '192.168.1.1:4000'.",
-    "MaterialDeck.Sett.ImageBuffer": "Image Cache Size (EXPERIMENTAL)",
+    "MaterialDeck.Sett.ImageBuffer": "Image Cache Size",
     "MaterialDeck.Sett.ImageBufferHint": "Sets the amount of images to store in the image cache. The image cache will locally store all images sent to the Stream Deck. This improves the update speed, but increases memory usage.",
 
     "MaterialDeck.PL.Unrestricted": "Unrestricted",
@@ -46,6 +50,132 @@
     "MaterialDeck.Save": "Save",
 
     "MaterialDeck.FxMaster.Colorize": "Colorize",
-    "MaterialDeck.FxMaster.Clear": "Clear All"
+    "MaterialDeck.FxMaster.Clear": "Clear All",
+
+
+    "MaterialDeck.Perm.Instructions": "Configure the permission for each Material Deck action.",
+    "MaterialDeck.Perm.DefaultNotification": "Material Deck user permissions have been configured to the default values.",
+
+    "MaterialDeck.Perm.ENABLE.label": "Enable Module",
+    "MaterialDeck.Perm.ENABLE.ENABLE.label": "Enable",
+    "MaterialDeck.Perm.ENABLE.ENABLE.hint": "Allow users to use Material Deck",
+
+    "MaterialDeck.Perm.COMBAT.label": "Combat Tracker",
+    "MaterialDeck.Perm.COMBAT.END_TURN.label": "End Turn",
+    "MaterialDeck.Perm.COMBAT.END_TURN.hint": "Allow users to end their turn",
+    "MaterialDeck.Perm.COMBAT.TURN_DISPLAY.label": "Turn Display",
+    "MaterialDeck.Perm.COMBAT.TURN_DISPLAY.hint": "Allow users to display the turn display",
+    "MaterialDeck.Perm.COMBAT.OTHER_FUNCTIONS.label": "Other Functions",
+    "MaterialDeck.Perm.COMBAT.OTHER_FUNCTIONS.hint": "Allow users to use other functions in the 'Function Mode', such as starting/stopping combat, increasing/decreasing the turn, etc",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_COMBATANTS.label": "Display Combatants",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_COMBATANTS.hint": "Allow users to display the combatants",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_NON_OWNED_STATS.label": "Display Non-Owned and Non-Observer Stats",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_NON_OWNED_STATS.hint": "Allow users to display stats for tokens they do not own or have observer permission for",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_LIMITED_HP.label": "Display Limited HP",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_LIMITED_HP.hint": "Allow users to display the HP of tokens they have Limited permission for",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_OBSERVER_HP.label": "Display Observer HP",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_OBSERVER_HP.hint": "Allow users to display the HP of tokens they have Observer permission for",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_ALL_NAMES.label": "Display All Names",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_ALL_NAMES.hint": "Allow users to display the name of all tokens",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_LIMITED_NAME.label": "Display Limited Name",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_LIMITED_NAME.hint": "Allow users to display the name of tokens they have Limited permission for",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_OBSERVER_NAME.label": "Display Observer Name",
+    "MaterialDeck.Perm.COMBAT.DISPLAY_OBSERVER_NAME.hint": "Allow users to display the name of tokens they have Observer permission for",
+    
+    "MaterialDeck.Perm.EXTERNAL.label": "External Modules",
+    "MaterialDeck.Perm.EXTERNAL.FXMASTER.label": "Fx Master",
+    "MaterialDeck.Perm.EXTERNAL.FXMASTER.hint": "Allow users to control the Fx Master module",
+    "MaterialDeck.Perm.EXTERNAL.GM_SCREEN.label": "GM Screen",
+    "MaterialDeck.Perm.EXTERNAL.GM_SCREEN.hint": "Allow users to display a GM screen using the GM Screen module",
+
+    "MaterialDeck.Perm.MACRO.label": "Macros",
+    "MaterialDeck.Perm.MACRO.HOTBAR.label": "Hotbar Macros",
+    "MaterialDeck.Perm.MACRO.HOTBAR.hint": "Allow users to use hotbar macros",
+    "MaterialDeck.Perm.MACRO.BY_NAME.label": "Macro by Name",
+    "MaterialDeck.Perm.MACRO.BY_NAME.hint": "Allow users to call macros by name",
+    "MaterialDeck.Perm.MACRO.MACROBOARD.label": "Macro Board",
+    "MaterialDeck.Perm.MACRO.MACROBOARD.hint": "Allow users to use the macro board",
+    "MaterialDeck.Perm.MACRO.MACROBOARD_CONFIGURE.label": "Configure the Macro Board",
+    "MaterialDeck.Perm.MACRO.MACROBOARD_CONFIGURE.hint": "Allow users to configure the macro board",
+
+    "MaterialDeck.Perm.MOVE.label": "Move",
+    "MaterialDeck.Perm.MOVE.TOKEN.label": "Token",
+    "MaterialDeck.Perm.MOVE.TOKEN.hint": "Allow users to move a controlled token",
+    "MaterialDeck.Perm.MOVE.CANVAS.label": "Canvas",
+    "MaterialDeck.Perm.MOVE.CANVAS.hint": "Allow users to move their canvas",
+
+    "MaterialDeck.Perm.OTHER.label": "Other",
+    "MaterialDeck.Perm.OTHER.PAUSE.label": "Pause/Resume",
+    "MaterialDeck.Perm.OTHER.PAUSE.hint": "Allow users to pause or resume the game",
+    "MaterialDeck.Perm.OTHER.CONTROL.label": "Control Buttons",
+    "MaterialDeck.Perm.OTHER.CONTROL.hint": "Allow users to control the control buttons",
+    "MaterialDeck.Perm.OTHER.DARKNESS.label": "Scene Darkness",
+    "MaterialDeck.Perm.OTHER.DARKNESS.hint": "Allow users to set the scene darkness",
+    "MaterialDeck.Perm.OTHER.DICE.label": "Dice Rolling",
+    "MaterialDeck.Perm.OTHER.DICE.hint": "Allow users to roll dice",
+    "MaterialDeck.Perm.OTHER.TABLES_ALL.label": "Roll Tables (all)",
+    "MaterialDeck.Perm.OTHER.TABLES_ALL.hint": "Allow users to view and roll from all roll tables",
+    "MaterialDeck.Perm.OTHER.TABLES.label": "Roll Tables (observer/owner)",
+    "MaterialDeck.Perm.OTHER.TABLES.hint": "Allow users to view and roll from roll tables that they have observer or owner permission for",
+    "MaterialDeck.Perm.OTHER.SIDEBAR.label": "Sidebar",
+    "MaterialDeck.Perm.OTHER.SIDEBAR.hint": "Allow users to control the sidebar",
+    "MaterialDeck.Perm.OTHER.COMPENDIUM_ALL.label": "Compendium Packs (all)",
+    "MaterialDeck.Perm.OTHER.COMPENDIUM_ALL.hint": "Allow users to open all compendium packs",
+    "MaterialDeck.Perm.OTHER.COMPENDIUM.label": "Compendium Packs (observer/owner)",
+    "MaterialDeck.Perm.OTHER.COMPENDIUM.hint": "Allow users to open compendium packs that they have observer or owner permission for",
+    "MaterialDeck.Perm.OTHER.JOURNAL_ALL.label": "Journals (all)",
+    "MaterialDeck.Perm.OTHER.JOURNAL_ALL.hint": "Allow users to open all journals",
+    "MaterialDeck.Perm.OTHER.JOURNAL.label": "Journals (observer/owner)",
+    "MaterialDeck.Perm.OTHER.JOURNAL.hint": "Allow users to open journals they have observer or owner permission for",
+    "MaterialDeck.Perm.OTHER.CHAT.label": "Chat Messages",
+    "MaterialDeck.Perm.OTHER.CHAT.hint": "Allow users to send chat messages",
+
+    "MaterialDeck.Perm.PLAYLIST.label": "Playlists",
+    "MaterialDeck.Perm.PLAYLIST.PLAY.label": "Control",
+    "MaterialDeck.Perm.PLAYLIST.PLAY.hint": "Allow users to play and pause playlists and tracks",
+    "MaterialDeck.Perm.PLAYLIST.CONFIGURE.label": "Configure",
+    "MaterialDeck.Perm.PLAYLIST.CONFIGURE.hint": "Allow users to configure the playlists",
+    
+    "MaterialDeck.Perm.SCENE.label": "Scenes",
+    "MaterialDeck.Perm.SCENE.VISIBLE.label": "Visible Scenes",
+    "MaterialDeck.Perm.SCENE.VISIBLE.hint": "Allow users to view and control the visible scenes",
+    "MaterialDeck.Perm.SCENE.ACTIVE.label": "Active Scene",
+    "MaterialDeck.Perm.SCENE.ACTIVE.hint": "Allow users to view the active scene",
+    "MaterialDeck.Perm.SCENE.DIRECTORY.label": "Scene Directory",
+    "MaterialDeck.Perm.SCENE.DIRECTOR.hint": "Allow users to view and control scenes from the scene directory",
+    "MaterialDeck.Perm.SCENE.NAME.label": "Scene by Name",
+    "MaterialDeck.Perm.SCENE.NAME.hint": "Allow users to view and control any scene by name",
+
+    "MaterialDeck.Perm.SOUNDBOARD.label": "Soundboard",
+    "MaterialDeck.Perm.SOUNDBOARD.PLAY.label": "Enable",
+    "MaterialDeck.Perm.SOUNDBOARD.PLAY.hint": "Allow users to play sounds from the soundboard",
+    "MaterialDeck.Perm.SOUNDBOARD.CONFIGURE.label": "Configure",
+    "MaterialDeck.Perm.SOUNDBOARD.CONFIGURE.hint": "Allow users to configure the soundboard",
+
+    "MaterialDeck.Perm.TOKEN.label": "Token",
+    "MaterialDeck.Perm.TOKEN.STATS.label": "Display Stats",
+    "MaterialDeck.Perm.TOKEN.STATS.hint": "Allow the user to display the stats of the controlled token",
+    "MaterialDeck.Perm.TOKEN.VISIBILITY.label": "Toggle Visibility",
+    "MaterialDeck.Perm.TOKEN.VISIBILITY.hint": "Allow the user to toggle the visibility of the controlled token",
+    "MaterialDeck.Perm.TOKEN.COMBAT.label": "Toggle Combat State",
+    "MaterialDeck.Perm.TOKEN.COMBAT.hint": "Allow the user to toggle the combat state of the controlled token",
+    "MaterialDeck.Perm.TOKEN.VISION.label": "Set Vision",
+    "MaterialDeck.Perm.TOKEN.VISION.hint": "Allow the user to set the vision of the controlled token",
+    "MaterialDeck.Perm.TOKEN.WILDCARD.label": "Wildcard Images",
+    "MaterialDeck.Perm.TOKEN.WILDCARD.hint": "Allow the user to set the controlled token's image using the wildcard image functionality",
+    "MaterialDeck.Perm.TOKEN.CONDITIONS.label": "Set Conditions",
+    "MaterialDeck.Perm.TOKEN.CONDITIONS.hint": "Allow the users to set conditions for the controlled token",
+    "MaterialDeck.Perm.TOKEN.CUSTOM.label": "Custom On-Click",
+    "MaterialDeck.Perm.TOKEN.CUSTOM.hint": "Allow the users to set custom on-click functions",
+    "MaterialDeck.Perm.TOKEN.NON_OWNED.label": "Non-Owned and Non-Observer Tokens",
+    "MaterialDeck.Perm.TOKEN.NON_OWNED.hint": "Allow users access to tokens with non-owned or limited permission",
+    "MaterialDeck.Perm.TOKEN.OBSERVER.label": "Observer",
+    "MaterialDeck.Perm.TOKEN.OBSERVER.hint": "Allow users access to tokens with observer permission",
+
+    "MaterialDeck.AboutTime.First": "st",
+    "MaterialDeck.AboutTime.Second": "nd",
+    "MaterialDeck.AboutTime.Third": "rd",
+    "MaterialDeck.AboutTime.Fourth": "th",
+    "MaterialDeck.AboutTime.Of": "of"
 }
 

module.json

@@ -2,8 +2,8 @@
     "name": "MaterialDeck",
     "title": "Material Deck",
     "description": "Material Deck allows you to control Foundry using an Elgato Stream Deck",
-    "version": "1.2.3",
-    "minimumSDversion": "1.2.2",
+    "version": "1.3.3",
+    "minimumSDversion": "1.3.4",
     "minimumMSversion": "1.0.2",
     "author": "CDeenen",
     "esmodules": [
@@ -11,7 +11,7 @@
     ],
     "socket": true,
     "minimumCoreVersion": "0.7.5",
-    "compatibleCoreVersion": "0.7.9",
+    "compatibleCoreVersion": "0.8.1",
     "languages": [
       {
         "lang": "en",

src/combattracker.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck, tokenControl} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class CombatTracker{
     constructor(){
@@ -24,8 +25,13 @@ export class CombatTracker{
         let src = "modules/MaterialDeck/img/black.png";
         let txt = "";
         let background = "#000000";
+        settings.combat = true;
         
         if (mode == 'combatants'){
+            if (MODULE.getPermission('COMBAT','DISPLAY_COMBATANTS') == false) {
+                streamDeck.noPermission(context,false,"combat tracker");
+                return;
+            }
             if (combat != null && combat != undefined && combat.turns.length != 0){
                 const initiativeOrder = combat.turns;
                 let nr = settings.combatantNr - 1;
@@ -34,31 +40,49 @@ export class CombatTracker{
                 const combatant = initiativeOrder[nr]
 
                 if (combatant != undefined){
-                    const tokenId = combatant.tokenId;
+                    const tokenId = compatibleCore("0.8.1") ? combatant.data.tokenId : combatant.tokenId;
                     tokenControl.pushData(tokenId,settings,context,combatantState,'#cccc00');
                     return;
                 }
                 else {
-                    streamDeck.setIcon(context,src,background);
+                    streamDeck.setIcon(context,src,{background:background});
                     streamDeck.setTitle(txt,context);
                 } 
             }
             else {
-                streamDeck.setIcon(context,src,background);
+                streamDeck.setIcon(context,src,{background:background});
                 streamDeck.setTitle(txt,context);
             }
         }
         else if (mode == 'currentCombatant'){
+            if (MODULE.getPermission('COMBAT','DISPLAY_COMBATANTS') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
             if (combat != null && combat != undefined && combat.started){
-                const tokenId = combat.combatant.tokenId;
+                const tokenId = compatibleCore("0.8.1") ? combat.combatant.data.tokenId : combat.combatant.tokenId;
                 tokenControl.pushData(tokenId,settings,context);
             }
             else {
-                streamDeck.setIcon(context,src,background);
+                streamDeck.setIcon(context,src,{background:background});
                 streamDeck.setTitle(txt,context);
             }
         }
         else if (mode == 'function'){
+
+            if (ctFunction == 'turnDisplay' && MODULE.getPermission('COMBAT','TURN_DISPLAY') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+            else if (ctFunction == 'endTurn' && MODULE.getPermission('COMBAT','END_TURN') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+            else if (ctFunction != 'turnDisplay' && ctFunction != 'endTurn' && MODULE.getPermission('COMBAT','OTHER_FUNCTIONS') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+
             if (ctFunction == 'startStop') {
                 if (combat == null || combat == undefined || combat.combatants.length == 0) {
                     src = "modules/MaterialDeck/img/combattracker/startcombat.png";
@@ -75,6 +99,9 @@ export class CombatTracker{
                     }
                 }
             }
+            else if (ctFunction == 'endTurn') {
+                src = "modules/MaterialDeck/img/combattracker/nextturn.png";
+            }
             else if (ctFunction == 'nextTurn') {
                 src = "modules/MaterialDeck/img/combattracker/nextturn.png";
             }
@@ -99,7 +126,7 @@ export class CombatTracker{
                 if (txt != "") txt += "\n";
                 if (settings.displayTurn) txt += "Turn\n"+turn;
             }
-            streamDeck.setIcon(context,src,background);
+            streamDeck.setIcon(context,src,{background:background});
             streamDeck.setTitle(txt,context);
         }
     }
@@ -111,6 +138,20 @@ export class CombatTracker{
         if (mode == 'function'){
             if (combat == null || combat == undefined) return;
             const ctFunction = settings.combatTrackerFunction ? settings.combatTrackerFunction : 'startStop';
+
+            if (ctFunction == 'turnDisplay' && MODULE.getPermission('COMBAT','TURN_DISPLAY') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+            else if (ctFunction == 'endTurn' && MODULE.getPermission('COMBAT','END_TURN') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+            else if (ctFunction != 'turnDisplay' && ctFunction != 'endTurn' && MODULE.getPermission('COMBAT','OTHER_FUNCTIONS') == false) {
+                streamDeck.noPermission(context);
+                return;
+            }
+
             if (ctFunction == 'startStop'){
                 let src;
                 let background;
@@ -124,15 +165,16 @@ export class CombatTracker{
                     src = "modules/MaterialDeck/img/combattracker/stopcombat.png";
                     background = "#FF0000";
                 }
-                streamDeck.setIcon(context,src,background);
+                streamDeck.setIcon(context,src,{background:background});
                 return;
             }
             if (game.combat.started == false) return;
-
+            
             if (ctFunction == 'nextTurn') game.combat.nextTurn();
             else if (ctFunction == 'prevTurn') game.combat.previousTurn();
             else if (ctFunction == 'nextRound') game.combat.nextRound();
             else if (ctFunction == 'prevRound') game.combat.previousRound();
+            else if (ctFunction == 'endTurn' && game.combat.combatant.owner) game.combat.nextTurn();
         }
         else {
             const onClick = settings.onClick ? settings.onClick : 'doNothing';
@@ -144,12 +186,12 @@ export class CombatTracker{
                     if (nr == undefined || nr < 1) nr = 0;
                     const combatant = initiativeOrder[nr]
                     if (combatant == undefined) return;
-                    tokenId = combatant.tokenId;
+                    tokenId = compatibleCore("0.8.1") ? combatant.data.tokenId : combatant.tokenId;
                 }
             }
             else if (mode == 'currentCombatant') 
                 if (combat != null && combat != undefined && combat.started)
-                    tokenId = combat.combatant.tokenId;
+                    tokenId = compatibleCore("0.8.1") ? combat.combatant.data.tokenId : combat.combatant.tokenId;
                 
             let token = (canvas.tokens.children[0] != undefined) ? canvas.tokens.children[0].children.find(p => p.id == tokenId) : undefined;
             if (token == undefined) return;

src/external.js

@@ -23,19 +23,28 @@ export class ExternalModules{
         this.active = true;
         const module = settings.module ? settings.module : 'fxmaster';
 
-        if (module == 'fxmaster') this.updateFxMaster(settings,context);
-        else if (module == 'gmscreen') this.updateGMScreen(settings,context);
+        if (module == 'fxmaster')           this.updateFxMaster(settings,context);
+        else if (module == 'gmscreen')      this.updateGMScreen(settings,context);
+        else if (module == 'triggerHappy')  this.updateTriggerHappy(settings,context);
+        else if (module == 'sharedVision')  this.updateSharedVision(settings,context);
+        else if (module == 'mookAI')        this.updateMookAI(settings,context);
+        else if (module == 'notYourTurn')   this.updateNotYourTurn(settings,context);
+        else if (module == 'lockView')      this.updateLockView(settings,context);
+        else if (module == 'aboutTime')     this.updateAboutTime(settings,context);
     }
 
     keyPress(settings,context){
         if (this.active == false) return;
         const module = settings.module ? settings.module : 'fxmaster';
 
-        if (module == 'fxmaster')    
-            this.keyPressFxMaster(settings,context);
-        else if (module == 'gmscreen')
-            this.keyPressGMScreen(settings,context);
-        
+        if (module == 'fxmaster')           this.keyPressFxMaster(settings,context);
+        else if (module == 'gmscreen')      this.keyPressGMScreen(settings,context);
+        else if (module == 'triggerHappy')  this.keyPressTriggerHappy(settings,context);
+        else if (module == 'sharedVision')  this.keyPressSharedVision(settings,context);
+        else if (module == 'mookAI')        this.keyPressMookAI(settings,context);
+        else if (module == 'notYourTurn')   this.keyPressNotYourTurn(settings,context);
+        else if (module == 'lockView')      this.keyPressLockView(settings,context);
+        else if (module == 'aboutTime')     this.keyPressAboutTime(settings,context);
     }
 
     getModuleEnable(moduleId){
@@ -48,6 +57,7 @@ export class ExternalModules{
     //FxMaster
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     updateFxMaster(settings,context){
+        if (game.user.isGM == false) return;
         const fxmaster = game.modules.get("fxmaster");
         if (fxmaster == undefined || fxmaster.active == false) return;
 
@@ -115,8 +125,8 @@ export class ExternalModules{
             name = game.i18n.localize("MaterialDeck.FxMaster.Clear");
         }
 
-        if (displayIcon) streamDeck.setIcon(context,icon,background,ring,ringColor);
-        else streamDeck.setIcon(context, "", background,ring,ringColor);
+        if (displayIcon) streamDeck.setIcon(context,icon,{background:background,ring:ring,ringColor:ringColor});
+        else streamDeck.setIcon(context, "", {background:background,ring:ring,ringColor:ringColor});
         if (displayName == 0) name = ""; 
         streamDeck.setTitle(name,context);
     }
@@ -131,6 +141,7 @@ export class ExternalModules{
       }
 
     keyPressFxMaster(settings,context){
+        if (game.user.isGM == false) return;
         const fxmaster = game.modules.get("fxmaster");
         if (fxmaster == undefined || fxmaster.active == false) return;
 
@@ -248,6 +259,7 @@ export class ExternalModules{
 
     updateGMScreen(settings,context){
         if (this.getModuleEnable("gm-screen") == false) return;
+        if (game.user.isGM == false) return;
 
         const background = settings.gmScreenBackground ? settings.gmScreenBackground : '#000000';
         let ring = 1;
@@ -258,13 +270,432 @@ export class ExternalModules{
         if (this.gmScreenOpen) ring = 2;
         
         if (settings.displayGmScreenIcon) src = "fas fa-book-reader";
-        streamDeck.setIcon(context,src,background,ring,ringColor);
+        streamDeck.setIcon(context,src,{background:background,ring:ring,ringColor:ringColor});
         if (settings.displayGmScreenName) txt = game.i18n.localize(`GMSCR.gmScreen.Open`); 
         streamDeck.setTitle(txt,context);
     }
 
     keyPressGMScreen(settings,context){
         if (this.getModuleEnable("gm-screen") == false) return;
+        if (game.user.isGM == false) return;
         window['gm-screen'].toggleGmScreenVisibility();
     }
-}
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Trigger Happy
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    updateTriggerHappy(settings,context) {
+        if (this.getModuleEnable("trigger-happy") == false) return;
+        if (game.user.isGM == false) return;
+        
+        const displayName = settings.displayTriggerHappyName ? settings.displayTriggerHappyName : false;
+        const displayIcon = settings.displayTriggerHappyIcon ? settings.displayTriggerHappyIcon : false;
+
+        const background = "#340057";
+        const ringColor = game.settings.get("trigger-happy", "enableTriggers") ? "#A600FF" : "#340057";
+
+        let txt = '';
+        if (displayIcon) streamDeck.setIcon(context,"fas fa-grin-squint-tears",{background:background,ring:2,ringColor:ringColor});
+        else streamDeck.setIcon(context,'',{background:'#000000'});
+        if (displayName) txt = 'Trigger Happy';
+        
+        streamDeck.setTitle(txt,context);
+    }
+
+    keyPressTriggerHappy(settings,context){
+        if (this.getModuleEnable("trigger-happy") == false) return;
+        if (game.user.isGM == false) return;
+        const mode = settings.triggerHappyMode ? settings.triggerHappyMode : 'toggle';
+
+        let val = game.settings.get("trigger-happy", "enableTriggers");
+        if (mode == 'toggle') val = !val;
+        else if (mode == 'enable') val = true;
+        else if (mode == 'disable') val = false;
+
+        game.settings.set("trigger-happy", "enableTriggers", val);
+
+        const control = ui.controls.controls.find(c => c.name == 'token');
+        if (control == undefined) return;
+        let tool = control.tools.find(t => t.name == 'triggers');
+        if (tool == undefined) return;
+        tool.active = val;
+        ui.controls.render(); 
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Shared Vision
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    updateSharedVision(settings,context) {
+        if (this.getModuleEnable("SharedVision") == false) return;
+        if (game.user.isGM == false) return;
+        
+        const displayName = settings.sharedVisionName ? settings.sharedVisionName : false;
+        const displayIcon = settings.sharedVisionIcon ? settings.sharedVisionIcon : false;
+
+        const background = "#340057";
+        const ringColor = game.settings.get("SharedVision", "enable") ? "#A600FF" : "#340057";
+
+        let txt = '';
+        if (displayIcon) streamDeck.setIcon(context,"fas fa-eye",{background:background,ring:2,ringColor:ringColor});
+        else streamDeck.setIcon(context,'',{background:'#000000'});
+        if (displayName) txt = 'Shared Vision';
+        streamDeck.setTitle(txt,context);
+    }
+
+    keyPressSharedVision(settings,context) {
+        if (this.getModuleEnable("SharedVision") == false) return;
+        if (game.user.isGM == false) return;
+
+        const mode = settings.sharedVisionMode ? settings.sharedVisionMode : 'toggle';
+
+        if (mode == 'toggle') Hooks.call("setShareVision",{enable:'toggle'});
+        else if (mode == 'enable') Hooks.call("setShareVision",{enable:true});
+        else if (mode == 'disable') Hooks.call("setShareVision",{enable:false});
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Mook AI
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    updateMookAI(settings,context) {
+        if (this.getModuleEnable("mookAI") == false) return;
+        if (game.user.isGM == false) return;
+        
+        const displayName = settings.mookName ? settings.mookName : false;
+        const displayIcon = settings.mookIcon ? settings.mookIcon : false;
+
+        const background = "#000000";
+
+        let txt = '';
+        if (displayIcon) streamDeck.setIcon(context,"fas fa-brain",{background:'#000000'});
+        else streamDeck.setIcon(context,'',{background:'#000000'});
+        if (displayName) txt = 'Mook AI';
+        streamDeck.setTitle(txt,context);
+    }
+
+    async keyPressMookAI(settings,context) {
+        if (this.getModuleEnable("mookAI") == false) return;
+        if (game.user.isGM == false) return;
+        
+        let mook = await import('../../mookAI/scripts/mookAI.js');
+        let mookAI = new mook.MookAI ();
+        mookAI.takeNextTurn();
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Not Your Turn!
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    updateNotYourTurn(settings,context) {
+        
+        if (this.getModuleEnable("NotYourTurn") == false) return;
+        if (game.user.isGM == false) return;
+
+        const mode = settings.notYourTurnMode ? settings.notYourTurnMode : 'toggle';
+        const displayName = settings.notYourTurnName ? settings.notYourTurnName : false;
+        const displayIcon = settings.notYourTurnIcon ? settings.notYourTurnIcon : false;
+
+        const background = "#340057";
+        let ringColor = "#340057" ;
+
+        let txt = '';
+        let icon = '';
+        if (mode == 'toggle' || mode == 'enable' || mode == 'disable') {
+            icon = "fas fa-fist-raised";
+            txt = "Block Combat Movement";
+            ringColor = game.settings.get('NotYourTurn','enable') ?  "#A600FF": "#340057" ;
+        }
+        else {
+            icon = "fas fa-lock";
+            txt = "Block Non-Combat Movement";
+            ringColor = game.settings.get('NotYourTurn','nonCombat') ?  "#A600FF": "#340057" ;
+        }
+        if (displayIcon) streamDeck.setIcon(context,icon,{background:background,ring:2,ringColor:ringColor});
+        else streamDeck.setIcon(context,'',{background:'#000000'});
+        if (displayName == false) txt = '';
+        streamDeck.setTitle(txt,context);
+    }
+
+    async keyPressNotYourTurn(settings,context) {
+        if (this.getModuleEnable("NotYourTurn") == false) return;
+        if (game.user.isGM == false) return;
+
+        const mode = settings.notYourTurnMode ? settings.notYourTurnMode : 'toggle';
+
+        if (mode == 'toggle') Hooks.call("setNotYourTurn",{combat:'toggle'});
+        else if (mode == 'enable') Hooks.call("setNotYourTurn",{combat:true});
+        else if (mode == 'disable') Hooks.call("setNotYourTurn",{combat:false});
+        else if (mode == 'toggleNonCombat') Hooks.call("setNotYourTurn",{nonCombat:'toggle'});
+        else if (mode == 'enableNonCombat') Hooks.call("setNotYourTurn",{nonCombat:true});
+        else if (mode == 'disableNonCombat') Hooks.call("setNotYourTurn",{nonCombat:false});
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Lock View
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    updateLockView(settings,context) {
+        
+        if (this.getModuleEnable("LockView") == false) return;
+        if (game.user.isGM == false) return;
+
+        const mode = settings.lockViewMode ? settings.lockViewMode : 'panLock';
+        const displayName = settings.lockViewName ? settings.lockViewName : false;
+        const displayIcon = settings.lockViewIcon ? settings.lockViewIcon : false;
+
+        const background = "#340057";
+        let ringColor = "#340057" ;
+
+        let txt = '';
+        let icon = '';
+        if (mode == 'panLock') {
+            icon = "fas fa-arrows-alt";
+            txt = "Pan Lock";
+            ringColor = canvas.scene.getFlag('LockView', 'lockPan') ?  "#A600FF": "#340057" ;
+        }
+        else if (mode == 'zoomLock') {
+            icon = "fas fa-search-plus";
+            txt = "Zoom Lock";
+            ringColor = canvas.scene.getFlag('LockView', 'lockZoom') ?  "#A600FF": "#340057" ;
+        }
+        else if (mode == 'boundingBox') {
+            icon = "fas fa-box";
+            txt = "Bounding Box";
+            ringColor = canvas.scene.getFlag('LockView', 'boundingBox') ?  "#A600FF": "#340057" ;
+        }
+        
+        if (displayIcon) streamDeck.setIcon(context,icon,{background:background,ring:2,ringColor:ringColor});
+        else streamDeck.setIcon(context,'',{background:'#000000'});
+        if (displayName == false) txt = '';
+        streamDeck.setTitle(txt,context);
+    }
+
+    async keyPressLockView(settings,context) {
+        if (this.getModuleEnable("LockView") == false) return;
+        if (game.user.isGM == false) return;
+
+        const mode = settings.lockViewMode ? settings.lockViewMode : 'panLock';
+        let toggle = settings.lockViewToggle ? settings.lockViewToggle : 'toggle';
+        if (toggle == 'enable') toggle = true;
+        else if (toggle == 'disable') toggle = false;
+        let msg = {};
+
+        if (mode == 'panLock') msg = {panLock:toggle};
+        else if (mode == 'zoomLock') msg = {zoomLock:toggle};
+        else if (mode == 'boundingBox') msg = {boundingBox:toggle};
+
+        Hooks.call("setLockView",msg);
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //About Time
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    updateAboutTime(settings,context) {
+        if (this.getModuleEnable("about-time") == false) return;
+        if (game.user.isGM == false) return;
+
+        const displayTime = settings.aboutTimeDisplayTime ? settings.aboutTimeDisplayTime : 'none';
+        const displayDate = settings.aboutTimeDisplayDate ? settings.aboutTimeDisplayDate : 'none';
+        const background = settings.aboutTimeBackground ? settings.aboutTimeBackground : '#000000';
+        const ringOffColor = settings.aboutTimeOffRing ? settings.aboutTimeOffRing : '#000000';
+        const ringOnColor = settings.aboutTimeOnRing ? settings.aboutTimeOnRing : '#00FF00';
+
+        let ring = 0;
+        let ringColor = '#000000';
+        let txt = '';
+        let currentTime = game.Gametime.DTNow().longDateExtended();
+        let clock = 'none';
+
+        if (displayTime == 'clock') {
+            const hours = currentTime.hour > 12 ? currentTime.hour-12 : currentTime.hour;
+            clock = {
+                hours: hours,
+                minutes: currentTime.minute
+            }
+        }
+        else if (displayTime != 'none') {
+            let hours;
+            let AMPM = "";
+            if ((displayTime == 'compact12h' || displayTime == 'full12h' || displayTime == 'hours12h') && currentTime.hour > 12) {
+                hours = currentTime.hour - 12;
+                AMPM = " PM";
+            }
+            else if ((displayTime == 'compact12h' || displayTime == 'full12h' || displayTime == 'hours12h') && currentTime.hour <= 12) {
+                hours = currentTime.hour;
+                AMPM = " AM";
+            }
+            else {
+                hours = currentTime.hour;
+            }
+            if (displayTime == 'hours24h' || displayTime == 'hours12h') txt = hours;
+            else if (displayTime == 'minutes') txt = currentTime.minute;
+            else if (displayTime == 'seconds') txt = currentTime.second;
+            else {
+                if (currentTime.minute < 10) currentTime.minute = '0' + currentTime.minute;
+                if (currentTime.second < 10) currentTime.second = '0' + currentTime.second;
+                txt += hours + ':' + currentTime.minute;
+                if (displayTime == 'full24h' || displayTime == 'full12h') txt += ':' + currentTime.second;
+            }
+            if (displayTime == 'compact12h' || displayTime == 'full12h' || displayTime == 'hours12h') txt += AMPM;
+        }
+        if (displayTime != 'none' && displayTime != 'clock' && displayDate != 'none') txt += '\n';
+
+        if (displayDate == 'day') txt += currentTime.day;
+        else if (displayDate == 'dayName') txt += currentTime.dowString;
+        else if (displayDate == 'month') txt += currentTime.month;
+        else if (displayDate == 'monthName') txt += currentTime.monthString;
+        else if (displayDate == 'year') txt += currentTime.year;
+        else if (displayDate == 'small') txt += currentTime.day + '-' + currentTime.month;
+        else if (displayDate == 'smallInv') txt += currentTime.month + '-' + currentTime.day;
+        else if (displayDate == 'full') txt += currentTime.day + '-' + currentTime.month + '-' + currentTime.year;
+        else if (displayDate == 'fullInv') txt += currentTime.month + '-' + currentTime.day + '-' + currentTime.year;
+        else if (displayDate == 'text' || displayDate == 'textDay') {
+
+            if (displayDate == 'textDay') txt += currentTime.dowString + ' ';
+            txt += currentTime.day;
+            if (currentTime.day % 10 == 1 && currentTime != 11) txt += game.i18n.localize("MaterialDeck.AboutTime.First");
+            else if (currentTime.day % 10 == 2 && currentTime != 12) txt += game.i18n.localize("MaterialDeck.AboutTime.Second");
+            else if (currentTime.day % 10 == 3 && currentTime != 13) txt += game.i18n.localize("MaterialDeck.AboutTime.Third");
+            else txt += game.i18n.localize("MaterialDeck.AboutTime.Fourth");
+            txt += ' ' + game.i18n.localize("MaterialDeck.AboutTime.Of") + ' ' + currentTime.monthString + ', ' + currentTime.year;
+        }
+
+        if (settings.aboutTimeActive) {
+            const clockRunning = game.Gametime.isRunning();
+            ringColor = clockRunning ? ringOnColor : ringOffColor;
+            ring = 2;
+        }
+        
+        streamDeck.setTitle(txt,context);
+        streamDeck.setIcon(context,'',{background:background,ring:ring,ringColor:ringColor, clock:clock});
+    }
+
+    keyPressAboutTime(settings,context) {
+        if (this.getModuleEnable("about-time") == false) return;
+        if (game.user.isGM == false) return;
+
+        const onClick = settings.aboutTimeOnClick ? settings.aboutTimeOnClick : 'none';
+        if (onClick == 'none') return;
+        else if (onClick == 'startStop') {
+            const clockRunning = game.Gametime.isRunning();
+            const startMode = settings.aboutTimeStartStopMode ? settings.aboutTimeStartStopMode : 'toggle';
+            if ((startMode == 'toggle' && clockRunning) || startMode == 'stop') game.Gametime.stopRunning();
+            else if ((startMode == 'toggle' && !clockRunning) || startMode == 'start') game.Gametime.startRunning();
+        }
+        else if (onClick == 'advance') {
+            const advanceMode = settings.aboutTimeAdvanceMode ? settings.aboutTimeAdvanceMode : 'dawn';
+            let now = Gametime.DTNow();
+            if (advanceMode == 'dawn') {
+                let newDT = now.add({
+                    days: now.hours < 7 ? 0 : 1
+                }).setAbsolute({
+                    hours: 7,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'noon') {
+                let newDT = now.add({
+                    days: now.hours < 12 ? 0 : 1
+                }).setAbsolute({
+                    hours: 12,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'dusk') {
+                let newDT = now.add({
+                    days: now.hours < 20 ? 0 : 1
+                }).setAbsolute({
+                    hours: 20,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'midnight') {
+                let newDT = Gametime.DTNow().add({
+                    days: 1
+                }).setAbsolute({
+                    hours: 0,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == '1s') 
+                game.Gametime.advanceClock(1);
+            else if (advanceMode == '30s') 
+                game.Gametime.advanceClock(30);
+            
+            else if (advanceMode == '1m') 
+                game.Gametime.advanceTime({ minutes: 1 });
+            else if (advanceMode == '5m') 
+                game.Gametime.advanceTime({ minutes: 5 });
+            else if (advanceMode == '15m') 
+                game.Gametime.advanceTime({ minutes: 15 });
+            else if (advanceMode == '1h') 
+                game.Gametime.advanceTime({ hours: 1 });
+        }
+        else if (onClick == 'recede') {
+            const advanceMode = settings.aboutTimeAdvanceMode ? settings.aboutTimeAdvanceMode : 'dawn';
+            let now = Gametime.DTNow();
+            if (advanceMode == 'dawn') {
+                let newDT = now.add({
+                    days: now.hours < 7 ? -1 : 0
+                }).setAbsolute({
+                    hours: 7,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'noon') {
+                let newDT = now.add({
+                    days: now.hours < 12 ? -1 : 0
+                }).setAbsolute({
+                    hours: 12,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'dusk') {
+                let newDT = now.add({
+                    days: now.hours < 20 ? -1 : 0
+                }).setAbsolute({
+                    hours: 20,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == 'midnight') {
+                let newDT = Gametime.DTNow().add({
+                    days: -1
+                }).setAbsolute({
+                    hours: 0,
+                    minutes: 0,
+                    seconds: 0
+                });
+                Gametime.setAbsolute(newDT);
+            }
+            else if (advanceMode == '1s') 
+                game.Gametime.advanceClock(-1);
+            else if (advanceMode == '30s') 
+                game.Gametime.advanceClock(-30);
+            
+            else if (advanceMode == '1m') 
+                game.Gametime.advanceTime({ minutes: -1 });
+            else if (advanceMode == '5m') 
+                game.Gametime.advanceTime({ minutes: -5 });
+            else if (advanceMode == '15m') 
+                game.Gametime.advanceTime({ minutes: -15 });
+            else if (advanceMode == '1h') 
+                game.Gametime.advanceTime({ hours: -1 });
+        }
+    }
+}
+
+

src/macro.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class MacroControl{
     constructor(){
@@ -16,11 +17,12 @@ export class MacroControl{
         }
     }
 
-    update(settings,context){
+    async update(settings,context){
         this.active = true;
         const mode = settings.macroMode ? settings.macroMode : 'hotbar';
         const displayName = settings.displayName ? settings.displayName : false;
         const displayIcon = settings.displayIcon ? settings.displayIcon : false;
+        const displayUses = settings.displayUses ? settings.displayUses : false;
         let background = settings.background ? settings.background : '#000000';
         let macroNumber = settings.macroNumber;
         if (macroNumber == undefined || isNaN(parseInt(macroNumber))) macroNumber = 0;
@@ -30,8 +32,14 @@ export class MacroControl{
         let ring = 0;
         let name = "";
         let src = ""; 
+        let macroId = undefined;
+        let uses = undefined;
         
         if (mode == 'macroBoard') {  //Macro board
+            if ((MODULE.getPermission('MACRO','MACROBOARD') == false )) {
+                streamDeck.noPermission(context);
+                return;
+            }
             if (settings.macroBoardMode == 'offset') {  //Offset
                 const ringOffColor = settings.offRing ? settings.offRing : '#000000';
                 const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
@@ -45,23 +53,22 @@ export class MacroControl{
             else { //Execute macro
                 macroNumber += this.offset - 1;
                 if (macroNumber < 0) macroNumber = 0;
-                var macroId = game.settings.get(MODULE.moduleName,'macroSettings').macros[macroNumber];
+                macroId = game.settings.get(MODULE.moduleName,'macroSettings').macros[macroNumber];
                 background = game.settings.get(MODULE.moduleName,'macroSettings').color[macroNumber];
                 if (background == undefined) background = '#000000';
-                src = "";
-
-                if (macroId != undefined){
-                    let macro = game.macros._source.find(p => p._id == macroId);
-                    if (macro != undefined) {
-                        if (displayName) name += macro.name;
-                        if (displayIcon) src += macro.img;
-                    }
-                }
                 ring = 0;
             }  
         }
+        else if (mode == 'name') {  //macro by name
+            const macroName = settings.macroNumber;
+            const macro = game.macros.getName(macroName);
+            macroId = macro?.id;
+        }
         else { //Macro Hotbar
-            let macroId 
+            if ((MODULE.getPermission('MACRO','HOTBAR') == false )) {
+                streamDeck.noPermission(context);
+                return;
+            }
             if (mode == 'hotbar') macroId = game.user.data.hotbar[macroNumber];
             else {
                 let macros;
@@ -70,28 +77,37 @@ export class MacroControl{
                 else 
                     macros = game.macros.apps[0].macros;
                 if (macroNumber > 9) macroNumber = 0;
-                for (let j=0; j<10; j++){
-                    if (macros[j].key == macroNumber)
-                        macroId = (macros[j].macro == null) ? undefined : macros[j].macro._id; 
-                }
-            }
-            let src = "";
-            let name = "";
+                macroId = game.macros.apps[0].macros.find(m => m.key == macroNumber).macro?.id
+            }  
+        }
 
-            if (macroId != undefined){
-                let macro = game.macros._source.find(p => p._id == macroId);
-                if (macro != undefined) {
-                    if (displayName) name += macro.name;
-                    if (displayIcon) src += macro.img;
-                }
+        if (macroId != undefined){
+            let macro = game.macros._source.find(p => p._id == macroId);
+            
+            if (macro != undefined) {
+                if (displayName) name = macro.name;
+                if (displayIcon) src = macro.img;
+                if (MODULE.hotbarUses && displayUses) uses = await this.getUses(macro);
             }
         }
-        streamDeck.setIcon(context,src,background,ring,ringColor);
+        else {
+            if (displayName) name = "";
+            if (displayIcon) src = "modules/MaterialDeck/img/black.png";
+        }
+        
+        streamDeck.setIcon(context,src,{background:background,ring:ring,ringColor:ringColor,uses:uses});
         streamDeck.setTitle(name,context);
     }
 
-    hotbar(macros){
-        for (let i=0; i<32; i++){  
+    async getUses(macro) {
+        let hbUses = await import('../../illandril-hotbar-uses/scripts/item-system.js');
+        const command = macro.command;
+        const uses = await hbUses.calculateUses(command);
+        return uses;
+    }
+
+    async hotbar(macros){
+        for (let i=0; i<32; i++){ 
             const data = streamDeck.buttonContext[i];
             if (data == undefined || data.action != 'macro' || data.settings.macroMode == 'macroBoard') continue;
             
@@ -99,10 +115,16 @@ export class MacroControl{
             const mode = data.settings.macroMode ? data.settings.macroMode : 'hotbar';
             const displayName = data.settings.displayName ? data.settings.displayName : false;
             const displayIcon = data.settings.displayIcon ? data.settings.displayIcon : false;
+            const displayUses = data.settings.displayUses ? data.settings.displayUses : false;
             let background = data.settings.background ? data.settings.background : '#000000';
             let macroNumber = data.settings.macroNumber;
             if(macroNumber == undefined || isNaN(parseInt(macroNumber))) macroNumber = 1;
-            
+
+            if ((MODULE.getPermission('MACRO','HOTBAR') == false )) {
+                streamDeck.noPermission(context);
+                return;
+            } 
+
             let src = "";
             let name = "";
 
@@ -114,20 +136,17 @@ export class MacroControl{
             }
             else {
                 if (macroNumber > 9) macroNumber = 0;
-                for (let j=0; j<10; j++){
-                    if (macros[j].key == macroNumber){
-                        if (macros[j].macro == null) macroId == undefined;
-                        else macroId = macros[j].macro._id;
-                    }  
-                }
+                macroId = game.macros.apps[0].macros.find(m => m.key == macroNumber).macro?.id
             }
             let macro = undefined;
+            let uses = undefined;
             if (macroId != undefined) macro = game.macros._source.find(p => p._id == macroId);
             if (macro != undefined && macro != null) {
                 if (displayName) name += macro.name;
                 if (displayIcon) src += macro.img;
+                if (MODULE.hotbarUses && displayUses) uses = await this.getUses(macro);
             }
-            streamDeck.setIcon(context,src,background);
+            streamDeck.setIcon(context,src,{background:background,uses:uses});
             streamDeck.setTitle(name,context);
         }
     }
@@ -136,10 +155,46 @@ export class MacroControl{
         const mode = settings.macroMode ? settings.macroMode : 'hotbar';
         let macroNumber = settings.macroNumber;
         if(macroNumber == undefined || isNaN(parseInt(macroNumber))) macroNumber = 0;
+        let target = settings.target ? settings.target : undefined;
+        //const targetActor = target.actor ? undefined : target;
+        //if (targetActor != undefined) target = undefined;
         
-        if (mode == 'hotbar' || mode == 'visibleHotbar' || mode == 'customHotbar')
+        //let macroTarget = {
+        //    token: target,
+        //    actor: targetActor
+        //}
+        //console.log('target',macroTarget,mode);
+        
+        if (mode == 'hotbar' || mode == 'visibleHotbar' || mode == 'customHotbar'){
+            if ((MODULE.getPermission('MACRO','HOTBAR') == false )) return;
             this.executeHotbar(macroNumber,mode);
+        } 
+        else if (mode == 'name') {
+            if ((MODULE.getPermission('MACRO','BY_NAME') == false )) return;
+            const macroName = settings.macroNumber;
+            const macro = game.macros.getName(macroName);
+
+            if (macro == undefined) return;
+           
+            const args = settings.macroArgs ? settings.macroArgs : "";
+
+            let furnaceEnabled = false;
+            let furnace = game.modules.get("furnace");
+            if (furnace != undefined && furnace.active && compatibleCore("0.8.1")==false) furnaceEnabled = true;
+            if (args == "" || args == " ") furnaceEnabled = false;
+            if (furnaceEnabled == false) macro.execute({token:target});
+            else {
+                let chatData = {
+                    user: game.user._id,
+                    speaker: ChatMessage.getSpeaker(),
+                    content: "/'" + macro.name + "' " + args
+                };
+                ChatMessage.create(chatData, {});
+            }
+
+        }
         else {
+            if ((MODULE.getPermission('MACRO','MACROBOARD') == false )) return;
             if (settings.macroBoardMode == 'offset') {
                 let macroOffset = settings.macroOffset;
                 if (macroOffset == undefined) macroOffset = 0;
@@ -161,12 +216,7 @@ export class MacroControl{
             }
             else macros = game.macros.apps[0].macros;
             if (macroNumber > 9) macroNumber = 0;
-            for (let j=0; j<10; j++){
-                if (macros[j].key == macroNumber){
-                    if (macros[j].macro == null) macroId == undefined;
-                    else macroId = macros[j].macro._id; 
-                }
-            }
+            macroId = game.macros.apps[0].macros.find(m => m.key == macroNumber).macro?.id
         }
         if (macroId == undefined) return;
         let macro = game.macros.get(macroId);
@@ -185,7 +235,7 @@ export class MacroControl{
                 const args = game.settings.get(MODULE.moduleName,'macroSettings').args;
                 let furnaceEnabled = false;
                 let furnace = game.modules.get("furnace");
-                if (furnace != undefined && furnace.active) furnaceEnabled = true;
+                if (furnace != undefined && furnace.active && compatibleCore("0.8.1")==false) furnaceEnabled = true;
                 if (args == undefined || args[macroNumber] == undefined || args[macroNumber] == "") furnaceEnabled = false;
                 if (furnaceEnabled == false) macro.execute();
                 else {
@@ -199,14 +249,4 @@ export class MacroControl{
             }
         }
     }
-}
-
-
-
-
-
-
-
-
-
-
+}

src/misc.js

@@ -1,6 +1,16 @@
 import * as MODULE from "../MaterialDeck.js";
 import {macroControl,soundboard,playlistControl} from "../MaterialDeck.js";
 
+export function compatibleCore(compatibleVersion){
+    let coreVersion = game.data.version;
+    coreVersion = coreVersion.split(".");
+    compatibleVersion = compatibleVersion.split(".");
+    if (compatibleVersion[0] > coreVersion[0]) return false;
+    if (compatibleVersion[1] > coreVersion[1]) return false;
+    if (compatibleVersion[2] > coreVersion[2]) return false;
+    return true;
+}
+
 export class playlistConfigForm extends FormApplication {
     constructor(data, options) {
         super(data, options);
@@ -17,7 +27,8 @@ export class playlistConfigForm extends FormApplication {
             title: "Material Deck: "+game.i18n.localize("MaterialDeck.Sett.PlaylistConfig"),
             template: "./modules/MaterialDeck/templates/playlistConfig.html",
             classes: ["sheet"],
-            width: 500
+            width: 500,
+            height: "auto"
         });
     }
 
@@ -25,6 +36,10 @@ export class playlistConfigForm extends FormApplication {
      * Provide data to the template
      */
     getData() {
+        if (MODULE.getPermission('PLAYLIST','CONFIGURE') == false ) {
+            ui.notifications.warn(game.i18n.localize("MaterialDeck.Notifications.Playlist.NoPermission"));
+            return;
+        }
         //Get the playlist settings
         let settings = game.settings.get(MODULE.moduleName,'playlists');
 
@@ -61,7 +76,7 @@ export class playlistConfigForm extends FormApplication {
         }
  
         return {
-            playlists: game.playlists.entities,
+            playlists: compatibleCore("0.8.1") ? game.playlists.contents : game.playlists.entities,
             numberOfPlaylists: numberOfPlaylists,
             playlistData: playlistData,
             playMode: playMode
@@ -109,9 +124,19 @@ export class playlistConfigForm extends FormApplication {
     }
 
     async updateSettings(settings,render){
-        await game.settings.set(MODULE.moduleName,'playlists', settings);
-        if (MODULE.enableModule) playlistControl.updateAll();
-        if (render) this.render();
+        if (game.user.isGM) {
+            await game.settings.set(MODULE.moduleName,'playlists', settings);
+            if (MODULE.enableModule) playlistControl.updateAll();
+            if (render) this.render();
+        }
+        else {
+            const payload = {
+                "msgType": "playlistUpdate", 
+                "settings": settings,
+                "render": render
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+        }
     }
 }
 
@@ -139,6 +164,10 @@ export class macroConfigForm extends FormApplication {
      * Provide data to the template
      */
     getData() {
+        if (MODULE.getPermission('MACRO','MACROBOARD_CONFIGURE') == false ) {
+            ui.notifications.warn(game.i18n.localize("MaterialDeck.Notifications.Macroboard.NoPermission"));
+            return;
+        }
         //Get the settings
         var selectedMacros = game.settings.get(MODULE.moduleName,'macroSettings').macros;
         var color = game.settings.get(MODULE.moduleName,'macroSettings').color;
@@ -153,7 +182,7 @@ export class macroConfigForm extends FormApplication {
         let furnaceEnabled = false;
         let height = 95;
         let furnace = game.modules.get("furnace");
-        if (furnace != undefined && furnace.active) {
+        if (furnace != undefined && furnace.active && compatibleCore("0.8.1")==false) {
             furnaceEnabled = true;
             height += 50;
         }
@@ -204,7 +233,7 @@ export class macroConfigForm extends FormApplication {
             }
             macroData.push({dataThis: macroThis});
         }
-
+        
         return {
             height: height,
             macros: game.macros,
@@ -252,8 +281,17 @@ export class macroConfigForm extends FormApplication {
     }
 
     async updateSettings(settings){
-        await game.settings.set(MODULE.moduleName,'macroSettings',settings);
-        if (MODULE.enableModule) macroControl.updateAll();
+        if (game.user.isGM) {
+            await game.settings.set(MODULE.moduleName,'macroSettings',settings);
+            if (MODULE.enableModule) macroControl.updateAll();
+        }
+        else {
+            const payload = {
+                "msgType": "macroboardUpdate", 
+                "settings": settings
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+        }
     }
 }
 
@@ -285,6 +323,11 @@ export class soundboardConfigForm extends FormApplication {
      * Provide data to the template
      */
     getData() {
+        if (MODULE.getPermission('SOUNDBOARD','CONFIGURE') == false ) {
+            ui.notifications.warn(game.i18n.localize("MaterialDeck.Notifications.Soundboard.NoPermission"));
+            return;
+        }
+
         //Get the settings
         this.settings = game.settings.get(MODULE.moduleName,'soundboardSettings');
 
@@ -303,9 +346,11 @@ export class soundboardConfigForm extends FormApplication {
         let playlists = [];
         playlists.push({id:"none",name:game.i18n.localize("MaterialDeck.None")});
         playlists.push({id:"FP",name:game.i18n.localize("MaterialDeck.FilePicker")})
-        for (let i=0; i<game.playlists.entities.length; i++){
-            playlists.push({id:game.playlists.entities[i]._id,name:game.playlists.entities[i].name});
-        }
+        
+        const playlistArray = compatibleCore("0.8.1") ? game.playlists.contents : game.playlists.entities;
+        for (let playlist of playlistArray) 
+            playlists.push({id: playlist.id, name: playlist.name})
+        
         this.playlists = playlists;
 
         //Check what SD model the user is using, and set the number of rows and columns to correspond
@@ -344,20 +389,30 @@ export class soundboardConfigForm extends FormApplication {
                 else if (this.settings.selectedPlaylists[iteration] == 'FP') selectedPlaylist = 'FP';
                 else {
                     //Get the playlist
-                    const pl = game.playlists.entities.find(p => p._id == this.settings.selectedPlaylists[iteration]);
+                    const playlistArray = compatibleCore("0.8.1") ? game.playlists.contents : game.playlists.entities;
+                    let pl = playlistArray.find(p => p.id == this.settings.selectedPlaylists[iteration])
+
                     if (pl == undefined){
                         selectedPlaylist = 'none';
                         sounds = [];
                     }
                     else {
                         //Add the sound name and id to the sounds array
-                        for (let i=0; i<pl.sounds.length; i++)
-                            sounds.push({
-                                name: pl.sounds[i].name,
-                                id: pl.sounds[i]._id
-                            });
+                        if (compatibleCore("0.8.1"))
+                            for (let sound of pl.sounds.contents)
+                                sounds.push({
+                                    name: sound.name,
+                                    id: sound.id
+                                });
+                        else {
+                            for (let sound of pl.sounds)
+                                sounds.push({
+                                    name: sound.name,
+                                    id: sound._id
+                                });
+                        }        
                         //Get the playlist id
-                        selectedPlaylist = pl._id;
+                        selectedPlaylist = pl.id;
                     }  
                 }
 
@@ -457,8 +512,9 @@ export class soundboardConfigForm extends FormApplication {
                     //Show the sound selector
                     document.querySelector(`#ss${iteration}`).style='';
 
-                    const pl = game.playlists.entities.find(p => p._id == event.target.value);
-                    selectedPlaylist = pl._id;
+                    const playlistArray = compatibleCore("0.8.1") ? game.playlists.contents : game.playlists.entities;
+                    const pl = playlistArray.find(p => p.id == event.target.value)
+                    selectedPlaylist = pl.id;
 
                     //Get the sound select element
                     let SSpicker = document.getElementById(`soundSelect${iteration}`);
@@ -472,12 +528,20 @@ export class soundboardConfigForm extends FormApplication {
                     optionNone.innerHTML = game.i18n.localize("MaterialDeck.None");
                     SSpicker.appendChild(optionNone);
 
-                    for (let i=0; i<pl.sounds.length; i++){
-                        let newOption = document.createElement('option');
-                        newOption.value = pl.sounds[i]._id;
-                        newOption.innerHTML = pl.sounds[i].name;
-                        SSpicker.appendChild(newOption);
-                    }
+                    if (compatibleCore("0.8.1"))
+                        for (let sound of pl.sounds.contents) {
+                            let newOption = document.createElement('option');
+                            newOption.value = sound.id;
+                            newOption.innerHTML = sound.name;
+                            SSpicker.appendChild(newOption);
+                        } 
+                    else 
+                        for (let sound of pl.sounds) {
+                            let newOption = document.createElement('option');
+                            newOption.value = sound._id;
+                            newOption.innerHTML = sound.name;
+                            SSpicker.appendChild(newOption);
+                        }        
                 }
 
                 //Save the new playlist to this.settings, and update the settings
@@ -530,7 +594,16 @@ export class soundboardConfigForm extends FormApplication {
     }
     
     async updateSettings(settings){
-        await game.settings.set(MODULE.moduleName,'soundboardSettings',settings);
-        if (MODULE.enableModule) soundboard.updateAll();
+        if (game.user.isGM) {
+            await game.settings.set(MODULE.moduleName,'soundboardSettings',settings);
+            if (MODULE.enableModule) soundboard.updateAll();
+        }
+        else {
+            const payload = {
+                "msgType": "soundboardUpdate", 
+                "settings": settings
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+        }
     }
 }

src/move.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class Move{
     constructor(){
@@ -11,6 +12,11 @@ export class Move{
         const mode = settings.mode ? settings.mode : 'canvas';
         const type = settings.type ? settings.type : 'move';
 
+        if ((MODULE.getPermission('MOVE','TOKEN') == false && mode == 'selectedToken') || (MODULE.getPermission('MOVE','CANVAS') == false && mode == 'canvas')) {
+            streamDeck.noPermission(context);
+            return;
+        }
+
         let url = '';
         if (mode == 'canvas' || (mode == 'selectedToken' && type == 'move')){
             const dir = settings.dir ? settings.dir : 'center';
@@ -44,15 +50,35 @@ export class Move{
             else
                 url = "modules/MaterialDeck/img/move/rotateccw.png";
         }
-        streamDeck.setIcon(context,url,background);
+        streamDeck.setIcon(context,url,{background:background});
+        streamDeck.setTitle('',context);
     }
 
     keyPress(settings){
         if (canvas.scene == null) return;
+        if ((MODULE.getPermission('MOVE','TOKEN') == false && mode == 'selectedToken') || (MODULE.getPermission('MOVE','CANVAS') == false && mode == 'canvas')) {
+            streamDeck.noPermission(context);
+            return;
+        }
+
         const dir = settings.dir ? settings.dir : 'center';
         const mode = settings.mode ? settings.mode : 'canvas';
         const type = settings.type ? settings.type : 'move';
 
+        let token;
+        if (mode == 'selectedToken') {
+            const selection = settings.selection ? settings.selection : 'selected';
+            const tokenIdentifier = settings.tokenName ? settings.tokenName : '';
+    
+            if (selection == 'selected') token = canvas.tokens.children[0].children.find(p => p.id == MODULE.selectedTokenId);
+            else if (selection != 'selected' && tokenIdentifier == '') {}
+            else if (selection == 'tokenName') token = canvas.tokens.children[0].children.find(p => p.name == tokenIdentifier);
+            else if (selection == 'actorName') token = canvas.tokens.children[0].children.find(p => p.actor.name == tokenIdentifier);
+            else if (selection == 'tokenId') token = canvas.tokens.children[0].children.find(p => p.id == tokenIdentifier);
+            else if (selection == 'actorId') token = canvas.tokens.children[0].children.find(p => p.actor.id == tokenIdentifier);
+            if (token == undefined) return;
+        }
+
         if (type == 'move'){
             if (dir ==  'zoomIn') {//zoom in
                 let viewPosition = canvas.scene._viewPosition;
@@ -68,15 +94,12 @@ export class Move{
             }
             else {
                 if (settings.mode == 'selectedToken')
-                    this.moveToken(MODULE.selectedTokenId,dir);
+                    this.moveToken(token,dir);
                 else    
                     this.moveCanvas(dir);
             }
         }
         else if (type == 'rotate' && mode == 'selectedToken'){
-            const token = canvas.tokens.children[0].children.find(p => p.id == MODULE.selectedTokenId);
-            if (token == undefined) return;
-
             const rotType = settings.rot ? settings.rot : 'to';
             const value = isNaN(parseInt(settings.rotValue)) ? 0 : parseInt(settings.rotValue);
 
@@ -84,13 +107,13 @@ export class Move{
             if (rotType == 'by') rotationVal = token.data.rotation + value;
             else if (rotType == 'to') rotationVal = value;
             
-            token.update({rotation: rotationVal});
+            if (compatibleCore("0.8.1")) token.document.update({rotation: rotationVal});
+            else token.update({rotation: rotationVal});
+            //token.rotate(rotationVal,false)
         }
     }
 
-    async moveToken(tokenId,dir){
-        if (tokenId == undefined) return;
-        const token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
+    async moveToken(token,dir){
         const gridSize = canvas.scene.data.grid;
         let x = token.x;
         let y = token.y;
@@ -120,7 +143,8 @@ export class Move{
             canvas.animatePan(location);
         }
         if (game.user.isGM == false && (token.can(game.user,"control") == false || token.checkCollision(token.getCenter(x, y)))) return;
-        token.update({x:x,y:y});
+        if (compatibleCore("0.8.1")) token.document.update({x:x,y:y});
+        else token.update({x:x,y:y});
     };
 
     moveCanvas(dir){

src/othercontrols.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class OtherControls{
     constructor(){
@@ -7,37 +8,39 @@ export class OtherControls{
         this.rollData = {};
     }
 
-    async updateAll(){
+    async updateAll(options={}){
         if (this.active == false) return;
         for (let i=0; i<32; i++){   
             const data = streamDeck.buttonContext[i];
             if (data == undefined || data.action != 'other') continue;
-            await this.update(data.settings,data.context);
+            await this.update(data.settings,data.context,options);
         }
     }
 
-    update(settings,context){
+    update(settings,context,options={}){
         this.active = true;
         const mode = settings.otherMode ? settings.otherMode : 'pause';
 
         if (mode == 'pause')    //pause
-            this.updatePause(settings,context);
+            this.updatePause(settings,context,options);
         else if (mode == 'controlButtons')    //control buttons
-            this.updateControl(settings,context);
+            this.updateControl(settings,context,options);
         else if (mode == 'darkness')   //darkness
-            this.updateDarkness(settings,context);
+            this.updateDarkness(settings,context,options);
         else if (mode == 'rollDice')    //roll dice
-            this.updateRollDice(settings,context);
+            this.updateRollDice(settings,context,options);
         else if (mode == 'rollTables')    //roll tables
-            this.updateRollTable(settings,context);
+            this.updateRollTable(settings,context,options);
         else if (mode == 'sidebarTab')    //open sidebar tab
-            this.updateSidebar(settings,context);
+            this.updateSidebar(settings,context,options);
+        else if (mode == 'compendiumBrowser')    //open compendium browser
+            this.updateCompendiumBrowser(settings,context,options);
         else if (mode == 'compendium')    //open compendium
-            this.updateCompendium(settings,context);
+            this.updateCompendium(settings,context,options);
         else if (mode == 'journal')    //open journal
-            this.updateJournal(settings,context);
+            this.updateJournal(settings,context,options);
         else if (mode == 'chatMessage')
-            this.updateChatMessage(settings,context);
+            this.updateChatMessage(settings,context,options);
     }
 
     keyPress(settings,context){
@@ -55,6 +58,8 @@ export class OtherControls{
             this.keyPressRollTable(settings);
         else if (mode == 'sidebarTab')    //sidebar
             this.keyPressSidebar(settings);
+        else if (mode == 'compendiumBrowser')    //open compendium browser
+            this.keyPressCompendiumBrowser(settings);
         else if (mode == 'compendium')    //open compendium
             this.keyPressCompendium(settings);
         else if (mode == 'journal')    //open journal
@@ -65,7 +70,12 @@ export class OtherControls{
 
     //////////////////////////////////////////////////////////////////////////////////////////////////
 
-    updatePause(settings,context){
+    updatePause(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','PAUSE') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
+
         let src = "";
         const pauseFunction = settings.pauseFunction ? settings.pauseFunction : 'pause';
         const background = settings.background ? settings.background : '#000000';
@@ -81,28 +91,35 @@ export class OtherControls{
         }
         else if (pauseFunction == 'toggle')  //toggle
             src = 'modules/MaterialDeck/img/other/pause/playpause.png';
-        streamDeck.setIcon(context,src,background,2,ringColor,true);
+        streamDeck.setIcon(context,src,{background:background,ring:2,ringColor:ringColor,overlay:true});
+        streamDeck.setTitle('',context);
     }
 
     keyPressPause(settings){
+        if (MODULE.getPermission('OTHER','PAUSE') == false ) return;
+        
         const pauseFunction = settings.pauseFunction ? settings.pauseFunction : 'pause';
 
         if (pauseFunction == 'pause'){ //Pause game
             if (game.paused) return; 
-            game.togglePause();
+            game.togglePause(true,true);
         }
         else if (pauseFunction == 'resume'){ //Resume game
             if (game.paused == false) return; 
-            game.togglePause();
+            game.togglePause(false,true);
         }
         else if (pauseFunction == 'toggle') { //toggle
-            game.togglePause();
+            game.togglePause(!game.paused,true);
         }
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////
     
-    updateControl(settings,context){
+    updateControl(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','CONTROL') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const control = settings.control ? settings.control : 'dispControls';
         const tool = settings.tool ?  settings.tool : 'open';
         let background = settings.background ? settings.background : '#000000';
@@ -118,6 +135,10 @@ export class OtherControls{
             controlNr--;
 
             const selectedControl = ui.controls.controls[controlNr];
+            if (selectedControl.visible == false) {
+                streamDeck.noPermission(context,false);
+                return;
+            }
             if (selectedControl != undefined){
                 if (tool == 'open'){  //open category
                     txt = game.i18n.localize(selectedControl.title);
@@ -136,6 +157,10 @@ export class OtherControls{
             if (selectedControl != undefined){
                 const selectedTool = selectedControl.tools[controlNr];
                 if (selectedTool != undefined){
+                    if (selectedControl.visible == false || selectedTool.visible == false) {
+                        streamDeck.noPermission(context,false);
+                        return;
+                    }
                     txt = game.i18n.localize(selectedTool.title);
                     src = selectedTool.icon;
                     if (selectedTool.toggle){
@@ -150,6 +175,10 @@ export class OtherControls{
         else {  // specific control/tool
             const selectedControl = ui.controls.controls.find(c => c.name == control);
             if (selectedControl != undefined){
+                if (selectedControl.visible == false) {
+                    streamDeck.noPermission(context,false);
+                    return;
+                }
                 if (tool == 'open'){  //open category
                         txt = game.i18n.localize(selectedControl.title);
                         src = selectedControl.icon;
@@ -159,6 +188,10 @@ export class OtherControls{
                 else {
                     const selectedTool = selectedControl.tools.find(t => t.name == tool);
                     if (selectedTool != undefined){
+                        if (selectedTool.visible == false) {
+                            streamDeck.noPermission(context,false);
+                            return;
+                        }
                         txt = game.i18n.localize(selectedTool.title);
                         src = selectedTool.icon;
                         if (selectedTool.toggle){
@@ -171,11 +204,12 @@ export class OtherControls{
                 }
             }
         }
-        streamDeck.setIcon(context,src,background,2,ringColor);
+        streamDeck.setIcon(context,src,{background:background,ring:2,ringColor:ringColor});
         streamDeck.setTitle(txt,context);
     }
 
     keyPressControl(settings){
+        if (MODULE.getPermission('OTHER','CONTROL') == false ) return;
         if (canvas.scene == null) return;
         const control = settings.control ? settings.control : 'dispControls';
         const tool = settings.tool ?  settings.tool : 'open';
@@ -186,6 +220,10 @@ export class OtherControls{
             controlNr--;
             const selectedControl = ui.controls.controls[controlNr];
             if (selectedControl != undefined){
+                if (selectedControl.visible == false) {
+                    streamDeck.noPermission(context,false);
+                    return;
+                }
                 ui.controls.activeControl = 'token';
                 selectedControl.activeTool = selectedControl.activeTool;
                 canvas.getLayer(selectedControl.layer).activate();
@@ -197,8 +235,16 @@ export class OtherControls{
             controlNr--;
             const selectedControl = ui.controls.controls.find(c => c.name == ui.controls.activeControl);
             if (selectedControl != undefined){
+                if (selectedControl.visible == false) {
+                    streamDeck.noPermission(context,false);
+                    return;
+                }
                 const selectedTool = selectedControl.tools[controlNr];
                 if (selectedTool != undefined){
+                    if (selectedTool.visible == false) {
+                        streamDeck.noPermission(context,false);
+                        return;
+                    }
                     if (selectedTool.toggle) {
                         selectedTool.active = !selectedTool.active;
                         selectedTool.onClick(selectedTool.active);
@@ -214,6 +260,10 @@ export class OtherControls{
         else {  //select control
             const selectedControl = ui.controls.controls.find(c => c.name == control);
             if (selectedControl != undefined){
+                if (selectedControl.visible == false) {
+                    streamDeck.noPermission(context,false);
+                    return;
+                }
                 if (tool == 'open'){  //open category
                     ui.controls.activeControl = 'token';
                     selectedControl.activeTool = selectedControl.activeTool;
@@ -222,6 +272,10 @@ export class OtherControls{
                 else {
                     const selectedTool = selectedControl.tools.find(t => t.name == tool);
                     if (selectedTool != undefined){
+                        if (selectedTool.visible == false) {
+                            streamDeck.noPermission(context,false);
+                            return;
+                        }
                         ui.controls.activeControl = control;
                         canvas.getLayer(selectedControl.layer).activate();
                         if (selectedTool.toggle) {
@@ -242,7 +296,11 @@ export class OtherControls{
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    updateDarkness(settings,context){
+    updateDarkness(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','DARKNESS') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const func = settings.darknessFunction ? settings.darknessFunction : 'value';
         const value = parseFloat(settings.darknessValue) ? parseFloat(settings.darknessValue) : 0;
         const background = settings.background ? settings.background : '#000000';
@@ -263,11 +321,12 @@ export class OtherControls{
             txt += darkness;
         }
         streamDeck.setTitle(txt,context);
-        streamDeck.setIcon(context,src,background);
+        streamDeck.setIcon(context,src,{background:background});
     }
 
     keyPressDarkness(settings) {
         if (canvas.scene == null) return;
+        if (MODULE.getPermission('OTHER','DARKNESS') == false ) return;
         const func = settings.darknessFunction ? settings.darknessFunction : 'value';
         const value = parseFloat(settings.darknessValue) ? parseFloat(settings.darknessValue) : 0;
 
@@ -283,17 +342,22 @@ export class OtherControls{
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    updateRollDice(settings,context){
+    updateRollDice(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','DICE') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const background = settings.background ? settings.background : '#000000';
         let txt = '';
 
         if (settings.displayDiceName) txt = 'Roll: ' + settings.rollDiceFormula;
 
         streamDeck.setTitle(txt,context);
-        streamDeck.setIcon(context,'',background);
+        streamDeck.setIcon(context,'',{background:background});
     }
 
     keyPressRollDice(settings,context){
+        if (MODULE.getPermission('OTHER','DICE') == false ) return;
         if (settings.rollDiceFormula == undefined || settings.rollDiceFormula == '') return;
         const rollFunction = settings.rollDiceFunction ? settings.rollDiceFunction : 'public';
 
@@ -330,12 +394,17 @@ export class OtherControls{
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    updateRollTable(settings,context){
+    updateRollTable(settings,context,options={}){
         const name = settings.rollTableName;
         if (name == undefined) return;
+        if (MODULE.getPermission('OTHER','TABLES') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
 
         const background = settings.background ? settings.background : '#000000';
-        const table = game.tables.entities.find(p=>p.name == name);
+        const table = game.tables.getName(name);
+
         let txt = settings.displayRollName ? table.name : '';
         let src = settings.displayRollIcon ? table.data.img : '';
 
@@ -343,19 +412,27 @@ export class OtherControls{
             src = '';
             txt = '';
         }
+        else {
+            if (table.permission < 2 && MODULE.getPermission('OTHER','TABLES_ALL') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
+        }
 
         streamDeck.setTitle(txt,context);
-        streamDeck.setIcon(context,src,background);
+        streamDeck.setIcon(context,src,{background:background});
     }
 
     keyPressRollTable(settings){
+        if (MODULE.getPermission('OTHER','TABLES') == false ) return;
         const name = settings.rollTableName;
         if (name == undefined) return;
 
         const func = settings.rolltableFunction ? settings.rolltableFunction : 'open';
-        const table = game.tables.entities.find(p=>p.name == name);
+        const table = game.tables.getName(name);
 
         if (table != undefined) {
+            if (table.permission < 2 && MODULE.getPermission('OTHER','TABLES_ALL') == false ) return;
             if (func == 'open'){ //open
                 const element = document.getElementById(table.sheet.id);
                 if (element == null) table.sheet.render(true);
@@ -402,40 +479,95 @@ export class OtherControls{
         return icon;
     }
     
-    updateSidebar(settings,context){
+    updateSidebar(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','SIDEBAR') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
+        const popOut = settings.sidebarPopOut ? settings.sidebarPopOut : false;
         const sidebarTab = settings.sidebarTab ? settings.sidebarTab : 'chat';
         const background = settings.background ? settings.background : '#000000';
         const collapsed = ui.sidebar._collapsed;
+        const activeTab = ui.sidebar.activeTab;
         const ringOffColor = settings.offRing ? settings.offRing : '#000000';
         const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
-        const ringColor = (sidebarTab == 'collapse' && collapsed) ? ringOnColor : ringOffColor;
+        let ringColor = ringOffColor;
+        if (popOut && options.sidebarTab == sidebarTab) {
+            ringColor = options.renderPopout ? ringOnColor : ringOffColor;
+        }
+        else ringColor = (sidebarTab == 'collapse' && collapsed || (activeTab == sidebarTab)) ? ringOnColor : ringOffColor;
         const name = settings.displaySidebarName ? this.getSidebarName(sidebarTab) : '';
         const icon = settings.displaySidebarIcon ? this.getSidebarIcon(sidebarTab) : '';
 
         streamDeck.setTitle(name,context);
-        streamDeck.setIcon(context,icon,background,2,ringColor);
+        streamDeck.setIcon(context,icon,{background:background,ring:2,ringColor:ringColor});
     }
 
     keyPressSidebar(settings){
+        if (MODULE.getPermission('OTHER','SIDEBAR') == false ) return;
         const sidebarTab = settings.sidebarTab ? settings.sidebarTab : 'chat';
+        const popOut = settings.sidebarPopOut ? settings.sidebarPopOut : false;
         
         if (sidebarTab == 'collapse'){
             const collapsed = ui.sidebar._collapsed;
             if (collapsed) ui.sidebar.expand();
             else if (collapsed == false) ui.sidebar.collapse();
         }
-        else ui.sidebar.activateTab(sidebarTab);
+        else if (popOut == false) ui.sidebar.activateTab(sidebarTab);
+        else {
+            const element = document.getElementById(sidebarTab+"-popout");
+            if (element == null) ui?.[sidebarTab].renderPopout();
+            else element.getElementsByClassName("close")[0].click();
+        }
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    updateCompendium(settings,context){
+    updateCompendiumBrowser(settings,context,options={}){
+        let rendered = options.renderCompendiumBrowser;
+        if (rendered == undefined && game.system.id == "pf2e") rendered = (document.getElementById("app-1") != null);
+        else if (rendered == undefined) rendered = (document.getElementById("compendium-popout") != null);
+        const background = settings.background ? settings.background : '#000000';
+        const ringOffColor = settings.offRing ? settings.offRing : '#000000';
+        const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
+        const ringColor = rendered ? ringOnColor : ringOffColor;
+        const txt = settings.displayCompendiumName ? name : '';
+
+        streamDeck.setTitle(txt,context);
+        streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
+    }
+
+    keyPressCompendiumBrowser(settings){
+        let element = null;
+        if (game.system.id == "pf2e") element = document.getElementById("app-1")
+        else element = document.getElementById("compendium-popout");
+        const rendered = (element != null);
+
+        if (rendered) 
+            element.getElementsByClassName("close")[0].click();
+        else if (game.system.id == "pf2e")
+            document.getElementsByClassName("compendium-browser-btn")[0].click()
+        else
+            ui.compendium.renderPopout();
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////////////
+
+    updateCompendium(settings,context,options={}){
         const name = settings.compendiumName;
         if (name == undefined) return;
-
-        const compendium = game.packs.entries.find(p=>p.metadata.label == name);
+        if (MODULE.getPermission('OTHER','COMPENDIUM') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
+        let compendium;
+        if (compatibleCore("0.8.1"))    compendium = game.packs.contents.find(p=>p.metadata.label == name)?.apps[0];
+        else                            compendium = game.packs.entries.find(p=>p.metadata.label == name);
         if (compendium == undefined) return;
-
+        if (compendium.private && MODULE.getPermission('OTHER','COMPENDIUM_ALL') == false) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const background = settings.background ? settings.background : '#000000';
         const ringOffColor = settings.offRing ? settings.offRing : '#000000';
         const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
@@ -443,62 +575,87 @@ export class OtherControls{
         const txt = settings.displayCompendiumName ? name : '';
 
         streamDeck.setTitle(txt,context);
-        streamDeck.setIcon(context,"",background,2,ringColor);
+        streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
     }
 
     keyPressCompendium(settings){
         let name = settings.compendiumName;
         if (name == undefined) return;
+        if (MODULE.getPermission('OTHER','COMPENDIUM') == false ) return;
 
-        const compendium = game.packs.entries.find(p=>p.metadata.label == name);
+        let compendium;
+        if (compatibleCore("0.8.1"))    compendium = game.packs.contents.find(p=>p.metadata.label == name)?.apps[0];
+        else                            compendium = game.packs.entries.find(p=>p.metadata.label == name);
         if (compendium == undefined) return;
-        if (compendium.rendered) compendium.close();
+        if (compendium.private && MODULE.getPermission('OTHER','COMPENDIUM_ALL') == false) return;
+        else if (compendium.rendered) compendium.close();
         else compendium.render(true);
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    //Journals
-    //game.journal.entries[0].render(true)
-
-    updateJournal(settings,context){
+    updateJournal(settings,context,options={}){
         const name = settings.compendiumName;
         if (name == undefined) return;
 
-        const journal = game.journal.entries.find(p=>p.name == name);
+        const journal = game.journal.getName(name);
         if (journal == undefined) return;
 
+        if (MODULE.getPermission('OTHER','JOURNAL') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
+        if (journal.permission < 2 && MODULE.getPermission('OTHER','JOURNAL_ALL') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
+        let rendered = false;
+        
+        if (options?.sheet?.title == name) {
+            if (options.hook == 'renderJournalSheet') rendered = true;
+            else if (options.hook == 'closeJournalSheet') rendered = false;
+        }
+        else 
+            if (document.getElementById("journalentry-sheet-"+journal.id) != null) rendered = true;
+
         const background = settings.background ? settings.background : '#000000';
         const ringOffColor = settings.offRing ? settings.offRing : '#000000';
         const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
-        const ringColor = journal.sheet.rendered ? ringOnColor : ringOffColor;
+        const ringColor = rendered ? ringOnColor : ringOffColor;
         const txt = settings.displayCompendiumName ? name : '';
 
         streamDeck.setTitle(txt,context);
-        streamDeck.setIcon(context,"",background,2,ringColor);
+        streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
     }
 
     keyPressJournal(settings){
         const name = settings.compendiumName;
         if (name == undefined) return;
 
-        const journal = game.journal.entries.find(p=>p.name == name);
+        const journal = game.journal.getName(name);
         if (journal == undefined) return;
 
-        const element = document.getElementById("journal-"+journal.id);
-        if (element == null) journal.render(true);
+        if (MODULE.getPermission('OTHER','JOURNAL') == false ) return;
+        if (journal.permission < 2 && MODULE.getPermission('OTHER','JOURNAL_ALL') == false ) return;
+
+        if (journal.sheet.rendered == false) journal.sheet.render(true);
         else journal.sheet.close();
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-    updateChatMessage(settings,context){
+    updateChatMessage(settings,context,options={}){
+        if (MODULE.getPermission('OTHER','CHAT') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const background = settings.background ? settings.background : '#000000';
         streamDeck.setTitle("",context);
-        streamDeck.setIcon(context,"",background);
+        streamDeck.setIcon(context,"",{background:background});
     }
 
     keyPressChatMessage(settings){
+        if (MODULE.getPermission('OTHER','CHAT') == false ) return;
         const message = settings.chatMessage ? settings.chatMessage : '';
 
         let chatData = {

src/playlist.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class PlaylistControl{
     constructor(){
@@ -18,39 +19,37 @@ export class PlaylistControl{
     }
 
     update(settings,context){
+        if (MODULE.getPermission('PLAYLIST','PLAY') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         this.active = true;
-        if (settings.playlistMode == undefined) settings.playlistMode = 'playlist';
-        if (settings.playlistMode == 'playlist'){
+        const mode = settings.playlistMode ? settings.playlistMode : 'playlist';
+        
+        if (mode == 'playlist'){
             this.updatePlaylist(settings,context);
         }
-        else if (settings.playlistMode == 'track'){
+        else if (mode == 'track'){
             this.updateTrack(settings,context);
         }
         else {
-            let src = 'modules/MaterialDeck/img/playlist/stop.png';
-            if (game.playlists.playing.length > 0)
-                streamDeck.setIcon(context,src,settings.background,2,'#00FF00',true);
-            else
-                streamDeck.setIcon(context,src,settings.background,1,'#000000',true);
+            const src = 'modules/MaterialDeck/img/playlist/stop.png';
+            const background = settings.background ? settings.background : '#000000';
+            const ringColor = (game.playlists.playing.length > 0) ? '#00FF00' : '#000000';
+            const ring = (game.playlists.playing.length > 0) ? 2 : 1;
+            const txt = settings.displayPlaylistName ? this.getPlaylist(this.playlistOffset).name : '';
+            streamDeck.setIcon(context,src,{background:background,ring:ring,ringColor:ringColor,overlay:true});
+            streamDeck.setTitle(txt,context);
         }
     }
 
     updatePlaylist(settings,context){
         let name = "";
-
-        let background = settings.background;
-        if(background == undefined) background = '#000000';
-
         let ringColor = "#000000"
-
-        let ringOffColor = settings.offRing;
-        if (ringOffColor == undefined) ringOffColor = '#FF0000';
-
-        let ringOnColor = settings.onRing;
-        if (ringOnColor == undefined) ringOnColor = '#00FF00';
-
-        let playlistType = settings.playlistType;
-        if (playlistType == undefined) playlistType = 'playStop';
+        const background = settings.background ? settings.background : '#000000';
+        const ringOffColor = settings.offRing ? settings.offRing : '#FF0000';
+        const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
+        const playlistType = settings.playlistType ? settings.playlistType : 'playStop';
 
         //Play/Stop
         if (playlistType == 'playStop'){
@@ -75,26 +74,28 @@ export class PlaylistControl{
             if (isNaN(playlistOffset)) playlistOffset = 0;
             if (playlistOffset == this.playlistOffset) ringColor = ringOnColor;
         }
-        streamDeck.setIcon(context,"",background,2,ringColor);
+        //Relative Offset
+        else if (playlistType == 'relativeOffset') {
+            let playlistOffset = parseInt(settings.offset);
+            if (isNaN(playlistOffset)) playlistOffset = 0;
+            let number = parseInt(this.playlistOffset + playlistOffset);
+            const nrOfPlaylists = parseInt(game.settings.get(MODULE.moduleName,'playlists').playlistNumber);
+            if (number < 0) number += nrOfPlaylists;
+            else if (number >= nrOfPlaylists) number -= nrOfPlaylists;
+            const targetPlaylist = this.getPlaylist(number);
+            if (targetPlaylist != undefined) name = targetPlaylist.name;
+        }
+        streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
         streamDeck.setTitle(name,context);
     }
 
     updateTrack(settings,context){
         let name = "";
-
-        let background = settings.background;
-        if(background == undefined) background = '#000000';
-
         let ringColor = "#000000"
-
-        let ringOffColor = settings.offRing;
-        if (ringOffColor == undefined) ringOffColor = '#FF0000';
-
-        let ringOnColor = settings.onRing;
-        if (ringOnColor == undefined) ringOnColor = '#00FF00';
-
-        let playlistType = settings.playlistType;
-        if (playlistType == undefined) playlistType = 'playStop';
+        const background = settings.background ? settings.background : '#000000';
+        const ringOffColor = settings.offRing ? settings.offRing : '#FF0000';
+        const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
+        const playlistType = settings.playlistType ? settings.playlistType : 'playStop';
 
         //Play/Stop
         if (playlistType == 'playStop'){
@@ -106,10 +107,13 @@ export class PlaylistControl{
             if (isNaN(trackNr) || trackNr < 1) trackNr = 1;
             trackNr--;
             trackNr += this.trackOffset;
-
+            
             let playlist = this.getPlaylist(playlistNr);
             if (playlist != undefined){
-                let track = playlist.data.sounds[trackNr];
+                let track;
+                if (compatibleCore("0.8.1")) track = playlist.sounds.contents[trackNr];
+                else track = playlist.data.sounds[trackNr];
+
                 if (track != undefined){
                     if (track.playing) 
                         ringColor = ringOnColor;
@@ -121,16 +125,27 @@ export class PlaylistControl{
             } 
         }
         //Offset
-        else {
+        else if (playlistType == 'offset') {
             let trackOffset = parseInt(settings.offset);
             if (isNaN(trackOffset)) trackOffset = 0;
             if (trackOffset == this.trackOffset) ringColor = ringOnColor;
         }
-        streamDeck.setIcon(context,"",background,2,ringColor);
+        //Relative Offset
+        else if (playlistType == 'relativeOffset') {
+        }
+        streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
         streamDeck.setTitle(name,context);
     }
 
     stopAll(force=false){
+        if (game.user.isGM == false) {
+            const payload = {
+                "msgType": "stopAllPlaylists", 
+                "force": force
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+            return;
+        }
         if (force){
             let playing = game.playlists.playing;
             for (let i=0; i<playing.length; i++){
@@ -152,11 +167,12 @@ export class PlaylistControl{
     getPlaylist(num){
         let selectedPlaylists = game.settings.get(MODULE.moduleName,'playlists').selectedPlaylist;
         if (selectedPlaylists != undefined) 
-            return game.playlists.entities.find(p => p._id == selectedPlaylists[num]);
+            return game.playlists.get(selectedPlaylists[num]);
         else return undefined;
     }
 
     keyPress(settings,context){
+        if (MODULE.getPermission('PLAYLIST','PLAY') == false ) return;
         let playlistNr = settings.playlistNr;
         if (playlistNr == undefined || playlistNr < 1) playlistNr = 1;
         playlistNr--;
@@ -166,41 +182,70 @@ export class PlaylistControl{
         trackNr--;
         trackNr += this.trackOffset;
 
-        if (settings.playlistMode == undefined) settings.playlistMode = 'playlist';
-        if (settings.playlistType == undefined) settings.playlistType = 'playStop';
-        if (settings.playlistMode == 'stopAll') {
+        const playlistMode =  settings.playlistMode ? settings.playlistMode : 'playlist';
+        const playlistType = settings.playlistType ? settings.playlistType : 'playStop';
+        
+        if (playlistMode == 'stopAll') {
             this.stopAll(true);
         } 
         else {
-            if (settings.playlistType == 'playStop') {
+            if (playlistType == 'playStop') {
                 let playlist = this.getPlaylist(playlistNr);
                 if (playlist != undefined){
-                    if (settings.playlistMode == 'playlist')
+                    if (playlistMode == 'playlist')
                         this.playPlaylist(playlist,playlistNr);
                     else {
-                        let track = playlist.data.sounds[trackNr];
+                        let track;
+                        if (compatibleCore("0.8.1")) track = playlist.sounds.contents[trackNr];
+                        else track = playlist.data.sounds[trackNr];
                         if (track != undefined){
                             this.playTrack(track,playlist,playlistNr);
                         }
                     }
                 }
             }
-            else {
-                if (settings.playlistMode == 'playlist') {
+            else if (playlistType == 'offset'){
+                if (playlistMode == 'playlist') {
                     this.playlistOffset = parseInt(settings.offset);
                     if (isNaN(this.playlistOffset)) this.playlistOffset = 0;
                 }
-                else {
+                else  {
                     this.trackOffset = parseInt(settings.offset);
                     if (isNaN(this.trackOffset)) this.trackOffset = 0;
                 }
                 this.updateAll();
             }
+            else if (playlistType == 'relativeOffset'){
+                if (playlistMode == 'playlist') {
+                    let playlistOffset = parseInt(settings.offset);
+                    if (isNaN(playlistOffset)) playlistOffset = 0;
+                    let number = parseInt(this.playlistOffset + playlistOffset);
+                    const nrOfPlaylists = parseInt(game.settings.get(MODULE.moduleName,'playlists').playlistNumber);
+                    if (number < 0) number += nrOfPlaylists;
+                    else if (number >= nrOfPlaylists) number -= nrOfPlaylists;
+                    this.playlistOffset = number;
+                }
+                else  {
+                    let value = parseInt(settings.offset);
+                    if (isNaN(value)) return;
+                    this.trackOffset += value;
+                }
+                this.updateAll();
+            }
         }
           
     }
 
     async playPlaylist(playlist,playlistNr){
+        if (game.user.isGM == false) {
+            const payload = {
+                "msgType": "playPlaylist", 
+                "playlistId": playlist.id,
+                "playlistNr": playlistNr
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+            return;
+        }
         if (playlist.playing) {
             playlist.stopAll();
             return;
@@ -214,6 +259,16 @@ export class PlaylistControl{
     }
     
     async playTrack(track,playlist,playlistNr){
+        if (game.user.isGM == false) {
+            const payload = {
+                "msgType": "playTrack", 
+                "playlistId": playlist.id,
+                "playlistNr": playlistNr,
+                "trackId": track._id
+            };
+            game.socket.emit(`module.MaterialDeck`, payload);
+            return;
+        }
         let play;
         if (track.playing)
             play = false;
@@ -227,7 +282,11 @@ export class PlaylistControl{
             }
             else if (mode == 2) await playlist.stopAll();
         }
-        await playlist.updateEmbeddedEntity("PlaylistSound", {_id: track._id, playing: play});
+        
+        if (compatibleCore("0.8.1") && play) await playlist.playSound(track);
+        else if (compatibleCore("0.8.1")) await playlist.stopSound(track);
+        else await playlist.updateEmbeddedEntity("PlaylistSound", {_id: track._id, playing: play});
+        
         playlist.update({playing: play});
     }
 }

src/scene.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class SceneControl{
     constructor(){
@@ -30,6 +31,10 @@ export class SceneControl{
         let src = "";
         let name = "";
         if (func == 'visible') { //visible scenes
+            if (MODULE.getPermission('SCENE','VISIBLE') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
             let nr = parseInt(settings.sceneNr);
             if (isNaN(nr) || nr < 1) nr = 1;
             nr--;
@@ -44,13 +49,17 @@ export class SceneControl{
             }
         }
         else if (func == 'dir') {   //from directory
+            if (MODULE.getPermission('SCENE','DIRECTORY') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
             let nr = parseInt(settings.sceneNr);
             if (isNaN(nr) || nr < 1) nr = 1;
             nr--;
 
             let sceneList = [];
             for (let i=0; i<ui.scenes.tree.children.length; i++){
-                const scenesInFolder = ui.scenes.tree.children[i].entities;
+                const scenesInFolder = compatibleCore("0.8.1") ? ui.scenes.tree.children[i].contents : ui.scenes.tree.children[i].entities;
                 for (let j=0; j<scenesInFolder.length; j++)
                     sceneList.push(scenesInFolder[j])
             }
@@ -75,8 +84,13 @@ export class SceneControl{
             }
         }
         else if (func == 'any') {   //by name
+            if (MODULE.getPermission('SCENE','NAME') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
             if (settings.sceneName == undefined || settings.sceneName == '') return;
-            let scene = game.scenes.apps[1].entities.find(p=>p.data.name == settings.sceneName);
+            let scene = game.scenes.getName(settings.sceneName);
+
             if (scene != undefined){
                 ringColor = scene.isView ? ringOnColor : ringOffColor;
                 if (settings.displaySceneName) name = scene.name;
@@ -85,6 +99,10 @@ export class SceneControl{
             }
         }
         else if (func == 'active'){
+            if (MODULE.getPermission('SCENE','ACTIVE') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
             const scene = game.scenes.active;
             if (scene == undefined) return;
             if (settings.displaySceneName) name = scene.name;
@@ -98,13 +116,14 @@ export class SceneControl{
             else ringColor = ringOffColor;
         }
         streamDeck.setTitle(name,context);
-        streamDeck.setIcon(context,src,background,ring,ringColor);
+        streamDeck.setIcon(context,src,{background:background,ring:ring,ringColor:ringColor});
     }
 
     keyPress(settings){
         const func = settings.sceneFunction ? settings.sceneFunction : 'visible';
 
         if (func == 'visible'){ //visible scenes
+            if (MODULE.getPermission('SCENE','VISIBLE') == false ) return;
             const viewFunc = settings.sceneViewFunction ? settings.sceneViewFunction : 'view';
             let nr = parseInt(settings.sceneNr);
             if (isNaN(nr) || nr < 1) nr = 1;
@@ -125,6 +144,7 @@ export class SceneControl{
             }  
         }
         else if (func == 'dir') {   //from directory
+            if (MODULE.getPermission('SCENE','DIRECTORY') == false ) return;
             const viewFunc = settings.sceneViewFunction ? settings.sceneViewFunction : 'view';
             let nr = parseInt(settings.sceneNr);
             if (isNaN(nr) || nr < 1) nr = 1;
@@ -132,7 +152,7 @@ export class SceneControl{
 
             let sceneList = [];
             for (let i=0; i<ui.scenes.tree.children.length; i++){
-                const scenesInFolder = ui.scenes.tree.children[i].entities;
+                const scenesInFolder = compatibleCore("0.8.1") ? ui.scenes.tree.children[i].contents : ui.scenes.tree.children[i].entities;
                 for (let j=0; j<scenesInFolder.length; j++)
                     sceneList.push(scenesInFolder[j])
             }
@@ -156,9 +176,10 @@ export class SceneControl{
 
         }
         else if (func == 'any'){ //by name
+            if (MODULE.getPermission('SCENE','NAME') == false ) return;
             if (settings.sceneName == undefined || settings.sceneName == '') return;
             const scenes = game.scenes.entries;
-            let scene = game.scenes.apps[1].entities.find(p=>p.data.name == settings.sceneName);
+            let scene = game.scenes.getName(settings.sceneName);
             if (scene == undefined) return;
 
             const viewFunc = settings.sceneViewFunction ? settings.sceneViewFunction : 'view';
@@ -175,6 +196,7 @@ export class SceneControl{
             }
         }
         else if (func == 'active'){
+            if (MODULE.getPermission('SCENE','ACTIVE') == false ) return;
             const scene = game.scenes.active;
             if (scene == undefined) return;
             scene.view();

src/settings.js

@@ -1,17 +1,84 @@
 import * as MODULE from "../MaterialDeck.js";
 import { playlistConfigForm, macroConfigForm, soundboardConfigForm } from "./misc.js";
 
-export const registerSettings = function() {
+let userPermissions = {};
+const defaultEnable = [true,true,true,true];
+const defaultUserPermissions = {
+    COMBAT: {
+        END_TURN: [true,true,true,true],
+        TURN_DISPLAY: [true,true,true,true],
+        OTHER_FUNCTIONS: [false,false,true,true],
+        DISPLAY_COMBATANTS: [false,false,true,true],
+        DISPLAY_NON_OWNED_STATS: [false,false,true,true],
+        DISPLAY_LIMITED_HP: [false,true,true,true],
+        DISPLAY_OBSERVER_HP: [true,true,true,true],
+        DISPLAY_ALL_NAMES: [false,false,true,true],
+        DISPLAY_LIMITED_NAME: [false,true,true,true],
+        DISPLAY_OBSERVER_NAME: [true,true,true,true]
+    },
+    MACRO: {
+        HOTBAR: [true,true,true,true],
+        BY_NAME: [false,false,true,true],
+        MACROBOARD: [false,false,true,true],
+        MACROBOARD_CONFIGURE: [false,false,true,true]
+    },
+    MOVE: {
+        TOKEN: [true,true,true,true],
+        CANVAS: [true,true,true,true]
+    },
+    OTHER: {
+        PAUSE: [false,false,true,true],
+        CONTROL: [true,true,true,true],
+        DARKNESS: [false,false,true,true],
+        DICE: [true,true,true,true],
+        TABLES_ALL: [false,false,true,true],
+        TABLES: [false,true,true,true],
+        SIDEBAR: [true,true,true,true],
+        COMPENDIUM_ALL: [false,false,true,true],
+        COMPENDIUM: [false,true,true,true],
+        JOURNAL_ALL: [false,false,true,true],
+        JOURNAL: [false,true,true,true],
+        CHAT: [false,true,true,true]
+    },
+    PLAYLIST: {
+        PLAY: [false,false,true,true],
+        CONFIGURE: [false,false,true,true]
+    },
+    SCENE: {
+        VISIBLE: [false,false,true,true],
+        ACTIVE: [true,true,true,true],
+        DIRECTORY: [false,false,true,true],
+        NAME: [false,false,true,true]
+    },
+    SOUNDBOARD: {
+        PLAY: [false,false,true,true],
+        CONFIGURE: [false,false,true,true]
+    },
+    TOKEN: {
+        STATS: [true,true,true,true],
+        VISIBILITY: [false,false,true,true],
+        COMBAT: [false,true,true,true],
+        VISION: [false,true,true,true],
+        WILDCARD: [false,true,true,true],
+        CONDITIONS: [false,true,true,true],
+        CUSTOM: [false,false,true,true],
+        NON_OWNED: [false,false,true,true],
+        OBSERVER: [false,true,true,true]
+    } 
+}
+
+export const registerSettings = async function() {
     /**
      * Main settings
      */
+    //world,global,client
 
     //Enabled the module
     game.settings.register(MODULE.moduleName,'Enable', {
         name: "MaterialDeck.Sett.Enable",
-        scope: "global",
+        scope: "client",
         config: true,
-        default: true,
+        default: false,
         type: Boolean,
         onChange: x => window.location.reload()
     });
@@ -19,7 +86,7 @@ export const registerSettings = function() {
     game.settings.register(MODULE.moduleName,'streamDeckModel', {
         name: "MaterialDeck.Sett.Model",
         hint: "MaterialDeck.Sett.Model_Hint",
-        scope: "world",
+        scope: "client",
         config: true,
         type:Number,
         default:1,
@@ -32,7 +99,7 @@ export const registerSettings = function() {
     game.settings.register(MODULE.moduleName,'address', {
         name: "MaterialDeck.Sett.ServerAddr",
         hint: "MaterialDeck.Sett.ServerAddrHint",
-        scope: "world",
+        scope: "client",
         config: true,
         default: "localhost:3001",
         type: String,
@@ -42,9 +109,9 @@ export const registerSettings = function() {
     game.settings.register(MODULE.moduleName, 'imageBuffer', {
         name: "MaterialDeck.Sett.ImageBuffer",
         hint: "MaterialDeck.Sett.ImageBufferHint",
-        default: 0,
+        default: 100,
         type: Number,
-        scope: 'world',
+        scope: 'client',
         range: { min: 0, max: 500, step: 10 },
         config: true
         
@@ -55,8 +122,23 @@ export const registerSettings = function() {
         name: "MaterialDeck.Sett.Help",
         label: "MaterialDeck.Sett.Help",
         type: helpMenu,
+        restricted: false
+    });
+
+    game.settings.registerMenu(MODULE.moduleName, 'permissionConfig',{
+        name: "MaterialDeck.Sett.Permission",
+        label: "MaterialDeck.Sett.Permission",
+        type: userPermission,
         restricted: true
     });
+
+    game.settings.register(MODULE.moduleName, 'userPermission', {
+        name: "userPermission",
+        scope: "world",
+        type: Object,
+        config: false
+    });
+
     /**
      * Playlist soundboard
      */
@@ -64,7 +146,7 @@ export const registerSettings = function() {
         name: "MaterialDeck.Sett.PlaylistConfig",
         label: "MaterialDeck.Sett.PlaylistConfig",
         type: playlistConfigForm,
-        restricted: true
+        restricted: false
     });
 
     game.settings.register(MODULE.moduleName, 'playlists', {
@@ -82,7 +164,7 @@ export const registerSettings = function() {
         name: "MaterialDeck.Sett.MacroConfig",
         label: "MaterialDeck.Sett.MacroConfig",
         type: macroConfigForm,
-        restricted: true
+        restricted: false
     });
 
     game.settings.register(MODULE.moduleName, 'macroSettings', {
@@ -114,8 +196,24 @@ export const registerSettings = function() {
         name: "MaterialDeck.Sett.SoundboardConfig",
         label: "MaterialDeck.Sett.SoundboardConfig",
         type: soundboardConfigForm,
-        restricted: true
+        restricted: false
     });
+
+    let permissionSettings = game.settings.get(MODULE.moduleName,'userPermission');
+    if (permissionSettings == undefined || permissionSettings == null || MODULE.isEmpty(permissionSettings)) {
+        permissionSettings = {
+            enable: defaultEnable,
+            permissions: defaultUserPermissions
+        }
+    }
+    else {
+        if (permissionSettings.permissions.TOKEN.NON_OWNED == undefined) permissionSettings.permissions.TOKEN.NON_OWNED = [false,false,true,true];
+        if (permissionSettings.permissions.TOKEN.OBSERVER == undefined) permissionSettings.permissions.TOKEN.OBSERVER = [false,true,true,true];
+        if (permissionSettings.permissions.MACRO.BY_NAME == undefined) permissionSettings.permissions.MACRO.BY_NAME = [false,false,true,true];
+    }
+    game.settings.set(MODULE.moduleName,'userPermission',permissionSettings);
+    
+
 }
 
 export class helpMenu extends FormApplication {
@@ -159,3 +257,108 @@ export class helpMenu extends FormApplication {
         
     }
   }
+
+  class userPermission extends FormApplication {
+    constructor(data, options) {
+        super(data, options);
+    }
+  
+    /**
+     * Default Options for this FormApplication
+     */
+    static get defaultOptions() {
+        return mergeObject(super.defaultOptions, {
+            id: "userPermissionConfig",
+            title: "Material Deck: "+game.i18n.localize("MaterialDeck.Sett.Permission"),
+            template: "./modules/MaterialDeck/templates/userPermissionConfig.html",
+            width: 660,
+            height: "auto",
+            scrollY: [".permissions-list"],
+        });
+    }
+  
+    /**
+     * Provide data to the template
+     */
+    async getData() {
+        let settings = game.settings.get(MODULE.moduleName,'userPermission');
+        if (settings == undefined || settings == null || MODULE.isEmpty(settings)) {
+            settings = {
+                enable: defaultEnable,
+                permissions: defaultUserPermissions
+            }
+        }
+
+        const actions = Object.entries(duplicate(settings.permissions)).reduce((arr, e) => {
+            //const perm = e[1];
+
+            const perms = Object.entries(duplicate(e[1])).reduce((arr, p) => {
+                //const perm = e[1];
+                
+                let perm = {};
+                perm.roles = [p[1][0],p[1][1],p[1][2],p[1][3]]
+                perm.id = p[0];
+                perm.label = game.i18n.localize("MaterialDeck.Perm."+e[0]+"."+p[0]+".label");
+                perm.hint = game.i18n.localize("MaterialDeck.Perm."+e[0]+"."+p[0]+".hint");
+                arr.push(perm);
+                return arr;
+              }, []);
+
+            let cat = {};
+            cat.permissions = perms;
+            cat.id = e[0];
+            cat.label = game.i18n.localize("MaterialDeck.Perm."+e[0]+".label");
+            cat.hint = game.i18n.localize("MaterialDeck.Perm."+e[0]+".hint");
+            arr.push(cat);
+            return arr;
+          }, []);
+
+        const current = await game.settings.get("core", "permissions");
+        return {
+          roles: Object.keys(CONST.USER_ROLES).reduce((obj, r) => {
+            if ( r === "NONE" ) return obj;
+            obj[r] = `USER.Role${r.titleCase()}`;
+            return obj;
+          }, {}),
+          actions: actions,
+          enable: settings.enable
+        }
+    }
+  
+    /**
+     * Update on form submit
+     * @param {*} event 
+     * @param {*} formData 
+     */
+    async _updateObject(event, formData) {
+        let permissions = expandObject(formData);
+        let settings = {};
+        settings.enable = permissions.ENABLE;
+        delete permissions.ENABLE;
+        settings.permissions = permissions;
+        game.settings.set(MODULE.moduleName,'userPermission',settings);
+    }
+  
+    async activateListeners(html) {
+        super.activateListeners(html);
+        const defaultBtn = html.find('button[name="reset"]');
+
+        defaultBtn.on("click", event => {
+            this.resetToDefault();
+        })
+            
+        
+    }
+
+    async resetToDefault(){
+        const settings = {
+            enable: defaultEnable,
+            permissions: defaultUserPermissions
+        }
+        await game.settings.set(MODULE.moduleName,'userPermission',settings);
+        this.render();
+        ui.notifications.info(game.i18n.localize("MaterialDeck.Perm.DefaultNotification"));
+    }
+  }
+
+

src/soundboard.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class SoundboardControl{
     constructor(){
@@ -20,6 +21,10 @@ export class SoundboardControl{
     }
 
     update(settings,context){
+        if (MODULE.getPermission('SOUNDBOARD','PLAY') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         this.active = true;
         const mode = settings.soundboardMode ? settings.soundboardMode : 'playSound';
         const background = settings.background ? settings.background : '#000000';
@@ -41,7 +46,7 @@ export class SoundboardControl{
             if (settings.displayIcon && soundboardSettings.img != undefined) src = soundboardSettings.img[soundNr];
 
             streamDeck.setTitle(txt,context);
-            streamDeck.setIcon(context,src,background,2,ringColor);
+            streamDeck.setIcon(context,src,{background:background,ring:2,ringColor:ringColor});
         }
         else if (mode == 'offset') { //Offset
             const ringOffColor = settings.offRing ? settings.offRing : '#000000';
@@ -53,22 +58,24 @@ export class SoundboardControl{
             else ringColor = ringOffColor;
 
             streamDeck.setTitle(txt,context);
-            streamDeck.setIcon(context,"",background,2,ringColor);
+            streamDeck.setIcon(context,"",{background:background,ring:2,ringColor:ringColor});
         }
         else if (mode == 'stopAll') {   //Stop all sounds
             let src = 'modules/MaterialDeck/img/playlist/stop.png';
             let soundPlaying = false;
+            const background = settings.background ? settings.background : '#000000';
             for (let i=0; i<this.activeSounds.length; i++)
                 if (this.activeSounds[i]) 
                     soundPlaying = true;
             if (soundPlaying)
-                streamDeck.setIcon(context,src,settings.background,2,'#00FF00',true);
+                streamDeck.setIcon(context,src,{background:background,ring:2,ringColor:'#00FF00',overlay:true});
             else
-                streamDeck.setIcon(context,src,settings.background,1,'#000000',true);
+                streamDeck.setIcon(context,src,{background:background,ring:1,ringColor:'#000000',overlay:true});
         }
     }
 
     keyPressDown(settings){
+        if (MODULE.getPermission('SOUNDBOARD','PLAY') == false ) return;
         const mode = settings.soundboardMode ? settings.soundboardMode : 'playSound';
 
         if (mode == 'playSound') {    //Play sound
@@ -81,7 +88,7 @@ export class SoundboardControl{
             const repeat = (playMode > 0) ? true : false;
             const play = (this.activeSounds[soundNr] == false) ? true : false;
 
-            this.playSound(soundNr,repeat,play);
+            this.prePlaySound(soundNr,repeat,play);
         }
         else if (mode == 'offset') { //Offset
             let offset = parseInt(settings.offset);
@@ -92,13 +99,14 @@ export class SoundboardControl{
         else if (mode == 'stopAll') {  //Stop All Sounds
             for (let i=0; i<64; i++) {
                 if (this.activeSounds[i] != false){
-                    this.playSound(i,false,false);
+                    this.prePlaySound(i,false,false);
                 }
             }
         }
     }
 
     keyPressUp(settings){
+        if (MODULE.getPermission('SOUNDBOARD','PLAY') == false ) return;
         const mode = settings.soundboardMode ? settings.soundboardMode : 'playSound';
 
         if (mode != 'playSound') return;
@@ -111,10 +119,10 @@ export class SoundboardControl{
         const playMode = game.settings.get(MODULE.moduleName,'soundboardSettings').mode[soundNr];
         
         if (playMode == 2)
-            this.playSound(soundNr,false,false);
+            this.prePlaySound(soundNr,false,false);
     }
 
-    async playSound(soundNr,repeat,play){  
+    async prePlaySound(soundNr,repeat,play){  
         const soundBoardSettings = game.settings.get(MODULE.moduleName,'soundboardSettings');
         const playlistId = (soundBoardSettings.selectedPlaylists != undefined) ? soundBoardSettings.selectedPlaylists[soundNr] : undefined;
         let src;
@@ -133,9 +141,9 @@ export class SoundboardControl{
         }
         else {
             const soundId = soundBoardSettings.sounds[soundNr];
-            const sounds = game.playlists.entities.find(p => p._id == playlistId).data.sounds;
+            const sounds = game.playlists.get(playlistId).sounds;
             if (sounds == undefined) return;
-            const sound = sounds.find(p => p._id == soundId);
+            const sound = compatibleCore("0.8.1") ? sounds.find(p => p.id == soundId) : sounds.find(p => p._id == soundId);
             if (sound == undefined) return;
             src = sound.path;
         }
@@ -153,21 +161,39 @@ export class SoundboardControl{
         };
         game.socket.emit(`module.MaterialDeck`, payload);
 
-        if (play){
-            volume *= game.settings.get("core", "globalInterfaceVolume");
+        this.playSound(soundNr,src,play,repeat,volume)
+    }
 
-            let howl = new Howl({src, volume, loop: repeat, onend: (id)=>{
-                if (repeat == false){
+    async playSound(soundNr,src,play,repeat,volume){
+        if (play){
+            volume *= game.settings.get("core", "globalAmbientVolume");
+
+            if (compatibleCore("0.8.1")) {
+                let newSound = new SoundNode(src);
+                if(newSound.loaded == false) await newSound.load({autoplay:true});
+                newSound.on('end', ()=>{
+                    if (repeat == false) {
+                        this.activeSounds[soundNr] = false;
+                        this.updateAll();
+                    }
+                });
+                newSound.play({loop:repeat,volume:volume});
+                this.activeSounds[soundNr] = newSound;
+            }
+            else {
+                let howl = new Howl({src, volume, loop: repeat, onend: (id)=>{
+                    if (repeat == false){
+                        this.activeSounds[soundNr] = false;
+                        this.updateAll();
+                    }
+                },
+                onstop: ()=>{
                     this.activeSounds[soundNr] = false;
                     this.updateAll();
-                }
-            },
-            onstop: (id)=>{
-                this.activeSounds[soundNr] = false;
-                this.updateAll();
-            }});
-            howl.play();
-            this.activeSounds[soundNr] = howl;
+                }});
+                howl.play();
+                this.activeSounds[soundNr] = howl;
+            }
         }
         else {
             this.activeSounds[soundNr].stop();
@@ -175,4 +201,23 @@ export class SoundboardControl{
         }
         this.updateAll();
     }
+
+    /*
+    volumeChange(soundNr){
+        
+        let volume = game.settings.get("core", "globalAmbientVolume");
+
+        if (soundNr == 'all') {
+            for (let i=0; this.activeSounds.length; i++) {
+                volume * game.settings.get(MODULE.moduleName,'soundboardSettings').volume[i]/100;
+                volume = AudioHelper.inputToVolume(volume);
+                this.activeSounds[i].volume = volume;
+            }
+        }
+        else {
+            volume * game.settings.get(MODULE.moduleName,'soundboardSettings').volume[soundNr]/100;
+            volume = AudioHelper.inputToVolume(volume);
+        }
+    }
+    */
 }

src/streamDeck.js

@@ -7,7 +7,7 @@ export class StreamDeck{
         this.tokenNameContext;
         this.tokenACContext;
         this.buttonContext = [];
-        for (let i=0; i<23; i++){
+        for (let i=0; i<31; i++){
             this.buttonContext[i] = undefined;
         }
         this.playlistTrackBuffer = [];
@@ -206,18 +206,26 @@ export class StreamDeck{
         MODULE.sendWS(JSON.stringify(json));
     }
 
-    setIcon(context,src='',background = '#000000',ring=0,ringColor = "#000000",overlay=false){
+    setIcon(context,src='',options = {}){
         if (src == null || src == undefined) src = '';
         if (src == '') src = 'modules/MaterialDeck/img/black.png';
+        let background = options.background ? options.background : '#000000';
+        let ring = options.ring ? options.ring : 0;
+        let ringColor = options.ringColor ? options.ringColor : '#000000';
+        let overlay = options.overlay ? options.overlay : false;
+        let uses = options.uses ? options.uses : undefined;
+        let clock = options.clock ? options.clock : false;
         for (let i=0; i<32; i++){
+            if (clock != false) break;
             if (this.buttonContext[i] == undefined) continue;
             if (this.buttonContext[i].context == context) {
-                if (this.buttonContext[i].icon == src && this.buttonContext[i].ring == ring && this.buttonContext[i].ringColor == ringColor && this.buttonContext[i].background == background) 
+                if (this.buttonContext[i].icon == src && this.buttonContext[i].ring == ring && this.buttonContext[i].ringColor == ringColor && this.buttonContext[i].background == background && this.buttonContext[i].uses == uses) 
                     return;
                 this.buttonContext[i].icon = src;
                 this.buttonContext[i].ring = ring;
                 this.buttonContext[i].ringColor = ringColor;
                 this.buttonContext[i].background = background;
+                this.buttonContext[i].uses = uses;
             }
         }
         const data = {
@@ -225,9 +233,11 @@ export class StreamDeck{
             background:background,
             ring:ring,
             ringColor:ringColor,
-            overlay:overlay
+            overlay:overlay,
+            uses:uses,
+            options:options
         }
-        const imgBuffer = this.checkImageBuffer(data);
+        const imgBuffer = (clock == false) ? this.checkImageBuffer(data) : false;
         if (imgBuffer != false) {
             this.setBufferImage(context,imgBuffer,this.getImageBufferId(data))
             return;
@@ -247,7 +257,9 @@ export class StreamDeck{
             background: background,
             ring: ring,
             ringColor: ringColor,
-            overlay: overlay
+            overlay: overlay,
+            uses:uses,
+            options:options
         };
         this.getImage(msg);
     }
@@ -299,12 +311,11 @@ export class StreamDeck{
     getImage(data){
         if (data == undefined) 
             return;
-        
         const context = data.context;
         var url = data.url;
         const format = data.format;
         var background = data.background;
-    
+        const uses = data.uses;
         let BGvalid = true;
         if (background.length != 7) BGvalid = false;
         if (background[0] != '#') BGvalid = false;
@@ -328,7 +339,8 @@ export class StreamDeck{
         ctx.filter = "none";
     
         let margin = 0;
-        
+        ctx.fillStyle = background;
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
         if (data.ring != undefined && data.ring > 0){
             ctx.fillStyle = background;
             ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -341,8 +353,12 @@ export class StreamDeck{
             }
         }
         else {
-            ctx.fillStyle = background;
-            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            
+        }
+        if (uses != undefined && uses.heart && (uses.available > 0 || uses.maximum != undefined)) {
+            const percentage = 102*uses.available/uses.maximum;
+            ctx.fillStyle = "#FF0000";
+            ctx.fillRect(0, 121,144,-percentage);
         }
         if (format == 'icon' && url != ""){
             ctx.font = '600 90px "Font Awesome 5 Free"';
@@ -400,6 +416,76 @@ export class StreamDeck{
                 yStart = 0;
             }
             ctx.drawImage(img, xStart+margin, yStart+margin, renderableWidth - 2*margin, renderableHeight - 2*margin);
+            if (uses != undefined && uses.heart == false && (uses.available > 0 || uses.maximum != undefined)) {
+                let txt = uses.available;
+                if (uses.maximum != undefined) txt = uses.available + '/' + uses.maximum;
+                if (uses.maximum == undefined ) uses.maximum = 1;
+                ctx.beginPath();
+                ctx.lineWidth = 4;
+                let green = Math.ceil(255*(uses.available/uses.maximum));
+                let red = 255-green;
+                green = green.toString(16);
+                if (green.length == 1) green = "0"+green;
+                red = red.toString(16);
+                if (red.length == 1) red = "0"+red;
+                if (uses.available == 0) ctx.strokeStyle = "#c80000";
+                else ctx.strokeStyle = "#"+red.toString(16)+green.toString(16)+"00";
+                const rect = {height:35, paddingSides:20, paddingBottom: 4}
+                ctx.rect(rect.paddingSides, 144-rect.height-rect.paddingBottom,144-2*rect.paddingSides,rect.height);
+                ctx.globalAlpha = 0.5;
+                ctx.fillRect(rect.paddingSides, 144-rect.height-rect.paddingBottom,144-2*rect.paddingSides,rect.height);
+                ctx.globalAlpha = 1;
+                ctx.fillStyle = "white";
+                ctx.font = "24px Arial";
+                ctx.fillText(txt, (canvas.width  - ctx.measureText(txt).width) / 2, 144-rect.height-rect.paddingBottom+25);
+                ctx.stroke();
+            }
+            
+            if (data.options.clock != undefined) {
+                if (data.options.clock != false && data.options.clock != 'none') {
+                    const hourAngle = (data.options.clock.hours+data.options.clock.minutes/60)*Math.PI/6;
+                    const minuteAngle = data.options.clock.minutes*Math.PI/30;
+
+                    ctx.translate(72,72);
+                    //Draw outer circle
+                    ctx.beginPath();
+                    ctx.lineWidth = 6;
+                    ctx.strokeStyle = "gray";
+                    ctx.arc(0,0, 50, 0, 2 * Math.PI);
+                    ctx.stroke(); 
+    
+                    //Draw hour marks
+                    ctx.fillStyle = "gray";
+                    ctx.beginPath();
+                    for (let i=0; i<12; i++) {
+                        ctx.fillRect(-2,40,4,10);
+                        const angle = 2*Math.PI/12;
+                        ctx.rotate(angle);
+                    }
+    
+    
+                    //Draw hour arm
+    
+                    ctx.rotate(Math.PI + hourAngle);
+                    ctx.rotate(0);
+                    ctx.fillRect(-4,0,8,30);
+                    ctx.stroke();
+                   // ctx.rotate 8*Math.PI/12;
+                   ctx.beginPath();
+                    ctx.rotate(-hourAngle + minuteAngle);
+                    ctx.fillStyle = "lightgray";
+                    ctx.fillRect(-2,0,4,40);
+                    ctx.rotate(2*Math.PI/12);
+                    ctx.stroke();
+    
+                    //Draw inner circle
+                    ctx.beginPath();
+                    ctx.arc(0,0, 5, 0, 2 * Math.PI);
+                    ctx.fill();
+                    
+                }
+            }
+            
             var dataURL = canvas.toDataURL();
             canvas.remove();
             const nr = this.addToImageBuffer(dataURL,data);
@@ -409,7 +495,7 @@ export class StreamDeck{
     }
 
     getImageBufferId(data){
-        return data.url+data.background+data.ring+data.ringColor+data.overlay;
+        return data.url+data.background+data.ring+data.ringColor+data.overlay+data.uses?.available+data.uses?.maximum;
     }
 
     addToImageBuffer(img,data){
@@ -444,4 +530,13 @@ export class StreamDeck{
         this.imageBufferCounter = 0;
         this.imageBuffer = [];
     }
+
+    noPermission(context,showTxt=true, origin = ""){
+        console.warn("Material Deck: User lacks permission for function "+origin);
+        const url = 'modules/MaterialDeck/img/black.png';
+        const background = '#000000';
+        const txt = showTxt ? 'no\npermission' : '';
+        this.setIcon(context,url,{background:background});
+        this.setTitle(txt,context);
+    }
 }

src/token.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
-import {streamDeck} from "../MaterialDeck.js";
+import {streamDeck, macroControl} from "../MaterialDeck.js";
+import {compatibleCore} from "./misc.js";
 
 export class TokenControl{
     constructor(){
@@ -7,7 +8,7 @@ export class TokenControl{
         this.wildcardOffset = 0;
     }
 
-    async update(tokenId){
+    async update(tokenId=null){
         if (this.active == false) return;
         for (let i=0; i<32; i++){   
             const data = streamDeck.buttonContext[i];
@@ -20,22 +21,59 @@ export class TokenControl{
         const name = settings.displayName ? settings.displayName : false;
         const icon = settings.displayIcon ? settings.displayIcon : false;
         const background = settings.background ? settings.background : "#000000";
-        const system = settings.system ? settings.system : 'dnd5e';
+        let stats =  settings.stats ? settings.stats : 'none';
+        const selection = settings.selection ? settings.selection : 'selected';
+        const tokenIdentifier = settings.tokenName ? settings.tokenName : '';
+    
+        let validToken = false;
+        let token;
+        if (selection == 'selected') token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
+        else if (selection != 'selected' && tokenIdentifier == '') {}
+        else if (selection == 'tokenName') token = canvas.tokens.children[0].children.find(p => p.name == tokenIdentifier);
+        else if (selection == 'actorName') token = canvas.tokens.children[0].children.find(p => p.actor.name == tokenIdentifier);
+        else if (selection == 'tokenId') token = canvas.tokens.children[0].children.find(p => p.id == tokenIdentifier);
+        else if (selection == 'actorId') token = canvas.tokens.children[0].children.find(p => p.actor.id == tokenIdentifier);
+
+        if (token != undefined) validToken = true;
 
-        let stats =  (system == 'demonlord') ? settings.statsDemonlord : settings.stats;
-        if (stats == undefined) stats = 'none';
-        
         let tokenName = "";
         let txt = "";
         let iconSrc = "";
         let overlay = false;
-        if (tokenId != undefined) {
-            const token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
+        let statsOld;
+        let uses = undefined;
+        let hp = undefined;
+        if (validToken) {
+            if (token.owner == false && token.observer == true && MODULE.getPermission('TOKEN','OBSERVER') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
+            if (token.owner == false && token.observer == false && MODULE.getPermission('TOKEN','NON_OWNED') == false ) {
+                streamDeck.noPermission(context);
+                return;
+            }
+
             tokenName = token.data.name;
             if (name) txt += tokenName;
-            if (name && stats != 'none') txt += "\n";
-            iconSrc = token.data.img;
 
+            const permission = token.actor?.permission;
+            if (settings.combat){
+                if (permission == 0 && MODULE.getPermission('COMBAT','DISPLAY_ALL_NAMES') == false) txt = "";
+                else if (permission == 1 && MODULE.getPermission('COMBAT','DISPLAY_LIMITED_NAME') == false) txt = "";
+                else if (permission == 2 && MODULE.getPermission('COMBAT','DISPLAY_OBSERVER_NAME') == false) txt = "";
+
+                if (permission == 0 && stats == 'HP') stats = 'none';
+                else if (stats == 'HP' && permission == 1 && MODULE.getPermission('COMBAT','DISPLAY_LIMITED_HP') == false) stats = 'none';
+                else if (stats == 'HP' && permission == 2 && MODULE.getPermission('COMBAT','DISPLAY_OBSERVER_HP') == false) stats = 'none';
+                else if (stats != 'HP' && permission < 3 && MODULE.getPermission('COMBAT','DISPLAY_NON_OWNED_STATS') == false) stats = 'none';
+            }
+            else if (MODULE.getPermission('TOKEN','STATS') == false) {
+                statsOld = stats;
+                stats = 'none';
+            }
+
+            if (icon) iconSrc = token.data.img;
+            if (name && stats != 'none' && stats != 'HPbox') txt += "\n";
             if (stats == 'custom'){
                 const custom = settings.custom ? settings.custom : '';
                 let split = custom.split('[');
@@ -54,11 +92,23 @@ export class TokenControl{
                         }
                     }
             }
-            else if (system == 'dnd5e' && game.system.id == 'dnd5e'){
+            else if (game.system.id == 'dnd5e'){
                 let attributes = token.actor.data.data.attributes;
                 if (stats == 'HP') {
+                    uses = {
+                        available: attributes.hp.value,
+                        maximum: attributes.hp.max,
+                        heart: true
+                    };
                     txt += attributes.hp.value + "/" + attributes.hp.max;
                 }
+                else if (stats == 'HPbox') {
+                    uses = {
+                        available: attributes.hp.value,
+                        maximum: attributes.hp.max,
+                        heart: false
+                    }
+                }
                 else if (stats == 'TempHP') {
                     txt += attributes.hp.temp;
                     if (attributes.hp.tempmax != null)
@@ -96,13 +146,47 @@ export class TokenControl{
                     }
                     txt += speed;
                 }
-                else if (stats == 'Init') txt += attributes.init.total;
+                else if (stats == 'Init') {
+                    const value = attributes.init.total;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
                 else if (stats == 'PassivePerception') txt += token.actor.data.data.skills.prc.passive;
                 else if (stats == 'PassiveInvestigation') txt += token.actor.data.data.skills.inv.passive;
+                else if (stats == 'Ability') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    txt += token.actor.data.data.abilities?.[ability].value;
+                }
+                else if (stats == 'AbilityMod') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    const value = token.actor.data.data.abilities?.[ability].mod;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Save') {        
+                    const ability = settings.save ? settings.save : 'str';
+                    const value = token.actor.data.data.abilities?.[ability].save;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Skill') {
+                    const skill = settings.skill ? settings.skill : 'acr';
+                    const value = token.actor.data.data.skills?.[skill].mod;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Prof') txt += token.actor.data.data.attributes.prof;
             }
-            else if ((system == 'dnd3.5e' && game.system.id == 'D35E') || (system == 'pf1e' && game.system.id == 'pf1')){
+
+            else if (game.system.id == 'D35E' || game.system.id == 'pf1'){
                 let attributes = token.actor.data.data.attributes;
                 if (stats == 'HP') txt += attributes.hp.value + "/" + attributes.hp.max;
+                else if (stats == 'HPbox') {
+                    uses = {
+                        available: attributes.hp.value,
+                        maximum: attributes.hp.max
+                    }
+                }
                 else if (stats == 'TempHP') {
                     if (attributes.hp.temp == null) txt += '0';
                     else txt += attributes.hp.temp;
@@ -129,11 +213,44 @@ export class TokenControl{
                     }
                     txt += speed;
                 }
-                else if (stats == 'Init') txt += attributes.init.total;
+                else if (stats == 'Init') {
+                    const value = attributes.init.total;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Ability') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    txt += token.actor.data.data.abilities?.[ability].value;
+                }
+                else if (stats == 'AbilityMod') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    const value = token.actor.data.data.abilities?.[ability].mod;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Save') {        
+                    const ability = settings.save ? settings.save : 'fort';
+                    const value = token.actor.data.data.attributes.savingThrows?.[ability].total;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Skill') {
+                    const skill = settings.skill ? settings.skill : 'apr';
+                    const value = token.actor.data.data.skills?.[skill].mod;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Prof') txt += token.actor.data.data.attributes.prof;
             }
-            else if (system == 'pf2e' && game.system.id == 'pf2e'){
+            else if (game.system.id == 'pf2e'){
                 let attributes = token.actor.data.data.attributes;
                 if (stats == 'HP') txt += attributes.hp.value + "/" + attributes.hp.max;
+                else if (stats == 'HPbox') {
+                    uses = {
+                        available: attributes.hp.value,
+                        maximum: attributes.hp.max
+                    }
+                }
                 else if (stats == 'TempHP') {
                     if (attributes.hp.temp == null) txt += '0';
                     else {
@@ -143,7 +260,7 @@ export class TokenControl{
                 }
                 else if (stats == 'AC') txt += attributes.ac.value;
                 else if (stats == 'Speed'){
-                    let speed = "Land: " + attributes.speed.value.replace('feet','') + ' feet';
+                    let speed = attributes.speed.breakdown;
                     const otherSpeeds = attributes.speed.otherSpeeds;
                     if (otherSpeeds.length > 0)
                         for (let i=0; i<otherSpeeds.length; i++)
@@ -151,16 +268,62 @@ export class TokenControl{
                     txt += speed;
                 }
                 else if (stats == 'Init') {
-                    let init = attributes.initiative.totalModifier;
-                    if (init != undefined) txt += init;
+                    const value = attributes.init.value;
+                    if (value != undefined) {
+                        if (value >= 0) txt += "+";
+                        txt += value;
+                    }
+                }
+                else if (stats == 'Ability') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    txt += token.actor.data.data.abilities?.[ability].value;
+                }
+                else if (stats == 'AbilityMod') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    const value = token.actor.data.data.abilities?.[ability].mod;
+                    if (value >= 0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'Save') {        
+                    let ability = settings.save ? settings.save : 'fort';
+                    if (ability == 'fort') ability = 'fortitude';
+                    else if (ability == 'ref') ability = 'reflex';
+                    else if (ability == 'will') ability = 'will';
+                    const value = token.actor.data.data.saves?.[ability].value;
+                    if (value >= 0) txt += "+";
+                    txt += value;
+                }
+                else if (stats == 'Skill') {
+                    const skill = settings.skill ? settings.skill : 'acr';
+                    const value = token.actor.data.data.skills?.[skill].totalModifier;
+                    if (value >= 0) txt += '+';
+                    txt += value;
                 }
             }
-            else if (system == 'demonlord' && game.system.id == 'demonlord'){
+            else if (game.system.id == 'demonlord'){
                 let characteristics = token.actor.data.data.characteristics;
                 if (stats == 'HP') txt += characteristics.health.value + "/" + characteristics.health.max;
+                else if (stats == 'HPbox') {
+                    uses = {
+                        available: characteristics.health.value,
+                        maximum: characteristics.health.max
+                    }
+                }
                 else if (stats == 'AC') txt += characteristics.defense;
                 else if (stats == 'Speed') txt += characteristics.speed;
                 else if (stats == 'Init') txt += token.actor.data.data.fastturn ? "FAST" : "SLOW";
+                else if (stats == 'Ability') {        
+                    const ability = settings.ability ? settings.ability : 'strength';
+                    const value = token.actor.data.data.attributes?.[ability].value;
+                    if (value >=0) txt += '+';
+                    txt += value;
+                }
+                else if (stats == 'AbilityMod') {        
+                    const ability = settings.ability ? settings.ability : 'strength';
+                    const value = token.actor.data.data.attributes?.[ability].modifier;
+                    if (value >=0) txt += '+';
+                    txt += value;
+                }
             }
             else {
                 //Other systems
@@ -171,6 +334,10 @@ export class TokenControl{
             }
 
             if (settings.onClick == 'visibility') { //toggle visibility
+                if (MODULE.getPermission('TOKEN','VISIBILITY') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 ring = 1;
                 if (token.data.hidden){
                     ring = 2;
@@ -182,6 +349,10 @@ export class TokenControl{
                 }
             }
             else if (settings.onClick == 'combatState') { //toggle combat state
+                if (MODULE.getPermission('TOKEN','COMBAT') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 ring = 1;
                 if (token.inCombat){
                     ring = 2;
@@ -203,15 +374,19 @@ export class TokenControl{
                 }
             }
             else if (settings.onClick == 'condition') { //toggle condition
+                if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 ring = 1;
-                if ((system == 'dnd5e' && game.system.id == 'dnd5e') || (system == 'dnd3.5e' && game.system.id == 'D35E') || (system == 'pf1e' && game.system.id == 'pf1')){
+                if (game.system.id == 'dnd5e' || game.system.id == 'D35E' || game.system.id == 'pf1'){
                     const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) {
                         let effect = CONFIG.statusEffects.find(e => e.id === condition);
                         iconSrc = effect.icon;
-                        let effects = token.actor.effects.entries;
+                        let effects = compatibleCore("0.8.1") ? token.actor.effects.contents : token.actor.effects.entries;
                         let active = effects.find(e => e.isTemporary === condition);
                         if (active != undefined){
                             ring = 2;
@@ -219,8 +394,8 @@ export class TokenControl{
                         } 
                     } 
                 }
-                else if (system == 'pf2e' && game.system.id == 'pf2e') {
-                    const condition = settings.conditionPF2E ? settings.conditionPF2E : 'removeAll';
+                else if (game.system.id == 'pf2e') {
+                    const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) {
@@ -234,8 +409,8 @@ export class TokenControl{
                         iconSrc = this.pf2eCondition(condition);
                     } 
                 }
-                else if (system == 'demonlord' && game.system.id == 'demonlord'){
-                    const condition = settings.conditionDemonlord ? settings.conditionDemonlord : 'removeAll';
+                else if (game.system.id == 'demonlord'){
+                    const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) {
@@ -253,7 +428,31 @@ export class TokenControl{
                     iconSrc = "";
                 overlay = true;
             }
+            else if (settings.onClick == 'cubCondition') { //Combat Utility Belt conditions
+                if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
+                ring = 1;
+                overlay = true;
+                const condition = settings.cubConditionName;
+                if (condition == undefined || condition == '') return;
+                if (icon == false) {
+                    let effect = CONFIG.statusEffects.find(e => e.label === condition);
+                    iconSrc = effect.icon;
+                    let effects = compatibleCore("0.8.1") ? token.actor.effects.contents : token.actor.effects.entries;
+                    let active = effects.find(e => e.isTemporary === effect.id);
+                    if (active != undefined){
+                        ring = 2;
+                        ringColor = "#FF7B00";
+                    } 
+                }
+            }
             else if (settings.onClick == 'wildcard') { //wildcard images
+                if (MODULE.getPermission('TOKEN','WILDCARD') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 if (icon == false) return;
                 const method = settings.wildcardMethod ? settings.wildcardMethod : 'iterate';
                 let value = parseInt(settings.wildcardValue);
@@ -285,12 +484,15 @@ export class TokenControl{
                     }
                 }
                 else return;
-                
-            }
+            } 
         }
         else {
             iconSrc += "";
             if (settings.onClick == 'visibility') { //toggle visibility
+                if (MODULE.getPermission('TOKEN','VISIBILITY') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 if (icon == false) {
                     iconSrc = window.CONFIG.controlIcons.visibility;
                     ring = 2;
@@ -298,6 +500,10 @@ export class TokenControl{
                 }
             }
             else if (settings.onClick == 'combatState') { //toggle combat state
+                if (MODULE.getPermission('TOKEN','COMBAT') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
                 if (icon == false) {
                     iconSrc = window.CONFIG.controlIcons.combat;
                     ring = 2;
@@ -312,22 +518,26 @@ export class TokenControl{
                 }
             }
             else if (settings.onClick == 'condition') { //toggle condition
-                if ((system == 'dnd5e' && game.system.id == 'dnd5e') || (system == 'dnd3.5e' && game.system.id == 'D35E') || (system == 'pf1e' && game.system.id == 'pf1')){
+                if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
+                if (game.system.id == 'dnd5e' || game.system.id == 'D35E' || game.system.id == 'pf1'){
                     const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) 
                         iconSrc = CONFIG.statusEffects.find(e => e.id === condition).icon;
                 }
-                else if (system == 'pf2e' && game.system.id == 'pf2e') {
-                    const condition = settings.conditionPF2E ? settings.conditionPF2E : 'removeAll';
+                else if (game.system.id == 'pf2e') {
+                    const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) 
                         iconSrc = this.pf2eCondition(condition);
                 }
-                else if (system == 'demonlord' && game.system.id == 'demonlord'){
-                    const condition = settings.conditionDemonlord ? settings.conditionDemonlord : 'removeAll';
+                else if (game.system.id == 'demonlord'){
+                    const condition = settings.condition ? settings.condition : 'removeAll';
                     if (condition == 'removeAll' && icon == false)
                         iconSrc = window.CONFIG.controlIcons.effects;
                     else if (icon == false) 
@@ -336,10 +546,24 @@ export class TokenControl{
                 ring = 1;
                 overlay = true;
             }
+            else if (settings.onClick == 'cubCondition') { //Combat Utility Belt conditions
+                if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) {
+                    streamDeck.noPermission(context);
+                    return;
+                }
+                const condition = settings.cubConditionName;
+                if (condition == undefined || condition == '') return;
+                if (icon == false) {
+                    iconSrc = CONFIG.statusEffects.find(e => e.label === condition).icon;
+                }
+                ring = 1;
+                overlay = true;
+            }
         }
         if (icon == false){
+            if (MODULE.getPermission('TOKEN','STATS') == false) stats = statsOld;
             if (stats == 'HP' || stats == 'TempHP') //HP
-                iconSrc = "modules/MaterialDeck/img/token/hp.png";
+                iconSrc = "modules/MaterialDeck/img/token/hp_empty.png";
             else if (stats == 'AC' || stats == 'ShieldHP') //AC
                 iconSrc = "modules/MaterialDeck/img/token/ac.webp";
             else if (stats == 'Speed') //Speed
@@ -351,28 +575,46 @@ export class TokenControl{
             else if (stats == 'PassiveInvestigation') 
                 iconSrc = "modules/MaterialDeck/img/black.png";
         } 
-        streamDeck.setIcon(context,iconSrc,background,ring,ringColor,overlay);
+        streamDeck.setIcon(context,iconSrc,{background:background,ring:ring,ringColor:ringColor,overlay:overlay,uses:uses,hp:hp});
         streamDeck.setTitle(txt,context);
     }
-    
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
     async keyPress(settings){
-        if (MODULE.selectedTokenId == undefined) return;
         const tokenId = MODULE.selectedTokenId;
 
-        const token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
+        const selection = settings.selection ? settings.selection : 'selected';
+        const tokenIdentifier = settings.tokenName ? settings.tokenName : '';
+        
+        let token;
+        if (selection == 'selected') token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
+        else if (selection != 'selected' && tokenIdentifier == '') {}
+        else if (selection == 'tokenName') token = canvas.tokens.children[0].children.find(p => p.name == tokenIdentifier);
+        else if (selection == 'actorName') token = canvas.tokens.children[0].children.find(p => p.actor.name == tokenIdentifier);
+        else if (selection == 'tokenId') token = canvas.tokens.children[0].children.find(p => p.id == tokenIdentifier);
+        else if (selection == 'actorId') token = canvas.tokens.children[0].children.find(p => p.actor.id == tokenIdentifier);
+
         if (token == undefined) return;
+        if (token.owner == false && token.observer == true && MODULE.getPermission('TOKEN','OBSERVER') == false ) return;
+        if (token.owner == false && token.observer == false && MODULE.getPermission('TOKEN','NON_OWNED') == false ) return;
 
-        let system = settings.system ? settings.system : 'dnd5e';
-
-        let onClick = (system == 'demonlord') ? settings.onClickDemonlord : settings.onClick;
-        if (onClick == undefined) onClick = 'doNothing';
+        const onClick = settings.onClick ? settings.onClick : 'doNothing';
         
         if (onClick == 'doNothing')   //Do nothing
             return;
+        else if (onClick == 'select'){ //select token
+            token.control();
+        }
         else if (onClick == 'center'){ //center on token
             let location = token.getCenter(token.x,token.y); 
             canvas.animatePan(location);
         }
+        else if (onClick == 'centerSelect'){ //center on token and select
+            const location = token.getCenter(token.x,token.y); 
+            canvas.animatePan(location);
+            token.control();
+        }
         else if (onClick == 'charSheet'){ //Open character sheet
             const element = document.getElementById(token.actor.sheet.id);
             if (element == null) token.actor.sheet.render(true);
@@ -384,16 +626,19 @@ export class TokenControl{
             else token.sheet.close();
         }
         else if (onClick == 'visibility') {    //Toggle visibility
+            if (MODULE.getPermission('TOKEN','VISIBILITY') == false ) return;
             token.toggleVisibility();
         }
         else if (onClick == 'combatState') {    //Toggle combat state
+            if (MODULE.getPermission('TOKEN','COMBAT') == false ) return;
             token.toggleCombat();
         }
         else if (onClick == 'target') {    //Target token
             token.setTarget(!token.isTargeted,{releaseOthers:false});
         }
         else if (onClick == 'condition') {    //Toggle condition
-            if ((system == 'dnd5e' && game.system.id == 'dnd5e') || (system == 'dnd3.5e' && game.system.id == 'D35E') || (system == 'pf1e' && game.system.id == 'pf1')){
+            if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) return;
+            if (game.system.id == 'dnd5e' || game.system.id == 'D35E' || game.system.id == 'pf1'){
                 const condition = settings.condition ? settings.condition : 'removeAll';
                 if (condition == 'removeAll'){
                     for( let effect of token.actor.effects)
@@ -404,8 +649,8 @@ export class TokenControl{
                     await token.toggleEffect(effect);
                 }
             }
-            else if (system == 'pf2e' && game.system.id == 'pf2e'){
-                const condition = settings.conditionPF2E ? settings.conditionPF2E : 'removeAll';
+            else if (game.system.id == 'pf2e'){
+                const condition = settings.condition ? settings.condition : 'removeAll';
                 if (condition == 'removeAll'){
                     for( let effect of token.actor.effects)
                         await effect.delete();
@@ -415,8 +660,8 @@ export class TokenControl{
                     await token.toggleEffect(effect);
                 }
             }  
-            else if (system == 'demonlord' && game.system.id == 'demonlord'){
-                const condition = settings.conditionDemonlord ? settings.conditionDemonlord : 'removeAll';
+            else if (game.system.id == 'demonlord'){
+                const condition = settings.condition ? settings.condition : 'removeAll';
                 if (condition == 'removeAll'){
                     for( let effect of token.actor.effects)
                         await effect.delete();
@@ -429,7 +674,17 @@ export class TokenControl{
             this.update(tokenId);
             
         }
+        else if (onClick == 'cubCondition') { //Combat Utility Belt conditions
+            if (MODULE.getPermission('TOKEN','CONDITIONS') == false ) return;
+            const condition = settings.cubConditionName;
+            if (condition == undefined || condition == '') return;
+
+            const effect = CONFIG.statusEffects.find(e => e.label === condition);
+            await token.toggleEffect(effect);
+            this.update(tokenId); 
+        }
         else if (onClick == 'vision'){
+            if (MODULE.getPermission('TOKEN','VISION') == false ) return;
             const token = canvas.tokens.children[0].children.find(p => p.id == tokenId);
             if (token == undefined) return;
             let tokenData = token.data;
@@ -468,13 +723,14 @@ export class TokenControl{
             data.lightAnimation = animation;
             token.update(data);
         }
-        else if (system == 'demonlord' && game.system.id == 'demonlord' && onClick == 'initiative'){
+        else if (game.system.id == 'demonlord' && onClick == 'initiative'){
             token.actor.update({
                 'data.fastturn': !token.actor.data?.data?.fastturn
             })
             
         }
         else if (onClick == 'wildcard') { //wildcard images
+            if (MODULE.getPermission('TOKEN','WILDCARD') == false ) return;
             const method = settings.wildcardMethod ? settings.wildcardMethod : 'iterate';
             let value = parseInt(settings.wildcardValue);
             if (isNaN(value)) value = 1;
@@ -508,7 +764,50 @@ export class TokenControl{
             iconSrc = images[imgNr];
             token.update({img: iconSrc})
         }
+        else if (onClick == 'macro') {  //call a macro
+            const settingsNew = {
+                target: token,
+                macroMode: settings.macroMode,
+                macroNumber: settings.macroId,
+                macroArgs: settings.macroArgs
+            }
+            macroControl.keyPress(settingsNew);
+        }
+        else if (onClick == 'roll') {   //roll skill/save/ability
+            const roll = settings.roll ? settings.roll : 'abilityCheck';
+            const ability = settings.rollAbility ? settings.rollAbility : 'str';
+            const skill = settings.rollSkill ? settings.rollSkill : 'acr';
+            const save = settings.rollSave ? settings.rollSave : 'str';
+
+            if (game.system.id == 'pf2e') {
+                if (roll == 'abilityCheck') token.actor.data.data.saves?.[ability].roll();
+                else if (roll == 'save') {
+                    let ability = save;
+                    if (ability == 'fort') ability = 'fortitude';
+                    else if (ability == 'ref') ability = 'reflex';
+                    else if (ability == 'will') ability = 'will';
+                    token.actor.data.data.saves?.[ability].roll();
+                }
+                else if (roll == 'skill') token.actor.data.data.skills?.[skill].roll();
+            }
+            if (roll == 'abilityCheck') token.actor.rollAbilityTest(ability);
+            else if (roll == 'save') {
+                if (game.system.id == 'dnd5e') token.actor.rollAbilitySave(save);
+                else token.actor.rollSavingThrow(save);
+            }
+            else if (roll == 'skill') token.actor.rollSkill(skill);
+            else if (roll == 'initiative') token.actor.rollInitiative();
+            else if (roll == 'deathSave') token.actor.rollDeathSave();
+            else if (roll == 'grapple') token.actor.rollGrapple();
+            else if (roll == 'bab') token.actor.rollBAB();
+            else if (roll == 'melee') token.actor.rollMelee();
+            else if (roll == 'ranged') token.actor.rollRanged();
+            else if (roll == 'cmb') token.actor.rollCMB();
+            else if (roll == 'attack') token.actor.rollAttack();
+            else if (roll == 'defenses') token.actor.rollDefenses();
+        }
         else if (onClick == 'custom') {//custom onClick function
+            if (MODULE.getPermission('TOKEN','CUSTOM') == false ) return;
             const formula = settings.customOnClickFormula ? settings.customOnClickFormula : '';
             if (formula == '') return;
 
@@ -516,19 +815,39 @@ export class TokenControl{
             let formulaArrayTemp;
             let split1 = formula.split(';');
             for (let i=0; i<split1.length; i++){
+                let macro = false;
+                let furnaceArguments = "";
                 let split2 = split1[i].split(' = ');
                 targetArrayTemp = split2[0];
                 formulaArrayTemp = split2[1];
-
                 let targetArray = this.splitCustom(targetArrayTemp);
-
                 for (let i=0; i<targetArray.length; i++){
                     if (targetArray[i][0] == '@') {
                         const dataPath = targetArray[i].split('@')[1].split('.');
                         targetArray[i] = dataPath;
+                        if (dataPath == 'macro') {
+                            macro = true;
+                        }
+                    }
+                    else if (macro) {
+                        const data = targetArray[i].split('[');
+                        if (data != undefined && data.length > 1) targetArray[i] = data[1];
+                        if (i > 1) {
+                            if (furnaceArguments != "") furnaceArguments += " ";
+                            furnaceArguments += "\"" + targetArray[i] + "\"";
+                        }
                     } 
                 }
-
+                if (macro) {
+                    const settingsNew = {
+                        target: token,
+                        macroMode: 'name',
+                        macroNumber: targetArray[1],
+                        macroArgs: furnaceArguments
+                    }
+                    macroControl.keyPress(settingsNew);
+                    continue;
+                }
                 let formulaArray = this.splitCustom(formulaArrayTemp);
 
                 let value = 0;
@@ -585,7 +904,7 @@ export class TokenControl{
                                 if (path != '') path += '.';
                                 path += targetArray[i][j];
                             }
-                            actor.update({[path]:value})
+                            await actor.update({[path]:value})
                         }
                         else {
                             let path = '';
@@ -593,9 +912,9 @@ export class TokenControl{
                                 if (path != '') path += '.';
                                 path += targetArray[i][j];
                             }
-                            actor.update({[path]:value})
+                            await actor.update({[path]:value})
                         }
-                        
+                        this.update(token.id);
                     }
                     else {
                         data = token;
@@ -604,8 +923,10 @@ export class TokenControl{
                             if (path != '') path += '.';
                             path += targetArray[i][j];
                         }
-                        token.update({[path]:value})
+                        await token.update({[path]:value})
+                        this.update(token.id);
                     }
+                    
                 }
             }
         }

templates/helpMenu.html

@@ -74,6 +74,18 @@
                 This improves the update speed, but increases memory usage.</li>
         </ul>
 
+        <BR CLEAR="right" />
+
+        <h2>User Permission Configuration</h2>
+        <img src="modules/MaterialDeck/wiki/img/PermissionConfig.png" align="right" HSPACE="5" width="450">
+        Using the 'User Permission Configuration' screen, the GM can configure what Material Deck functions users have access to.<br>
+        Each action has various settings, and these settings can be set for each user role.<br>
+        <br>
+        To save the settings, press the 'Save Configuration' button at the lower left, or to set the settings back to the default values, press 'Reset Defaults' in the lower right.<br>
+        <br>
+
+        <BR CLEAR="right" />
+
         <h2>Playlist Configuration</h2>
         <img src="modules/MaterialDeck/wiki/img/PlaylistConfig.png" align="right" HSPACE="5" width="350">
         The playlist configuration screen configures the playlists that you control using the <a href="https://github.com/CDeenen/MaterialDeck/wiki/Playlist-Action">Playlist action</a>.<br>

templates/macroConfig.html

@@ -20,7 +20,7 @@
                             {{#select this.macro}}
                                 <option value="">{{localize "MaterialDeck.None"}}</option>
                                 {{#each ../../macros}}
-                                <option value="{{this._id}}">{{this.name}}</option>
+                                <option value="{{this.id}}">{{this.name}}</option>
                                 {{/each}}
                             {{/select}}
                         </select>

templates/playlistConfig.html

@@ -26,7 +26,7 @@
                 {{#select this.playlist}}
                     <option value="">{{localize "MaterialDeck.None"}}</option>
                     {{#each ../playlists}}
-                    <option value="{{this._id}}">{{this.name}}</option>
+                    <option value="{{this.id}}">{{this.name}}</option>
                     {{/each}}
                 {{/select}}
             </select>

templates/userPermissionConfig.html

@@ -0,0 +1,113 @@
+<form autocomplete="off" onsubmit="event.preventDefault();">
+
+    <style>
+    header.table-header {
+        background: rgba(0, 0, 0, 0.5);
+        padding: 5px;
+        border: 1px solid #191813;
+        text-align: center;
+        color: #f0f0e0;
+        font-weight: bold;
+        text-shadow: 1px 1px #000;
+      }
+      ul.permissions-list {
+        list-style: none;
+        margin: 0;
+        padding: 0;
+
+        overflow: hidden auto;
+        scrollbar-width: thin;
+      }
+      li.permission {
+        padding: 5px;
+        border-bottom: 1px solid #7a7971;
+      }
+      li.permission .form-fields {
+        justify-content: space-around;
+      }
+      li.permission input[type="checkbox"] {
+        margin: 0;
+      }
+      .index {
+        flex: 0 0 200px;
+        text-align: left;
+        font-weight: bold;
+      }
+      .hint {
+        flex: 0 0 100%;
+        color: #4b4a44;
+        font-size: 13px;
+        margin: 5px 0 0;
+      }
+
+      .form-fields {
+        justify-content: space-around;
+        }
+      </style>
+
+
+    <p class="notes">{{localize "MaterialDeck.Perm.Instructions"}}</p>
+    <hr>
+    
+    <div class="form-group">
+        <h2>{{ localize "MaterialDeck.Perm.ENABLE.label" }}</h2>
+    </div>
+    <header class="table-header flexrow">
+        <label class="index">{{ localize "PERMISSION.Permission" }}</label>
+        {{#each roles as |rl r|}}
+        <label>{{ localize rl}}</label>
+        {{/each}}
+    </header>
+    
+
+        <li class="permission form-group">
+            <label class="index">{{ localize "MaterialDeck.Perm.ENABLE.ENABLE.label" }}</label>
+            <div class="form-fields">
+                {{#each enable as |r|}}
+                    <input type="checkbox" name="ENABLE" {{checked r}}>
+                {{/each}}
+            </div>
+            <p class="hint">{{ localize "MaterialDeck.Perm.ENABLE.ENABLE.hint" }}</p>
+        </li>
+
+   
+    {{#each actions as |a|}}
+    
+    <div class="form-group">
+        <h2>{{ localize a.label }}</h2>
+    </div>
+    <header class="table-header flexrow">
+        <label class="index">{{ localize "PERMISSION.Permission" }}</label>
+        {{#each ../roles as |rl r|}}
+        <label>{{ localize rl}}</label>
+        {{/each}}
+    </header>
+    
+        <ul class="permissions-list">
+        {{#each a.permissions as |p|}}
+        <li class="permission form-group">
+            <label class="index">{{ localize p.label }}</label>
+            <div class="form-fields">
+                {{#each p.roles as |r|}}
+                    <input type="checkbox" id="{{p.id}}" name="{{a.id}}.{{p.id}}" {{checked r}}>
+                {{/each}}
+            </div>
+            <p class="hint">{{ localize p.hint }}</p>
+        </li>
+        {{/each}}
+    </ul>
+    
+    
+    {{/each}}
+    
+
+    <div class="form-group">
+        <button type="submit" name="submit">
+            <i class="fas fa-save"></i> {{localize 'PERMISSION.Submit'}}
+        </button>
+
+        <button type="button" name="reset">
+            <i class="fas fa-sync"></i> {{localize 'PERMISSION.Reset'}}
+        </button>
+    </div>
+</form>