v1.3.2

MaterialDeck.js

@@ -25,6 +25,9 @@ export var selectedTokenId;
 
 let ready = false;
 let activeSounds = [];
+
+export let hotbarUses = false;
+export let calculateHotbarUses;
        
 //CONFIG.debug.hooks = true;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -53,19 +56,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 +85,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 +118,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 +181,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 +208,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 +234,10 @@ export function sendWS(txt){
  * Ready hook
  * Attempt to open the websocket
  */
-Hooks.once('ready', ()=>{
+Hooks.once('ready', async()=>{
     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 +249,63 @@ Hooks.once('ready', ()=>{
     externalModules = new ExternalModules();
     sceneControl = new SceneControl();
 
+    game.socket.on(`module.MaterialDeck`, async(payload) =>{
+        //console.log(payload);
+        if (payload.msgType == "playSound") playTrack(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,6 +332,11 @@ Hooks.once('ready', ()=>{
             volume: arrayVolume
         });
     }
+
+    const hotbarUsesTemp = game.modules.get("illandril-hotbar-uses");
+    if (hotbarUsesTemp != undefined) {
+        hotbarUses = true;
+    }
     
 });
 
@@ -290,6 +366,7 @@ Hooks.on('updateToken',(scene,token)=>{
     let tokenId = token._id;
     if (tokenId == selectedTokenId)
         tokenControl.update(selectedTokenId);
+    if (macroControl != undefined) macroControl.updateAll();
 });
 
 Hooks.on('updateActor',(scene,actor)=>{
@@ -302,6 +379,7 @@ Hooks.on('updateActor',(scene,actor)=>{
                 tokenControl.update(selectedTokenId);
         }
     }
+    if (macroControl != undefined) macroControl.updateAll();
 });
 
 Hooks.on('controlToken',(token,controlled)=>{
@@ -313,8 +391,13 @@ 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 (enableModule == false || ready == false) return;
     if (macroControl != undefined) macroControl.hotbar(hotbar.macros);
@@ -358,6 +441,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)=>{
@@ -395,6 +479,26 @@ 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

changelog.md

@@ -1,4 +1,84 @@
 # Changelog Material Deck Module
+## 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,130 @@
     "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.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.2",
+    "minimumSDversion": "1.3.2",
     "minimumMSversion": "1.0.2",
     "author": "CDeenen",
     "esmodules": [

src/combattracker.js

@@ -24,8 +24,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);
+                return;
+            }
             if (combat != null && combat != undefined && combat.turns.length != 0){
                 const initiativeOrder = combat.turns;
                 let nr = settings.combatantNr - 1;
@@ -39,26 +44,44 @@ export class CombatTracker{
                     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;
                 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 +98,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 +125,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 +137,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,7 +164,7 @@ 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;
@@ -133,6 +173,7 @@ export class CombatTracker{
             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';

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

@@ -16,11 +16,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 +31,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 +52,17 @@ 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 { //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;
@@ -74,24 +75,33 @@ export class MacroControl{
                     if (macros[j].key == macroNumber)
                         macroId = (macros[j].macro == null) ? undefined : macros[j].macro._id; 
                 }
-            }
-            let src = "";
-            let name = "";
+            }  
+        }
 
-            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);
+
+        
+        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 +109,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 = "";
 
@@ -122,12 +138,14 @@ export class MacroControl{
                 }
             }
             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);
         }
     }
@@ -137,9 +155,12 @@ export class MacroControl{
         let macroNumber = settings.macroNumber;
         if(macroNumber == undefined || isNaN(parseInt(macroNumber))) macroNumber = 0;
         
-        if (mode == 'hotbar' || mode == 'visibleHotbar' || mode == 'customHotbar')
+        if (mode == 'hotbar' || mode == 'visibleHotbar' || mode == 'customHotbar'){
+            if ((MODULE.getPermission('MACRO','HOTBAR') == false )) return;
             this.executeHotbar(macroNumber,mode);
+        } 
         else {
+            if ((MODULE.getPermission('MACRO','MACROBOARD') == false )) return;
             if (settings.macroBoardMode == 'offset') {
                 let macroOffset = settings.macroOffset;
                 if (macroOffset == undefined) macroOffset = 0;
@@ -199,14 +220,4 @@ export class MacroControl{
             }
         }
     }
-}
-
-
-
-
-
-
-
-
-
-
+}

src/misc.js

@@ -25,6 +25,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');
 
@@ -109,9 +113,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 +153,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;
@@ -252,8 +270,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 +312,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');
 
@@ -530,7 +562,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

@@ -11,6 +11,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 +49,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 +93,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);
 
@@ -88,9 +110,7 @@ export class Move{
         }
     }
 
-    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;

src/othercontrols.js

@@ -66,6 +66,11 @@ export class OtherControls{
     //////////////////////////////////////////////////////////////////////////////////////////////////
 
     updatePause(settings,context){
+        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,10 +86,13 @@ 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
@@ -103,6 +111,10 @@ export class OtherControls{
     //////////////////////////////////////////////////////////////////////////////////////////
     
     updateControl(settings,context){
+        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 +130,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 +152,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 +170,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 +183,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 +199,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 +215,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 +230,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 +255,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 +267,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) {
@@ -243,6 +292,10 @@ export class OtherControls{
     //////////////////////////////////////////////////////////////////////////////////////////
 
     updateDarkness(settings,context){
+        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 +316,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;
 
@@ -284,16 +338,21 @@ export class OtherControls{
     //////////////////////////////////////////////////////////////////////////////////////////
 
     updateRollDice(settings,context){
+        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';
 
@@ -333,9 +392,14 @@ export class OtherControls{
     updateRollTable(settings,context){
         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 +407,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);
@@ -403,6 +475,10 @@ export class OtherControls{
     }
     
     updateSidebar(settings,context){
+        if (MODULE.getPermission('OTHER','SIDEBAR') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
         const sidebarTab = settings.sidebarTab ? settings.sidebarTab : 'chat';
         const background = settings.background ? settings.background : '#000000';
         const collapsed = ui.sidebar._collapsed;
@@ -413,10 +489,11 @@ export class OtherControls{
         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';
         
         if (sidebarTab == 'collapse'){
@@ -432,10 +509,17 @@ export class OtherControls{
     updateCompendium(settings,context){
         const name = settings.compendiumName;
         if (name == undefined) return;
+        if (MODULE.getPermission('OTHER','COMPENDIUM') == false ) {
+            streamDeck.noPermission(context);
+            return;
+        }
 
         const 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,31 +527,39 @@ 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);
         if (compendium == undefined) return;
+        if (compendium.private && MODULE.getPermission('OTHER','COMPENDIUM_ALL') == false) return;
         if (compendium.rendered) compendium.close();
         else compendium.render(true);
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    //Journals
-    //game.journal.entries[0].render(true)
-
     updateJournal(settings,context){
         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;
+        }
+
         const background = settings.background ? settings.background : '#000000';
         const ringOffColor = settings.offRing ? settings.offRing : '#000000';
         const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
@@ -475,16 +567,19 @@ 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});
     }
 
     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;
 
+        if (MODULE.getPermission('OTHER','JOURNAL') == false ) return;
+        if (journal.permission < 2 && MODULE.getPermission('OTHER','JOURNAL_ALL') == false ) return;
+
         const element = document.getElementById("journal-"+journal.id);
         if (element == null) journal.render(true);
         else journal.sheet.close();
@@ -493,12 +588,17 @@ export class OtherControls{
 //////////////////////////////////////////////////////////////////////////////////////////
 
     updateChatMessage(settings,context){
+        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

@@ -18,39 +18,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 +73,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'){
@@ -121,16 +121,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 +163,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,16 +178,17 @@ 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];
@@ -185,22 +198,48 @@ export class PlaylistControl{
                     }
                 }
             }
-            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 +253,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;

src/scene.js

@@ -30,6 +30,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,6 +48,10 @@ 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--;
@@ -75,8 +83,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 +98,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 +115,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 +143,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;
@@ -156,9 +175,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 +195,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,83 @@
 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],
+        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 +85,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 +98,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 +108,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 +121,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 +145,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 +163,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 +195,23 @@ 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];
+    }
+    game.settings.set(MODULE.moduleName,'userPermission',permissionSettings);
+    
+
 }
 
 export class helpMenu extends FormApplication {
@@ -159,3 +255,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

@@ -20,6 +20,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 +45,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 +57,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
@@ -99,6 +105,7 @@ export class SoundboardControl{
     }
 
     keyPressUp(settings){
+        if (MODULE.getPermission('SOUNDBOARD','PLAY') == false ) return;
         const mode = settings.soundboardMode ? settings.soundboardMode : 'playSound';
 
         if (mode != 'playSound') return;
@@ -133,7 +140,7 @@ 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);
             if (sound == undefined) return;

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,7 @@ export class StreamDeck{
             }
         }
         else {
-            ctx.fillStyle = background;
-            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            
         }
         if (format == 'icon' && url != ""){
             ctx.font = '600 90px "Font Awesome 5 Free"';
@@ -400,6 +411,76 @@ export class StreamDeck{
                 yStart = 0;
             }
             ctx.drawImage(img, xStart+margin, yStart+margin, renderableWidth - 2*margin, renderableHeight - 2*margin);
+            if (uses != undefined && (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 +490,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 +525,12 @@ export class StreamDeck{
         this.imageBufferCounter = 0;
         this.imageBuffer = [];
     }
+
+    noPermission(context,showTxt=true){
+        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

@@ -7,7 +7,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 +20,58 @@ 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;
+        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 +90,17 @@ 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') {
                     txt += attributes.hp.value + "/" + attributes.hp.max;
                 }
+                else if (stats == 'HPbox') {
+                    uses = {
+                        available: attributes.hp.value,
+                        maximum: attributes.hp.max
+                    }
+                }
                 else if (stats == 'TempHP') {
                     txt += attributes.hp.temp;
                     if (attributes.hp.tempmax != null)
@@ -99,10 +141,30 @@ export class TokenControl{
                 else if (stats == 'Init') txt += attributes.init.total;
                 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';
+                    txt += token.actor.data.data.abilities?.[ability].mod;
+                }
+                else if (stats == 'AbilitySave') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    txt += token.actor.data.data.abilities?.[ability].save;
+                }
+                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;
@@ -130,10 +192,29 @@ export class TokenControl{
                     txt += speed;
                 }
                 else if (stats == 'Init') txt += attributes.init.total;
+                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';
+                    txt += token.actor.data.data.abilities?.[ability].mod;
+                }
+                else if (stats == 'AbilitySave') {        
+                    const ability = settings.ability ? settings.ability : 'str';
+                    txt += token.actor.data.data.abilities?.[ability].save;
+                }
+                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 {
@@ -155,12 +236,26 @@ export class TokenControl{
                     if (init != undefined) txt += init;
                 }
             }
-            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';
+                    txt += token.actor.data.data.attributes?.[ability].value;
+                }
+                else if (stats == 'AbilityMod') {        
+                    const ability = settings.ability ? settings.ability : 'strength';
+                    txt += token.actor.data.data.attributes?.[ability].modifier;
+                }
             }
             else {
                 //Other systems
@@ -171,6 +266,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 +281,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,8 +306,12 @@ 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;
@@ -219,8 +326,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 +341,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 +360,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 = 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 +416,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 +432,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 +450,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,8 +478,22 @@ 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";
             else if (stats == 'AC' || stats == 'ShieldHP') //AC
@@ -351,28 +507,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});
         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 +558,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 +581,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 +592,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 +606,17 @@ export class TokenControl{
             this.update(tokenId);
             
         }
+        else if (settings.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 +655,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;
@@ -509,6 +697,7 @@ export class TokenControl{
             token.update({img: iconSrc})
         }
         else if (onClick == 'custom') {//custom onClick function
+            if (MODULE.getPermission('TOKEN','CUSTOM') == false ) return;
             const formula = settings.customOnClickFormula ? settings.customOnClickFormula : '';
             if (formula == '') return;
 

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/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>