v1.4.10

Fixed rolls and conditions to work with latest pf2e version

MaterialDeck.js

@@ -8,7 +8,7 @@ import {SoundboardControl} from "./src/soundboard.js";
 import {OtherControls} from "./src/othercontrols.js";
 import {ExternalModules} from "./src/external.js";
 import {SceneControl} from "./src/scene.js";
-import {downloadUtility, compatibleCore} from "./src/misc.js";
+import {downloadUtility, compatibleCore, compareVersions} from "./src/misc.js";
 import {TokenHelper} from "./src/systems/tokenHelper.js";
 export var streamDeck;
 export var tokenControl;
@@ -23,6 +23,8 @@ export var tokenHelper;
 
 export const moduleName = "MaterialDeck";
 
+export let gamingSystem = "dnd5e";
+
 let ready = false;
 
 export let hotbarUses = false;
@@ -59,18 +61,18 @@ let WSconnected = false;
 async function analyzeWSmessage(msg){
     if (enableModule == false) return;
     const data = JSON.parse(msg);
-//    console.log("Received",data);
+    //console.log("Received",data);
 
     if (data.type == "connected" && data.data == "SD"){
         const msg = {
             target: "SD",
             type: "init",
-            system: game.system.id
+            system: gamingSystem
         }
         ws.send(JSON.stringify(msg));
-        
+        if (data.MSversion) msVersion = data.MSversion;
 
-        console.log("streamdeck connected to server");
+        console.log("streamdeck connected to server", msVersion);
         streamDeck.resetImageBuffer();
     }
 
@@ -88,10 +90,10 @@ async function analyzeWSmessage(msg){
         
         sdVersion = data.version;
 
-        if (data.version < minimumSDversion && updateDialog == undefined) {
+        if (!compareVersions(minimumSDversion,data.version) && updateDialog == undefined) {
             updateDialog = new Dialog({
                 title: "Material Deck: Update Needed",
-                content: "<p>The Stream Deck plugin version you're using is v" + data.version + ", which is incompatible with this verion of the module.<br>Update to v" + minimumSDversion + " or newer.</p>",
+                content: "<p>The Stream Deck plugin version you're using is v" + data.version + ", which is incompatible with this version of the module.<br>Update to v" + minimumSDversion + " or newer.</p>",
                 buttons: {
                  download: {
                   icon: '<i class="fas fa-download"></i>',
@@ -109,15 +111,20 @@ async function analyzeWSmessage(msg){
         }
     }
 
+    if (data.type == 'newDevice') {
+        streamDeck.newDevice(data.iteration,data.device);
+        return;
+    }
+
     if (data == undefined || data.payload == undefined) return;
-    //console.log("Received",data);
     const action = data.action;
     const event = data.event;
     const context = data.context;
     const coordinates = data.payload.coordinates;
     const settings = data.payload.settings;
     const device = data.device;
-    
+    const name = data.deviceName;
+    const type = data.deviceType;
 
     if (data.data == 'init'){
 
@@ -125,7 +132,9 @@ async function analyzeWSmessage(msg){
     if (event == 'willAppear' || event == 'didReceiveSettings'){
         if (coordinates == undefined) return;
         streamDeck.setScreen(action);
-        await streamDeck.setContext(device,data.size,data.deviceIteration,action,context,coordinates,settings);
+        await streamDeck.setContext(device,data.size,data.deviceIteration,action,context,coordinates,settings,name,type);
+
+        if (game.settings.get(moduleName, 'devices')?.[device]?.enable == false) return;
 
         if (action == 'token'){
             tokenControl.active = true;
@@ -153,6 +162,8 @@ async function analyzeWSmessage(msg){
     }
 
     else if (event == 'keyDown'){
+        if (game.settings.get(moduleName, 'devices')?.[device]?.enable == false) return;
+
         if (action == 'token')
             tokenControl.keyPress(settings);
         else if (action == 'macro')
@@ -172,6 +183,8 @@ async function analyzeWSmessage(msg){
     }
 
     else if (event == 'keyUp'){
+        if (game.settings.get(moduleName, 'devices')?.[device]?.enable == false) return;
+
         if (action == 'soundboard'){
             soundboard.keyPressUp(settings);
         }
@@ -211,7 +224,7 @@ function startWebsocket() {
         const msg2 = {
             target: "SD",
             type: "init",
-            system: game.system.id
+            system: gamingSystem
         }
         ws.send(JSON.stringify(msg2));
         clearInterval(wsInterval);
@@ -280,6 +293,9 @@ Hooks.once('ready', async()=>{
     registerSettings();
     enableModule = (game.settings.get(moduleName,'Enable')) ? true : false;
 
+    const systemOverride = game.settings.get(moduleName,'systemOverride');
+    gamingSystem = systemOverride != '' ? systemOverride : game.system.id;
+
     soundboard = new SoundboardControl();
     streamDeck = new StreamDeck();
     tokenControl = new TokenControl();
@@ -380,6 +396,11 @@ Hooks.once('ready', async()=>{
     if (hotbarUsesTemp != undefined) hotbarUses = true;
 });
 
+function updateActor(id) {
+    const token = tokenHelper.getTokenFromActorId(id)
+    tokenControl.update(token.id);
+}
+
 Hooks.on('updateToken',(scene,token)=>{
     if (enableModule == false || ready == false) return;
     let tokenId = token._id;
@@ -389,19 +410,28 @@ Hooks.on('updateToken',(scene,token)=>{
 
 Hooks.on('updateActor',(actor)=>{
     if (enableModule == false || ready == false) return;
-    let children = canvas.tokens.children[0].children;
-    for (let i=0; i<children.length; i++){
-        if (children[i].actor.id == actor._id){
-            let tokenId = children[i].id;
-            if (tokenId == canvas.tokens.controlled[0]?.id) {
-                tokenControl.update(canvas.tokens.controlled[0]?.id);
-            }
-                
-        }
-    }
+    updateActor(actor.id);
     if (macroControl != undefined) macroControl.updateAll();
 });
 
+Hooks.on('createActiveEffect',(data)=>{
+    if (enableModule == false || ready == false) return;
+    updateActor(data.parent.id);
+    return;
+});
+
+Hooks.on('deleteActiveEffect',(data)=>{
+    if (enableModule == false || ready == false) return;
+    updateActor(data.parent.id);
+    return;
+});
+
+Hooks.on('onActorSetCondition',(data)=>{
+    if (enableModule == false || ready == false) return;
+    updateActor(data.actor.id);
+    return;
+});
+
 Hooks.on('controlToken',(token,controlled)=>{
     if (enableModule == false || ready == false) return;
     if (controlled) {
@@ -572,6 +602,11 @@ Hooks.on('about-time.clockRunningStatus', ()=>{
     externalModules.updateAll();
 })
 
+Hooks.on('updateTile',()=>{
+    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,56 @@
 # Changelog Material Deck Module
+### v1.4.10 - 30-05-2022
+Fixes:
+<ul>
+    <li>Stream Deck plugin v1.4.10 was not properly recognized as compatible</li>
+</ul>
+
+Additions;
+<ul>
+    <li>Material Server version is now displayed in the Download Utility (MS v1.1.0+)</li>
+</ul>
+
+
+### v1.4.9 - 16-04-2022
+Fixes:
+<ul>
+<li>PF2e: Fixed rolls and conditions for compatibility with latest pf2e version. Thanks to Kyamsil</li>
+<li>Token Action => Set Vison: Setting light is working again</li>
+<li>Other Actions => Roll Dice: Roll result would show as 'NaN' in Foundry v9, this is fixed</li>
+</ul>
+
+Additions:
+<ul>
+<li>Added support for the Starfinder system</li>
+<li>External Modules => Added support for 'Monks Active Tile Triggers'</li>
+<li>Added 'System Override' module setting. If your system is not supported, MD defaults to 5e. Here you can choose a supported system that is most similar to yours and have Material Deck use that system instead.</li>
+<li>Token Action => Displayed Stats: A colored border is drawn around certain skills, saves, etc to indicate proficiency (compatible systems: dnd5e, pf2e). Thanks to Kyamsil</li>
+</ul>
+
+### v1.4.8 - 22-12-2021
+Fixes:
+<ul>
+<li>'Device Configuration' would not save its settings properly</li>
+</ul>
+
+
+### v1.4.7 - 20-12-2021
+Fixes:
+<ul>
+<li>External Modules => GM Screen: Changed to new api (thanks to akrigline)</li>
+<li>Fixed an issue where SDs would not iterate properly, causing errors (thanks to InnerGI)</li>
+<li>Fixed support for FXMaster. Requires FXMaster v2.0.0 or later (not officially released yet)</li>
+</ul>
+
+Additions:
+<ul>
+<li>Added compatibility for Foundry V0.9</li>
+<li>Added Forbidden Lands system (thanks to JackDCondon)</li>
+<li>Other Controls => Control Buttons: Added offset for 'Displayed Controls' and 'Displayed Tools'</li>
+<li>Added 'Device Configuration' to the module settings. You can use this to configure specific SD devices to not connect to a client</li>
+<li>Playlist Action => Added option to play next or previous track</li>
+</ul>
+
 ### v1.4.6 - 07-09-2021
 Fixes:
 <ul>

img/token/skills/SOURCES.txt

@@ -10,6 +10,7 @@ his.png: https://game-icons.net/1x1/delapouite/backward-time.html
 ins.png: https://game-icons.net/1x1/lorc/light-bulb.html
 itm.png: https://game-icons.net/1x1/lorc/one-eyed.html
 inv.png: https://game-icons.net/1x1/lorc/magnifying-glass.html
+lor.png: https://game-icons.net/1x1/lorc/bookmarklet.html
 med.png: https://game-icons.net/1x1/delapouite/first-aid-kit.html
 nat.png: https://game-icons.net/1x1/delapouite/forest.html
 occ.png: https://game-icons.net/1x1/skoll/pentacle.html

lang/en.json

@@ -9,6 +9,7 @@
     "MaterialDeck.Sett.Enable": "Enable module",
     "MaterialDeck.Sett.Help": "Help",
     "MaterialDeck.Sett.Permission": "User Permission Configuration",
+    "MaterialDeck.DeviceConfig.Title": "Device Configuration",
     "MaterialDeck.Sett.PlaylistConfig": "Playlist Configuration",
     "MaterialDeck.Sett.MacroConfig": "Macro Configuration",
     "MaterialDeck.Sett.SoundboardConfig": "Soundboard Configuration",
@@ -20,6 +21,8 @@
     "MaterialDeck.Sett.ImageBrightnessHint": "Sets the brightness of the default white images. If the Image Cache Size is bigger than 0, perform a refresh for instant results.",
     "MaterialDeck.Sett.NrOfConnMessages": "Number of Connection Warnings",
     "MaterialDeck.Sett.NrOfConnMessagesHint": "Sets the number of times a connection warning is displayed if Material Deck cannot connect to Material Server. If set to 0, it will give not be limited.",
+    "MaterialDeck.Sett.SystemOverride": "System Override",
+    "MaterialDeck.Sett.SystemOverrideHint": "Overrides the automatic gaming system detection. Unsupported systems default to dnd5e, but if an unsupported system is similar to a different system you can specify that system here. Leave empty for system autodetection.",
 
     "MaterialDeck.PL.Unrestricted": "Unrestricted",
     "MaterialDeck.PL.OneTrackPlaylist": "One track per playlist",
@@ -32,7 +35,7 @@
     "MaterialDeck.Playlists": "Playlists",
     "MaterialDeck.Playlist": "Playlist",
     "MaterialDeck.FilePicker": "File Picker",
-    "MaterialDeck.FurnaceArgs": "Furnace arguments",
+    "MaterialDeck.FurnaceArgs": "Macro arguments",
     "MaterialDeck.Background": "Background",
     "MaterialDeck.Macro": "Macro",
     "MaterialDeck.Sound": "Sound",
@@ -58,6 +61,8 @@
     "MaterialDeck.Import": "Import",
     "MaterialDeck.Export": "Export",
     "MaterialDeck.Filename": "Filename",
+    "MaterialDeck.Id": "Id",
+    "MaterialDeck.Type": "Type",
 
     "MaterialDeck.ExportDialog.Title": "Export",
     "MaterialDeck.ExportDialog.SoundboardContent": "Export the soundboard data. Please note that only the metadata is exported, so you will have to make sure the audio files are in the same relative location when you import them.",
@@ -200,7 +205,8 @@
     "MaterialDeck.DownloadUtility.SDplugin": "SD Plugin",
     "MaterialDeck.DownloadUtility.MSserver": "Material Server",
     "MaterialDeck.DownloadUtility.Windows": "Windows",
-    "MaterialDeck.DownloadUtility.Macos": "MacOS",
+    "MaterialDeck.DownloadUtility.MacosM1": "MacOS (M1)",
+    "MaterialDeck.DownloadUtility.MacosIntel": "MacOS (Intel)",
     "MaterialDeck.DownloadUtility.Linux": "Linux",
     "MaterialDeck.DownloadUtility.Source": "Source",
     "MaterialDeck.DownloadUtility.Profiles": "Profiles",

lang/ja.json

@@ -200,7 +200,8 @@
     "MaterialDeck.DownloadUtility.SDplugin": "SDプラグイン",
     "MaterialDeck.DownloadUtility.MSserver": "Material Server",
     "MaterialDeck.DownloadUtility.Windows": "Windows",
-    "MaterialDeck.DownloadUtility.Macos": "MacOS",
+    "MaterialDeck.DownloadUtility.MacosM1": "MacOS (M1)",
+    "MaterialDeck.DownloadUtility.MacosIntel": "MacOS (Intel)",
     "MaterialDeck.DownloadUtility.Linux": "Linux",
     "MaterialDeck.DownloadUtility.Source": "ソース",
     "MaterialDeck.DownloadUtility.Profiles": "プロファイル",

module.json

@@ -2,7 +2,7 @@
   "name": "MaterialDeck",
   "title": "Material Deck",
   "description": "Material Deck allows you to control Foundry using an Elgato Stream Deck",
-  "version": "1.4.6",
+  "version": "1.4.10",
   "author": "CDeenen",
   "authors": {
     "name": "CDeenen",
@@ -12,17 +12,17 @@
     "reddit": "CDeenen123"
   },
   "flags": {
-    "minimumSDversion": "1.4.4",
+    "minimumSDversion": "1.4.7",
     "minimumMSversion": "1.0.2"
   },
-  "minimumSDversion": "1.4.4",
+  "minimumSDversion": "1.4.7",
   "minimumMSversion": "1.0.2",
   "esmodules": [
     "./MaterialDeck.js"
   ],
   "socket": true,
   "minimumCoreVersion": "0.7.5",
-  "compatibleCoreVersion": "0.8.9",
+  "compatibleCoreVersion": "9",
   "languages": [
     {
       "lang": "en",

src/external.js

@@ -69,6 +69,7 @@ export class ExternalModules{
         else if (module == 'lockView')      this.updateLockView(settings,context,device);
         else if (module == 'aboutTime')     this.updateAboutTime(settings,context,device);
         else if (module == 'soundscape')    this.updateSoundscape(settings,context,device);
+        else if (module == 'monksActiveTiles') this.updateMonksActiveTiles(settings,context,device);
     }
 
     keyPress(settings,context,device){
@@ -84,6 +85,7 @@ export class ExternalModules{
         else if (module == 'lockView')      this.keyPressLockView(settings,context,device);
         else if (module == 'aboutTime')     this.keyPressAboutTime(settings,context,device);
         else if (module == 'soundscape')    this.keyPressSoundscape(settings,context,device);
+        else if (module == 'monksActiveTiles') this.keyPressMonksActiveTiles(settings,context,device);
     }
 
     getModuleEnable(moduleId){
@@ -111,38 +113,20 @@ export class ExternalModules{
         let name = '';
         if (type == 'weatherControls') {
             const effect = (settings.weatherEffect == undefined) ? 'leaves' : settings.weatherEffect;
-            name = CONFIG.weatherEffects[effect].label;
-            icon = CONFIG.weatherEffects[effect].icon;
-            ring = this.findWeatherEffect(effect) != undefined ? 2 : 1;
+            name = CONFIG.fxmaster.weather[effect].label;
+            icon = CONFIG.fxmaster.weather[effect].icon;
+            ring = canvas.scene.getFlag("fxmaster", "effects")?.[`core_${effect}`] ? 2 : 1;
             ringColor = ring < 2 ? '#000000' : "#00ff00";
         }
-        else if (type == 'colorize') {
-            background = (settings.fxMasterColorizeColor == undefined) ? '#000000' : settings.fxMasterColorizeColor;
-            icon = "fas fa-palette";
-            name = game.i18n.localize("MaterialDeck.FxMaster.Colorize");
-            const filters = canvas.scene.getFlag("fxmaster", "filters");
-            ring = 2;
-            if (filters == undefined || filters['core_color'] == undefined) {
-                ringColor = "#000000";
-            }
-            else {
-                const colors = filters['core_color'].options;
-                let red = Math.ceil(colors.red*255).toString(16);
-                if (red.length == 1) red = '0' + red;
-                let green = Math.ceil(colors.green*255).toString(16);
-                if (green.length == 1) green = '0' + green;
-                let blue = Math.ceil(colors.blue*255).toString(16);
-                if (blue.length == 1) blue = '0' + blue;
-                ringColor = "#" + red + green + blue;
-            }
-        }
         else if (type == 'filters') {
             const filter = (settings.fxMasterFilter == undefined) ? 'underwater' : settings.fxMasterFilter;
             name = CONFIG.fxmaster.filters[filter].label;
             background = "#340057";
             if (displayIcon){
-                if (filter == 'underwater') icon = "fas fa-water";
+                if (filter == 'lightning') icon = "fas fa-bolt";
+                else if (filter == 'underwater') icon = "fas fa-water";
                 else if (filter == 'predator') icon = "fas fa-wave-square";
+                else if (filter == 'color') icon = "fas fa-palette";
                 else if (filter == 'oldfilm') icon = "fas fa-film";
                 else if (filter == 'bloom') icon = "fas fa-ghost";
             }
@@ -158,6 +142,7 @@ export class ExternalModules{
                     }
                 }
             }
+            if (filter == 'color') background = settings.fxMasterFilterColor ? settings.fxMasterFilterColor : '#ffffff';
         }
         else if (type == 'clear'){
             icon = "fas fa-trash";
@@ -170,15 +155,6 @@ export class ExternalModules{
         streamDeck.setTitle(name,context);
     }
 
-    hexToRgb(hex) {
-        var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        return result ? {
-          red: parseInt(result[1], 16)/256,
-          green: parseInt(result[2], 16)/256,
-          blue: parseInt(result[3], 16)/256
-        } : null;
-      }
-
     keyPressFxMaster(settings,context,device){
         if (game.user.isGM == false) return;
         const fxmaster = game.modules.get("fxmaster");
@@ -188,91 +164,63 @@ export class ExternalModules{
 
         if (type == 'weatherControls') {
             const effect = (settings.weatherEffect == undefined) ? 'leaves' : settings.weatherEffect;
-            let exists = false;
-            let newEffects = {};
-            let effects = canvas.scene.getFlag("fxmaster", "effects");
-            if (effects != undefined){
-                const weatherIds = Object.keys(effects);
-                for (let i=0; i<weatherIds.length; i++){
-                    const weather = effects[weatherIds[i]].type;
-                    if (weather === effect) {
-                        exists = true;
-                        continue;
-                    } 
-                    newEffects[weatherIds[i]] = effects[weatherIds[i]]; 
-                }
+
+            const options = {
+                density: (settings.densitySlider == undefined) ? 0.25 : settings.densitySlider,
+                speed: (settings.speedSlider == undefined) ? 1 : settings.speedSlider,
+                direction: (settings.directionSlider == undefined) ? 15 : settings.directionSlider,
+                scale: (settings.scaleSlider == undefined) ? 1 : settings.scaleSlider,
+                color: (settings.fxMasterWeatherColor == undefined) ? "#000000" : settings.fxMasterWeatherColor,
+                applyColor: (settings.fxWeatherEnColor == undefined) ? false : settings.fxWeatherEnColor
             }
 
-            const density = (settings.densitySlider == undefined) ? 50 : settings.densitySlider;
-            const speed = (settings.speedSlider == undefined) ? 50 : settings.speedSlider;
-            const direction = (settings.directionSlider == undefined) ? 50 : settings.directionSlider;
-            const scale = (settings.scaleSlider == undefined) ? 50 : settings.scaleSlider;
-            const color = (settings.fxMasterWeatherColor == undefined) ? "#000000" : settings.fxMasterWeatherColor;
-            const applyColor = (settings.fxWeatherEnColor == undefined) ? false : settings.fxWeatherEnColor;
-            
-            if (exists == false) {
-                newEffects[randomID()] = {
-                    type: effect,
-                    options: {
-                        density: density,
-                        speed: speed,
-                        scale: scale,
-                        tint: color,
-                        direction: direction,
-                        apply_tint: applyColor
-                    }
-                };
-            }
-            canvas.scene.unsetFlag("fxmaster", "effects").then(() => {
-                canvas.scene.setFlag("fxmaster", "effects", newEffects);
-            });
-            
-        }
-        else if (type == 'colorize') {
-            const color = (settings.fxMasterColorizeColor == undefined) ? '#000000' : settings.fxMasterColorizeColor;
-            const filters = canvas.scene.getFlag("fxmaster", "filters");
-            let newFilters = {};
-            if (filters != undefined){
-                const filterObjects = Object.keys(filters);
-                for (let i=0; i<filterObjects.length; i++){
-                    if (filterObjects[i] == 'core_color'){
-                        //continue;
-                    }
-                    newFilters[filterObjects[i]] = filters[filterObjects[i]]; 
-                }
-            }
-            newFilters['core_color'] = {
-                type : 'color',
-                options: this.hexToRgb(color)
-            };
-            
-            canvas.scene.unsetFlag("fxmaster", "filters").then(() => {
-                canvas.scene.setFlag("fxmaster", "filters", newFilters);
-            });
+            Hooks.call("fxmaster.switchWeather", {
+                name: `core_${effect}`,
+                type: effect,
+                options,
+              });
 
         }
         else if (type == 'filters') {
             const filter = (settings.fxMasterFilter == undefined) ? 'underwater' : settings.fxMasterFilter;
-            const filters = canvas.scene.getFlag("fxmaster", "filters");
-            let newFilters = {};
-            let exists = false;
-            if (filters != undefined){
-                const filterObjects = Object.keys(filters);
-                for (let i=0; i<filterObjects.length; i++){
-                    if (filterObjects[i] == 'core_'+filter){
-                        exists = true;
-                        continue;
-                    }
-                    newFilters[filterObjects[i]] = filters[filterObjects[i]]; 
+
+            let options = {color: {value:"#000000", apply:false}};
+            if (filter == 'lightning') {
+                options.period = settings.fxMasterFilterPeriod ? parseFloat(settings.fxMasterFilterPeriod) : 500;
+                options.duration = settings.fxMasterFilterDuration ? parseFloat(settings.fxMasterFilterDuration) : 300;
+                options.brightness = settings.fxMasterFilterBrightness ? parseFloat(settings.fxMasterFilterBrightness) : 1.3;
+            }
+            else if (filter == 'underwater') {
+                options.speed = settings.fxMasterFilterSpeed ? parseFloat(settings.fxMasterFilterSpeed) : 0.3;
+                options.scale = settings.fxMasterFilterScale ? parseFloat(settings.fxMasterFilterScale) : 4;
+            }
+            else if (filter == 'predator') {
+                options.noise = settings.fxMasterFilterNoise ? parseFloat(settings.fxMasterFilterNoise) : 4;
+                options.speed = settings.fxMasterFilterSpeed ? parseFloat(settings.fxMasterFilterSpeed)*0.1 : 0.03;
+            }
+            
+            else if (filter == 'bloom') {
+                options.blur = settings.fxMasterFilterBlur ? parseFloat(settings.fxMasterFilterBlur) : 1;
+                options.bloom = settings.fxMasterFilterBloom ? parseFloat(settings.fxMasterFilterBloom) : 0.1;
+                options.threshold = settings.fxMasterFilterThreshold ? parseFloat(settings.fxMasterFilterThreshold) : 0.5;
+            }
+            else if (filter == 'oldfilm') {
+                options.sepia = settings.fxMasterFilterSepia ? parseFloat(settings.fxMasterFilterSepia) : 0.3;
+                options.noise = settings.fxMasterFilterNoise ? parseFloat(settings.fxMasterFilterNoise) : 4;
+            }
+
+            if (filter == 'color') {
+                options.color = {
+                    apply: settings.fxMasterFilterTint ? settings.fxMasterFilterTint : false,
+                    value: settings.fxMasterFilterColor ? settings.fxMasterFilterColor : '#ffffff'
                 }
-                
+                options.saturation = settings.fxMasterFilterSaturation ? parseFloat(settings.fxMasterFilterSaturation) : 1;
+                options.contrast = settings.fxMasterFilterContrast ? parseFloat(settings.fxMasterFilterContrast) : 1;
+                options.brightness = settings.fxMasterFilterBrightness ? parseFloat(settings.fxMasterFilterBrightness) : 1;
+                options.Gamma = settings.fxMasterFilterGamma ? parseFloat(settings.fxMasterFilterGamma) : 1;
             }
-            if (exists == false) {
-                newFilters['core_'+filter] = {type : filter};
-            }
-            canvas.scene.unsetFlag("fxmaster", "filters").then(() => {
-                canvas.scene.setFlag("fxmaster", "filters", newFilters);
-            });
+
+            FXMASTER.filters.switch(`core_${filter}`, filter, options);
         }
         else if (type == 'clear'){
             canvas.scene.unsetFlag("fxmaster", "filters");
@@ -280,18 +228,6 @@ export class ExternalModules{
         }
     }
 
-    findWeatherEffect(effect){
-        const effects = canvas.scene.getFlag("fxmaster", "effects");
-        if (effects == undefined) return undefined;
-
-        const weatherIds = Object.keys(effects);
-        for (let i = 0; i < weatherIds.length; ++i) {
-            const weather = effects[weatherIds[i]].type;
-            if (weather === effect) return weatherIds[i];
-        }
-        return undefined;
-    }
-
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //GM Screen
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -317,7 +253,7 @@ export class ExternalModules{
     keyPressGMScreen(settings,context,device){
         if (this.getModuleEnable("gm-screen") == false) return;
         if (game.user.isGM == false) return;
-        window['gm-screen'].toggleGmScreenVisibility();
+        game.modules.get('gm-screen')?.api?.toggleGmScreenVisibility?.();
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1056,6 +992,42 @@ export class ExternalModules{
 
         this.updateAll();
     }
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Monks Active Tile Triggers
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    updateMonksActiveTiles(settings,context,device) {
+        const id = settings.monksActiveTilesId;
+        if (id == undefined || id == '') return;
+        let tile = canvas.background.placeables.find(t => t.id == id);
+        if (tile == undefined) return;
+        const tileData = tile.data.flags?.['monks-active-tiles'];
+        if (tileData == undefined) return;
+
+        let ring = 1;
+        let ringColor = '#000000';
+        let background = '#000000';
+        if (tileData.active) {
+            ring = 2;
+            ringColor = '#00ff00'
+        }
+        let src = tile.data.img;
+
+        streamDeck.setTitle('',context);
+        streamDeck.setIcon(context,device,src,{background:background,ring:ring,ringColor:ringColor});
+    }
+
+    keyPressMonksActiveTiles(settings,context,device) {
+        const mode = settings.monksActiveTilesMode ? settings.monksActiveTilesMode : 'toggle';
+        const id = settings.monksActiveTilesId;
+        if (id == undefined || id == '') return;
+        let tile = canvas.background.placeables.find(t => t.id == id);
+        if (tile == undefined) return;
+        const tileData = tile.data.flags?.['monks-active-tiles'];
+        if (tileData == undefined) return;
+
+        if (mode == 'toggle') tile.document.setFlag('monks-active-tiles','active',!tileData.active);
+    }
 }
 
 

src/misc.js

@@ -1,15 +1,36 @@
-import {sdVersion, msVersion, moduleName, getPermission, enableModule} from "../MaterialDeck.js";
+import {sdVersion, msVersion, moduleName, getPermission, enableModule, streamDeck} from "../MaterialDeck.js";
 import {macroControl,soundboard,playlistControl} from "../MaterialDeck.js";
 
+export function compareVersions(checkedVersion, requiredVersion) {
+    requiredVersion = requiredVersion.split(".");
+    checkedVersion = checkedVersion.split(".");
+    for (let i=0; i<3; i++) {
+        requiredVersion[i] = isNaN(parseInt(requiredVersion[i])) ? 0 : parseInt(requiredVersion[i]);
+        checkedVersion[i] = isNaN(parseInt(checkedVersion[i])) ? 0 : parseInt(checkedVersion[i]);
+    }
+
+    if (checkedVersion[0] > requiredVersion[0]) return false;
+    if (checkedVersion[0] < requiredVersion[0]) return true;
+    if (checkedVersion[1] > requiredVersion[1]) return false;
+    if (checkedVersion[1] < requiredVersion[1]) return true;
+    if (checkedVersion[2] > requiredVersion[2]) return false;
+    return true;
+}
+
 export function compatibleCore(compatibleVersion){
-    let coreVersion = game.data.version;
+    let coreVersion = game.version == undefined ? game.data.version : `0.${game.version}`;
+    return compareVersions(compatibleVersion, coreVersion);
+    /*
     coreVersion = coreVersion.split(".");
     compatibleVersion = compatibleVersion.split(".");
     if (compatibleVersion[0] > coreVersion[0]) return false;
+    if (compatibleVersion[0] < coreVersion[0]) return true;
     if (compatibleVersion[1] > coreVersion[1]) return false;
+    if (compatibleVersion[1] < coreVersion[1]) return true;
     if (compatibleVersion[2] > coreVersion[2]) return false;
     return true;
-}
+    */
+  }
 
 export class playlistConfigForm extends FormApplication {
     constructor(data, options) {
@@ -1163,7 +1184,7 @@ export class downloadUtility extends FormApplication {
         let parent = this;
         let url;
         if (reqType == 'SD') url = 'https://raw.githubusercontent.com/CDeenen/MaterialDeck_SD/master/Plugin/com.cdeenen.materialdeck.sdPlugin/manifest.json';
-        else if (reqType == 'MS') url = 'https://raw.githubusercontent.com/CDeenen/MaterialServer/master/src/Windows/package.json';
+        else if (reqType == 'MS') url = 'https://raw.githubusercontent.com/CDeenen/MaterialServer/master/package.json';
         const elementId = reqType == 'SD' ? 'masterSdVersion' : 'masterMsVersion';
 
         var request = new XMLHttpRequest();
@@ -1185,4 +1206,93 @@ export class downloadUtility extends FormApplication {
             document.getElementById(elementId).innerHTML = 'Error';
         }
     }     
+}
+
+export class deviceConfig extends FormApplication {
+    constructor(data, options) {
+        super(data, options);
+
+        this.devices = [];
+    }
+
+    /**
+     * Default Options for this FormApplication
+     */
+    static get defaultOptions() {
+        return mergeObject(super.defaultOptions, {
+            id: "MD_DeviceConfig",
+            title: "Material Deck: " + game.i18n.localize("MaterialDeck.DeviceConfig.Title"),
+            template: "./modules/MaterialDeck/templates/deviceConfig.html",
+            width: 500,
+            height: "auto"
+        });
+    }
+
+    /**
+     * Provide data to the template
+     */
+    getData() {
+        this.devices = [];
+        let dConfig = game.settings.get(moduleName, 'devices');
+        if (Object.prototype.toString.call(game.settings.get('MaterialDeck', 'devices')) === "[object String]") {
+            dConfig = {};
+            game.settings.set(moduleName, 'devices', dConfig);
+        }
+  
+        for (let d of streamDeck.buttonContext) {
+            if (d == undefined) continue;
+            let type;
+            if (d.type == 0) type = 'Stream Deck';
+            else if (d.type == 1) type = 'Stream Deck Mini';
+            else if (d.type == 2) type = 'Stream Deck XL';
+            else if (d.type == 3) type = 'Stream Deck Mobile';
+            else if (d.type == 4) type = 'Corsair G Keys';
+
+            const name = d.name;
+            const id = d.device;
+            let enable;
+            if (dConfig?.[id] == undefined) enable = true;
+            else enable = dConfig?.[id].enable;
+
+            const device = {
+                id,
+                name,
+                type,
+                en: enable
+            }
+            this.devices.push(device);
+        }
+        
+        
+        return {
+            devices: this.devices
+        } 
+    }
+
+    /**
+     * Update on form submit
+     * @param {*} event 
+     * @param {*} formData 
+     */
+    async _updateObject(event, formData) {
+   
+    }
+
+    activateListeners(html) {
+        super.activateListeners(html);
+
+        html.find("input[name='enable']").on('change', (event) => {
+            const id = event.currentTarget.id;
+            for (let d of this.devices) {
+                if (d.id == id) {
+                    let dConfig = game.settings.get(moduleName, 'devices');
+                    delete dConfig[id];
+                    dConfig[id] = {enable: event.currentTarget.checked}
+                    game.settings.set(moduleName, 'devices', dConfig);
+                }
+            }
+        })
+    }
+
+    
 }

src/othercontrols.js

@@ -1,5 +1,5 @@
 import * as MODULE from "../MaterialDeck.js";
-import {streamDeck} from "../MaterialDeck.js";
+import {streamDeck, gamingSystem} from "../MaterialDeck.js";
 import {compatibleCore} from "./misc.js";
 
 export class OtherControls{
@@ -7,6 +7,8 @@ export class OtherControls{
         this.active = false;
         this.rollData = {};
         this.rollOption = 'dialog';
+        this.controlsOffset = 0;
+        this.toolsOffset = 0;
     }
 
     setRollOption(option) {
@@ -225,7 +227,9 @@ export class OtherControls{
         const control = settings.control ? settings.control : 'dispControls';
         const tool = settings.tool ?  settings.tool : 'open';
         let background = settings.background ? settings.background : '#000000';
-        let ringColor = '#000000'
+        let ringColor = '#000000';
+        const ringOffColor = settings.offRing ? settings.offRing : '#000000';
+        const ringOnColor = settings.onRing ? settings.onRing : '#00FF00';
         let txt = "";
         let src = "";
         const activeControl = ui.controls.activeControl;
@@ -235,6 +239,7 @@ export class OtherControls{
             let controlNr = parseInt(settings.controlNr);
             if (isNaN(controlNr)) controlNr = 1;
             controlNr--;
+            controlNr += this.controlsOffset;
 
             const selectedControl = ui.controls.controls[controlNr];
             
@@ -255,6 +260,7 @@ export class OtherControls{
             let controlNr = parseInt(settings.controlNr);
             if (isNaN(controlNr)) controlNr = 1;
             controlNr--;
+            controlNr += this.toolsOffset;
 
             const selectedControl = ui.controls.controls.find(c => c.name == ui.controls.activeControl);
             if (selectedControl != undefined){
@@ -275,6 +281,18 @@ export class OtherControls{
                 }  
             }
         }
+        else if (control == 'controlsOffset') {
+            const display = settings.controlsOffsetDisplay ? settings.controlsOffsetDisplay : false;
+            const offsetType = settings.controlsOffsetType ? settings.controlsOffsetType : 'absoluteOffset';
+            if (display) txt = `${this.controlsOffset}`;
+            if (offsetType == 'absoluteOffset') ringColor = (this.controlsOffset == settings.controlsOffset) ? ringOnColor : ringOffColor;
+        }
+        else if (control == 'toolsOffset') {
+            const display = settings.controlsOffsetDisplay ? settings.controlsOffsetDisplay : false;
+            const offsetType = settings.controlsOffsetType ? settings.controlsOffsetType : 'absoluteOffset';
+            if (display) txt = `${this.toolsOffset}`;
+            if (offsetType == 'absoluteOffset') ringColor = (this.toolsOffset == settings.controlsOffset) ? ringOnColor : ringOffColor;
+        }
         else {  // specific control/tool
             const selectedControl = ui.controls.controls.find(c => c.name == control);
             if (selectedControl != undefined){
@@ -370,6 +388,16 @@ export class OtherControls{
                 }  
             }
         }
+        else if (control == 'controlsOffset') {
+            const offsetType = settings.controlsOffsetType ? settings.controlsOffsetType : 'absoluteOffset';
+            if (offsetType == 'absoluteOffset') this.controlsOffset = parseInt(settings.controlsOffset);
+            else if (offsetType == 'relativeOffset') this.controlsOffset += parseInt(settings.controlsOffset);
+        }
+        else if (control == 'toolsOffset') {
+            const offsetType = settings.controlsOffsetType ? settings.controlsOffsetType : 'absoluteOffset';
+            if (offsetType == 'absoluteOffset') this.toolsOffset = parseInt(settings.controlsOffset);
+            else if (offsetType == 'relativeOffset') this.toolsOffset += parseInt(settings.controlsOffset);
+        }
         else {  //select control
             const selectedControl = ui.controls.controls.find(c => c.name == control);
             if (selectedControl != undefined){
@@ -502,7 +530,7 @@ export class OtherControls{
         if (tokenControlled) r = new Roll(settings.rollDiceFormula,actor.getRollData());
         else r = new Roll(settings.rollDiceFormula);
 
-        r.evaluate();
+        r.evaluate({async:false});
         
         if (rollFunction == 'public') {
             r.toMessage(r,{rollMode:"roll"})
@@ -588,6 +616,7 @@ export class OtherControls{
         else if (nr == 'items') name = game.i18n.localize("SIDEBAR.TabItems");
         else if (nr == 'journal') name = game.i18n.localize("SIDEBAR.TabJournal");
         else if (nr == 'tables') name = game.i18n.localize("SIDEBAR.TabTables");
+        else if (nr == 'cards') name = game.i18n.localize("SIDEBAR.TabCards");
         else if (nr == 'playlists') name = game.i18n.localize("SIDEBAR.TabPlaylists");
         else if (nr == 'compendium') name = game.i18n.localize("SIDEBAR.TabCompendium");
         else if (nr == 'settings') name = game.i18n.localize("SIDEBAR.TabSettings");
@@ -600,10 +629,11 @@ export class OtherControls{
         if (nr == 'chat') icon = window.CONFIG.ChatMessage.sidebarIcon;
         else if (nr == 'combat') icon = window.CONFIG.Combat.sidebarIcon;
         else if (nr == 'scenes') icon = window.CONFIG.Scene.sidebarIcon;
-        else if (nr == 'actors') icon = window.CONFIG.Actor.sidebarIcon;
+        else if (nr == 'actors') icon = "fas fa-users";
         else if (nr == 'items') icon = window.CONFIG.Item.sidebarIcon;
         else if (nr == 'journal') icon = window.CONFIG.JournalEntry.sidebarIcon;
         else if (nr == 'tables') icon = window.CONFIG.RollTable.sidebarIcon;
+        else if (nr == 'cards') icon = "fas fa-id-badge";
         else if (nr == 'playlists') icon = window.CONFIG.Playlist.sidebarIcon;
         else if (nr == 'compendium') icon = "fas fa-atlas";
         else if (nr == 'settings') icon = "fas fa-cogs";
@@ -657,7 +687,7 @@ export class OtherControls{
 
     updateCompendiumBrowser(settings,context,device,options={}){
         let rendered = options.renderCompendiumBrowser;
-        if (rendered == undefined && game.system.id == "pf2e") rendered = (document.getElementById("app-1") != null);
+        if (rendered == undefined && gamingSystem == "pf2e") rendered = (document.getElementById("app-1") != null);
         else if (rendered == undefined) rendered = (document.getElementById("compendium-popout") != null);
         const background = settings.background ? settings.background : '#000000';
         const ringOffColor = settings.offRing ? settings.offRing : '#000000';
@@ -671,13 +701,13 @@ export class OtherControls{
 
     keyPressCompendiumBrowser(settings){
         let element = null;
-        if (game.system.id == "pf2e") element = document.getElementById("app-1")
+        if (gamingSystem == "pf2e") element = document.getElementById("app-1")
         else element = document.getElementById("compendium-popout");
         const rendered = (element != null);
 
         if (rendered) 
             element.getElementsByClassName("close")[0].click();
-        else if (game.system.id == "pf2e")
+        else if (gamingSystem == "pf2e")
             document.getElementsByClassName("compendium-browser-btn")[0].click()
         else
             ui.compendium.renderPopout();

src/playlist.js

@@ -229,6 +229,12 @@ export class PlaylistControl{
                     }
                 }
             }
+            else if (playlistType == 'playNext') {
+                this.getPlaylist(playlistNr).playNext();
+            }
+            else if (playlistType == 'playPrev') {
+                this.getPlaylist(playlistNr).playNext(null,{direction:-1});
+            }
             else if (playlistType == 'offset'){
                 if (playlistMode == 'playlist') {
                     this.playlistOffset = parseInt(settings.offset);

src/settings.js

@@ -1,5 +1,5 @@
 import * as MODULE from "../MaterialDeck.js";
-import { playlistConfigForm, macroConfigForm, soundboardConfigForm, downloadUtility } from "./misc.js";
+import { playlistConfigForm, macroConfigForm, soundboardConfigForm, downloadUtility, deviceConfig } from "./misc.js";
 
 let userPermissions = {};
 const defaultEnable = [true,true,true,true];
@@ -79,6 +79,19 @@ export const registerSettings = async function() {
         onChange: x => window.location.reload()
     });
 
+    /**
+     * System override
+     */
+     game.settings.register(MODULE.moduleName,'systemOverride', {
+        name: "MaterialDeck.Sett.SystemOverride",
+        hint: "MaterialDeck.Sett.SystemOverrideHint",
+        scope: "client",
+        config: true,
+        default: "",
+        type: String,
+        onChange: x => window.location.reload()
+    });
+
     /**
      * Sets the ip address of the server
      */
@@ -133,6 +146,27 @@ export const registerSettings = async function() {
         restricted: false
     });
 
+    game.settings.registerMenu(MODULE.moduleName, 'downloadUtility',{
+        name: "MaterialDeck.DownloadUtility.Title",
+        label: "MaterialDeck.DownloadUtility.Title",
+        type: downloadUtility,
+        restricted: false
+    });
+
+    game.settings.registerMenu(MODULE.moduleName, 'deviceConfig',{
+        name: "MaterialDeck.DeviceConfig.Title",
+        label: "MaterialDeck.DeviceConfig.Title",
+        type: deviceConfig,
+        restricted: false
+    });
+
+    game.settings.register(MODULE.moduleName, 'devices', {
+        name: "devices",
+        scope: "client",
+        type: Object,
+        config: false
+    });
+
     game.settings.registerMenu(MODULE.moduleName, 'permissionConfig',{
         name: "MaterialDeck.Sett.Permission",
         label: "MaterialDeck.Sett.Permission",
@@ -147,13 +181,6 @@ export const registerSettings = async function() {
         config: false
     });
 
-    game.settings.registerMenu(MODULE.moduleName, 'downloadUtility',{
-        name: "MaterialDeck.DownloadUtility.Title",
-        label: "MaterialDeck.DownloadUtility.Title",
-        type: downloadUtility,
-        restricted: false
-    });
-
     /**
      * Playlist soundboard
      */

src/streamDeck.js

@@ -34,7 +34,26 @@ export class StreamDeck{
        
     }
 
-    setContext(device,size,iteration,action,context,coordinates = {column:0,row:0},settings){
+    //getButtonContext
+
+    newDevice(iteration,device) {
+        if (this.buttonContext[iteration] == undefined) {
+            const deckSize = device.size.columns*device.size.rows;
+            let buttons = [];
+            for (let i=0; i<deckSize; i++){
+                buttons[i] = undefined;
+            }
+            this.buttonContext[iteration] = {
+                device: device.id,
+                name: device.name,
+                type: device.type,
+                size: size,
+                buttons: buttons
+            }
+        }
+    }
+
+    setContext(device,size,iteration,action,context,coordinates = {column:0,row:0},settings, name, type){
         if (device == undefined) return;
         if (this.buttonContext[iteration] == undefined) {
             const deckSize = size.columns*size.rows;
@@ -44,6 +63,8 @@ export class StreamDeck{
             }
             this.buttonContext[iteration] = {
                 device: device,
+                name: name,
+                type: type,
                 size: size,
                 buttons: buttons
             }
@@ -61,7 +82,7 @@ export class StreamDeck{
 
     clearContext(device,action,coordinates = {column:0,row:0}){
         for (let d of this.buttonContext) {
-            if (d.device == device) {
+            if (d?.device == device) {
                 const num = coordinates.column + coordinates.row*d.size.columns;
                 d.buttons[num] = undefined;
                 return;
@@ -241,7 +262,7 @@ export class StreamDeck{
         
         //if (src != 'modules/MaterialDeck/img/black.png')
         for (let d of this.buttonContext) {
-            if (d.device == device) {
+            if (d?.device == device) {
                 for (let i=0; i<d.buttons.length; i++){
                     if (clock != false) break;
                     if (d.buttons[i] == undefined) continue;
@@ -357,15 +378,13 @@ export class StreamDeck{
             if(isNaN(parseInt(background[i],16)))
                 BGvalid = false;
         if (BGvalid == false) background = '#000000';
-
-        let canvas;
-        if (canvas == null || canvas == undefined){
-            canvas = document.createElement('canvas');
-            canvas.width="144";
-            canvas.height="144";
-            canvas.style="background-color:transparent;visibility:hidden";
-            document.getElementById('sdCanvasBox').appendChild(canvas); // adds the canvas to #someBox
-        }
+        
+        let canvas = document.createElement('canvas');
+        canvas.width="144";
+        canvas.height="144";
+        canvas.style="background-color:transparent;visibility:hidden;display:none";
+        document.getElementById('sdCanvasBox').appendChild(canvas); // adds the canvas to #someBox
+      
         this.counter++;
         if (this.counter > 31) this.counter = 0;
     
@@ -413,6 +432,7 @@ export class StreamDeck{
 
         if (format != 'jpg' && format != 'jpeg' && format != 'png' && format != 'PNG' && format != 'webm' && format != 'webp' && format != 'gif' && format != 'svg') url = "modules/MaterialDeck/img/transparant.png";
         //if (url == "") url = "modules/MaterialDeck/img/transparant.png"
+        
         let resImageURL = url;
         let img = new Image();
         img.setAttribute('crossorigin', 'anonymous');
@@ -583,4 +603,4 @@ export class StreamDeck{
         this.setIcon(context,device,url,{background:background});
         this.setTitle(txt,context);
     }
-}
+}

src/systems/demonlord.js

@@ -134,4 +134,15 @@ export class demonlord{
     rollItem(item) {
         return item.roll()
     }
+
+    /**
+     * Ring Colors
+     */
+    getSkillRingColor(token, skill) {
+        return;
+    }
+
+    getSaveRingColor(token, save) {
+        return;        
+    }
 }

src/systems/dnd35e.js

@@ -199,4 +199,15 @@ export class dnd35e{
     rollItem(item) {
         return item.roll()
     }
+
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token, skill) {
+        return;
+    }
+
+    getSaveRingColor(token, save) {
+        return;        
+    }
 }

src/systems/dnd5e.js

@@ -1,5 +1,12 @@
 import {compatibleCore} from "../misc.js";
 
+const proficiencyColors = {
+    0: "#000000",
+    0.5: "#804A00",
+    1: "#C0C0C0",
+    2: "#FFD700"
+}
+
 export class dnd5e{
     constructor(){
         
@@ -202,4 +209,19 @@ export class dnd5e{
     rollItem(item) {
         return item.roll()
     }
+
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token, skill) {
+        const profLevel = token.actor.data.data?.skills[skill]?.proficient;
+        if (profLevel == undefined) return;
+        return proficiencyColors?.[profLevel];
+    }
+
+    getSaveRingColor(token, save) {
+        const profLevel = token.actor.data.data?.abilities[save]?.proficient;        
+        if (profLevel == undefined) return;
+        return proficiencyColors?.[profLevel];
+    }
 }

src/systems/forbidden-lands.js

@@ -0,0 +1,249 @@
+import {compatibleCore} from "../misc.js";
+
+export class forbiddenlands{
+    constructor(){
+        
+    }
+
+    getHP(token) {
+        const hp = token.actor.data.data.attribute.strength;
+        return {
+            value: hp.value,
+            max: hp.max
+        }
+    }
+
+
+    getAgility(token) {
+        const agility = token.actor.data.data.attribute.agility;
+        return {
+            value: agility.value,
+            max: agility.max
+        }
+    }
+
+
+    getWits(token) {
+        const wits = token.actor.data.data.attribute.wits;
+        return {
+            value: wits.value,
+            max: wits.max
+        }
+    }
+
+    getEmpathy(token) {
+        const empathy = token.actor.data.data.attribute.empathy;
+        return {
+            value: empathy.value,
+            max: empathy.max
+        }
+    }
+
+    getWillPower(token) {
+        const wp = token.actor.data.data.bio.willpower;
+        return {
+            value: wp.value,
+            max: wp.max
+        }
+    }
+
+    getTempHP(token) {
+        return 0;
+        const hp = token.actor.data.data.attributes.hp;
+        return {
+            value: (hp.temp == null) ? 0 : hp.temp,
+            max: (hp.tempmax == null) ? 0 : hp.tempmax
+        }
+    }
+
+    getAC(token) {
+
+        const totalArmor = token.actor.itemTypes.armor.reduce((sum, armor) => {
+			if (armor.itemProperties.part === "shield") return sum;
+			const value = armor.itemProperties.bonus.value;
+			return (sum += value);
+		}, 0);
+        return totalArmor;
+    }
+
+    getShieldHP(token) {
+        return;
+    }
+
+    getSpeed(token) {
+        return 1;
+    }
+
+    getInitiative(token) {
+        return 0;
+        let initiative = token.actor.data.data.attributes.init.total;
+        return (initiative >= 0) ? `+${initiative}` : initiative;
+    }
+
+    toggleInitiative(token) {
+        return;
+    }
+
+    getPassivePerception(token) {
+        return 0;
+        return token.actor.data.data.skills.prc.passive;
+    }
+
+    getPassiveInvestigation(token) {
+        return;
+        return token.actor.data.data.skills.inv.passive;
+    }
+
+    getAbility(token, ability) {
+        if (ability == undefined) ability = 'strength';
+        return token.actor.data.data.attribute?.[ability].value;
+    } 
+
+    getAbilityModifier(token, ability) {
+        return;
+    }
+
+    getAbilitySave(token, ability) {
+        return this.getAbility(token, ability);
+    }
+
+    getSkill(token, skill) {
+        if (skill == undefined) skill = 'might';
+        let skillComp = token.actor.sheet.getSkill(skill);
+        const val = skillComp.skill.value + skillComp.attribute.value;
+        return game.i18n.localize(skillComp.skill.label)+`-${val}`;
+    }
+
+    getProficiency(token) {
+        return;
+        const val = token.actor.data.data.attributes.prof;
+        return (val >= 0) ? `+${val}` : val;
+    }
+
+    getConditionIcon(condition) {
+        if (condition == undefined) condition = 'removeAll';
+        if (condition == 'removeAll') return window.CONFIG.controlIcons.effects;
+        else return CONFIG.statusEffects.find(e => e.id === condition).icon;
+    }
+
+    getConditionActive(token,condition) {
+        if (condition == undefined) condition = 'removeAll';
+        return token.actor.effects.find(e => e.isTemporary === condition) != undefined;
+    }
+
+    async toggleCondition(token,condition) {
+        if (condition == undefined) condition = 'removeAll';
+        if (condition == 'removeAll'){
+            for( let effect of token.actor.effects)
+                await effect.delete();
+        }
+        else {
+            const effect = CONFIG.statusEffects.find(e => e.id === condition);
+            await token.toggleEffect(effect);
+        }
+        return true;
+    }
+
+    /**
+     * Roll
+     */
+     roll(token,roll,options,ability,skill,save) {
+        if (roll == undefined) roll = 'ability';
+        if (ability == undefined) ability = 'strength';
+        if (skill == undefined) skill = 'might';
+        if (save == undefined) save = 'strength';
+
+        if (roll == 'ability') token.actor.sheet.rollAttribute(ability);
+        else if (roll == 'save') token.actor.sheet.rollAttribute(save);
+        else if (roll == 'skill') token.actor.sheet.rollSkill(skill);
+        else if (roll == 'rollFood') token.actor.sheet.rollConsumable('food');
+        else if (roll == 'rollWater') token.actor.sheet.rollConsumable('water');
+        else if (roll == 'rollArrows') token.actor.sheet.rollConsumable('arrows');
+        else if (roll == 'rollTorches') token.actor.sheet.rollConsumable('torches');
+        else if (roll == 'rollArmor') token.actor.sheet.rollArmor();
+        else if (roll == 'monsterAttack') token.actor.sheet.rollAttack();
+        //else if (roll == 'initiative') token.actor.rollInitiative(options);
+    }
+
+    /**
+     * Items
+     */
+    getItems(token,itemType) {
+        if (itemType == undefined) itemType = 'any';
+        const allItems = token.actor.items;
+        if (itemType == 'any') return allItems.filter(i => i.type == 'weapon' || i.type == 'armor' || i.type == 'gear' || i.type == 'rawMaterial');
+        else if (token.actor.type == 'monster' && itemType == 'weapon')
+        {
+            return allItems.filter(i => i.type == 'monsterAttack');
+        }
+        return allItems.filter(i => i.type == itemType);
+    }
+
+    getItemUses(item) {
+        if (item.type == 'monsterAttack') return;
+        if (item.type == 'rawMaterial') return {available: item.data.data.quantity};
+        return {available: item.data.data.bonus.value,
+            maximum: item.data.data.bonus.max};
+    }
+
+    /**
+     * Features
+     */
+    getFeatures(token,featureType) {
+        if (featureType == undefined) featureType = 'any';
+        const allItems = token.actor.items;
+        if (featureType == 'any') return allItems.filter(i => i.type == 'talent')
+        else return allItems.filter(i => i.type == featureType)
+    }
+
+    getFeatureUses(item) {
+        if (item.data.type == 'class') return {available: item.data.data.levels};
+        else return {
+            available: item.data.data.uses.value, 
+            maximum: item.data.data.uses.max
+        };
+    }
+
+    /**
+     * Spells
+     */
+     getSpells(token,level) {
+        if (level == undefined) level = 'any';
+        const allItems = token.actor.items;
+        if (level == 'any') return allItems.filter(i => i.type == 'spell')
+        else return allItems.filter(i => i.type == 'spell' && i.data.data.level == level)
+    }
+
+    getSpellUses(token,level,item) {
+        if (level == undefined) level = 'any';
+        if (item.data.data.level == 0) return;
+        return {
+            available: token.actor.data.data.spells?.[`spell${level}`].value,
+            maximum: token.actor.data.data.spells?.[`spell${level}`].max
+        }
+    }
+
+    rollItem(item) {
+        const sheet = item.actor.sheet;
+        if (item.type === "armor")
+        return sheet.rollSpecificArmor(item.id);
+        else if (item.type === "weapon")
+        return sheet.rollGear(item.id);
+        else if (item.type === "spell")
+        return sheet.rollSpell(item.id);
+        else if (item.type === "monsterAttack")
+        sheet.rollSpecificAttack(item.id);
+        return item.sendToChat();
+    }
+
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token, skill) {
+        return;
+    }
+
+    getSaveRingColor(token, save) {
+        return;        
+    }
+}

src/systems/pf2e.js

@@ -1,38 +1,58 @@
 import {compatibleCore} from "../misc.js";
 import {otherControls} from "../../MaterialDeck.js";
 
+const limitedSheets = ['loot', 'vehicle'];
+const proficiencyColors = 
+{
+    untrained: "#424242",
+    trained: "#171F69",
+    expert: "#3C005E",
+    master: "#664400",
+    legendary: "#5E0000"
+};
+
 export class pf2e{
+
     constructor(){
         
     }
 
+    tokenSpellData = new Map();
+
     getHP(token) {
-        const hp = token.actor.data.data.attributes.hp;
+        const hp = token.actor.attributes?.hp;
         return {
-            value: hp.value,
-            max: hp.max
+            value: (hp?.value == null) ? 0 : hp.value,
+            max: (hp?.max == null) ? 0 : hp.max
         }
     }
 
     getTempHP(token) {
-        const hp = token.actor.data.data.attributes.hp;
+        const hp = token.actor.attributes?.hp;
         return {
-            value: (hp.temp == null) ? 0 : hp.temp,
-            max: (hp.tempmax == null) ? 0 : hp.tempmax
+            value: (hp?.temp == null) ? 0 : hp.temp,
+            max: (hp?.tempmax == null) ? 0 : hp.tempmax
         }
     }
 
     getAC(token) {
-        return token.actor.data.data.attributes.ac.value;
+        const ac = token.actor.attributes?.ac;
+        return (ac?.value == null) ? 10 : ac?.value;
     }
 
     getShieldHP(token) {
-        return token.actor.data.data.attributes.shield.value;
+        const shieldhp = token.actor.attributes.shield
+        return (shieldhp?.value == null) ? 0 : shieldhp?.value;
     }
 
     getSpeed(token) {
-        let speed = `${token.actor.data.data.attributes.speed.total}'`;
-        const otherSpeeds = token.actor.data.data.attributes.speed.otherSpeeds;
+        if (this.isLimitedSheet(token.actor) || token.actor.type == 'hazard') {
+            if (token.actor.type == 'vehicle') {
+                return token.actor.data.data.details.speed;
+            } else return '';
+        }
+        let speed = `${token.actor.attributes.speed?.total}'`;
+        const otherSpeeds = token.actor.attributes.speed?.otherSpeeds;
         if (otherSpeeds.length > 0)
             for (let os of otherSpeeds) 
                  speed += `\n${os.type} ${os.total}'`;    
@@ -40,14 +60,20 @@ export class pf2e{
     }
 
     getInitiative(token) {
-        let initiativeModifier = token.actor.data.data.attributes?.initiative.totalModifier;
-        let initiativeAbility = token.actor.data.data.attributes?.initiative.ability;
+        if (this.isLimitedSheet(token.actor) || token.actor.type == 'familiar') return '';
+        if (token.actor.type == 'hazard') {
+            let initiative = token.actor.attributes?.stealth?.value;
+            return `Init: Stealth (${initiative})`; 
+        }
+        let initiative = token.actor.attributes.initiative;
+        let initiativeModifier = initiative?.totalModifier;
+        let initiativeLabel = initiative?.label.replace('iative',''); //Initiative is too long for the button
         if (initiativeModifier > 0) {
             initiativeModifier = `+${initiativeModifier}`;
         } else {
             initiativeModifier = this.getPerception(token); //NPCs won't have a valid Initiative value, so default to use Perception
         } 
-        return (initiativeAbility != '') ? `(${initiativeAbility}): ${initiativeModifier}` : `(perception): ${initiativeModifier}`;
+        return `${initiativeLabel} (${initiativeModifier})`;
     }
 
     toggleInitiative(token) {
@@ -63,46 +89,73 @@ export class pf2e{
     }
 
     getPerception(token) {
-        let perception = token.actor.data.data.attributes?.perception.totalModifier;
+        if (this.isLimitedSheet(token.actor) || token.actor.type == 'hazard') return '';
+        let perception = token.actor.attributes.perception?.totalModifier;
         return (perception >= 0) ? `+${perception}` : perception;
     }
 
     getAbility(token, ability) {
+        if (this.isLimitedSheet(token.actor) || token.actor.type == 'familiar') return '';
         if (ability == undefined) ability = 'str';
-        return token.actor.data.data.abilities?.[ability].value;
+        return token.actor.abilities?.[ability]?.value;
     } 
 
     getAbilityModifier(token, ability) {
+        if (this.isLimitedSheet(token.actor) || token.actor.type == 'hazard' || token.actor.type == 'familiar') return '';
         if (ability == undefined) ability = 'str';
-        let val = token.actor.data.data.abilities?.[ability].mod;
+        let val = token.actor.abilities?.[ability]?.mod;
         return (val >= 0) ? `+${val}` : val;
     }
 
     getAbilitySave(token, ability) {
-        if (ability == undefined) ability = 'fortitude';
-        else if (ability == 'fort') ability = 'fortitude';
-        else if (ability == 'ref') ability = 'reflex';
-        else if (ability == 'will') ability = 'will';
-        let val = token.actor.data.data.saves?.[ability].value;
+        ability = this.fixSave(ability);
+        const save = this.findSave(token, ability);
+        if (save == undefined) return '';
+        let val = save?.value;
         return (val >= 0) ? `+${val}` : val;
     }
 
+    findSave(token, ability) {
+        if (this.isLimitedSheet(token.actor)) return;
+        return token.actor.data.data.saves?.[ability];
+    }
+
+    fixSave(ability) {
+        if (ability == undefined) return 'fortitude';
+        else if (ability == 'fort') return 'fortitude';
+        else if (ability == 'ref') return 'reflex';
+        else if (ability == 'will') return 'will';
+    }
+
     getSkill(token, skill) {
+        const tokenSkill = this.findSkill(token, skill);
+        if (tokenSkill == undefined) return '';
+        
+        if (skill.startsWith('lor')) {
+            return `${tokenSkill.name}: +${tokenSkill.totalModifier}`;
+        }
+
+        const val = tokenSkill.totalModifier;
+        return (val >= 0) ? `+${val}` : val;
+    }
+
+    findSkill(token, skill) {
+        if (this.isLimitedSheet(token.actor)) return;
         if (skill == undefined) skill = 'acr';
         if (skill.startsWith('lor')) {
             const index = parseInt(skill.split('_')[1])-1;
             const loreSkills = this.getLoreSkills(token);
             if (loreSkills.length > index) {
-                return `${loreSkills[index].name}: +${loreSkills[index].totalModifier}`;
+                return loreSkills[index];
             } else {
-                return '';
+                return;
             }
         }
-        const val = token.actor.data.data.skills?.[skill].totalModifier;
-        return (val >= 0) ? `+${val}` : val;
+        return token.actor.data.data.skills?.[skill];
     }
 
     getLoreSkills(token) {
+        if (this.isLimitedSheet(token.actor)) return [];
         const skills = token.actor.data.data.skills;
         return Object.keys(skills).map(key => skills[key]).filter(s => s.lore == true);
     }
@@ -142,9 +195,7 @@ export class pf2e{
             const effect = this.getConditionValue(token,condition);
             if (effect == undefined) {
                 if (delta > 0) {
-                    const Condition = this.getConditionName(condition);
-                    const newCondition = game.pf2e.ConditionManager.getCondition(Condition);
-                    await game.pf2e.ConditionManager.addConditionToToken(newCondition, token);
+                    await game.pf2e.ConditionManager.addConditionToToken(condition, token);
                 }
             } else {
                 try {
@@ -166,19 +217,16 @@ export class pf2e{
     async toggleCondition(token,condition) {
         if (condition == undefined) condition = 'removeAll';
         if (condition == 'removeAll'){
-            for( let effect of token.actor.items.filter(i => i.type == 'condition'))
-                await effect.delete();
+            for( let existing of token.actor.items.filter(i => i.type == 'condition'))
+                await game.pf2e.ConditionManager.removeConditionFromToken(existing.data._id, token);
         }
         else {
             const effect = this.getCondition(token,condition);
             if (effect == undefined) {
-                const Condition = this.getConditionName(condition);
-                const newCondition = game.pf2e.ConditionManager.getCondition(Condition);
-                newCondition.data.sources.hud = !0,
-                await game.pf2e.ConditionManager.addConditionToToken(newCondition, token);
+                await game.pf2e.ConditionManager.addConditionToToken(condition, token);
             }
             else {
-                effect.delete();
+                await game.pf2e.ConditionManager.removeConditionFromToken(effect.data._id, token);
             }
         }
         return true;
@@ -188,19 +236,28 @@ export class pf2e{
      * Roll
      */
      roll(token,roll,options,ability,skill,save) {
+        if (this.isLimitedSheet(token.actor)) return;
+        options.skipDialog = true;
         if (roll == undefined) roll = 'skill';
         if (ability == undefined) ability = 'str';
         if (skill == undefined) skill = 'acr';
         if (save == undefined) save = 'fort';
-        if (roll == 'perception') token.actor.data.data.attributes.perception.roll(options);
-        if (roll == 'initiative') token.actor.rollInitiative(options);
-        if (roll == 'ability') token.actor.rollAbility(options, ability);
+        if (roll == 'perception') {
+            this.checkRoll(`Perception Check`, token.actor.perception, 'perception-check', token.actor);
+        }
+        if (roll == 'initiative') {
+            token.actor.rollInitiative({createCombatants:true, initiativeOptions: {skipDialog: true}});
+        }
+            
+        if (roll == 'ability') return; //Ability Checks are not supported in pf2e
         else if (roll == 'save') {
             let ability = save;
             if (ability == 'fort') ability = 'fortitude';
             else if (ability == 'ref') ability = 'reflex';
             else if (ability == 'will') ability = 'will';
-            token.actor.rollSave(options, ability);
+            if (token.actor.type == 'hazard' && ability == 'will') return; //Hazards don't have Will saves
+            let abilityName = ability.charAt(0).toUpperCase() + ability.slice(1);
+            this.checkRoll(`${abilityName} Saving Throw`, token.actor.saves?.[ability], 'saving-throw', token.actor);
         }
         else if (roll == 'skill') {
             if (skill.startsWith('lor')) {
@@ -212,15 +269,23 @@ export class pf2e{
                 } else {
                     return;
                 }
-            }  
-            token.actor.data.data.skills?.[skill].roll(options);
+            }
+            let skillName = token.actor.data.data.skills?.[skill].name;
+            skillName = skillName.charAt(0).toUpperCase() + skillName.slice(1);
+            this.checkRoll(`Skill Check: ${skillName}`, token.actor.skills?.[skill], 'skill-check', token.actor);
         }
     }
 
+    checkRoll(checkLabel,stat,type,actor) {
+        let checkModifier = new game.pf2e.CheckModifier(checkLabel, stat);
+        game.pf2e.Check.roll(checkModifier, {type:type, actor: actor, skipDialog: true}, null);
+    }
+
     /**
      * Items
      */
     getItems(token,itemType) {
+        if (this.isLimitedSheet(token.actor)) return [];
         if (itemType == undefined) itemType = 'any';
         const allItems = token.actor.items;
         if (itemType == 'any') return allItems.filter(i => i.type == 'weapon' || i.type == 'equipment' || i.type == 'consumable' || i.type == 'loot' || i.type == 'container');
@@ -229,13 +294,14 @@ export class pf2e{
     }
 
     getItemUses(item) {
-        return {available: item.data.data.quantity.value};
+        return {available: item.quantity.value};
     }
     
     /**
      * Features
      */
      getFeatures(token,featureType) {
+        if (this.isLimitedSheet(token.actor)) return [];
         if (featureType == undefined) featureType = 'any';
         const allItems = token.actor.items;
         if (featureType == 'any') return allItems.filter(i => i.type == 'ancestry' || i.type == 'background' || i.type == 'class' || i.type == 'feat' || i.type == 'action');
@@ -244,7 +310,10 @@ export class pf2e{
         if (featureType == 'action-int') return allItems.filter(i => i.type == 'action' && i.data.data.actionCategory?.value == 'interaction');
         if (featureType == 'action-off') return allItems.filter(i => i.type == 'action' && i.data.data.actionCategory?.value == 'offensive');
         if (featureType == 'strike') { //Strikes are not in the actor.items collection
-            let actions = token.actor.data.data.actions.filter(a=>a.type == 'strike');
+            if (token.actor.type == 'hazard' || token.actor.type == 'familiar') {
+                return allItems.filter(i => i.type == 'melee' || i.type == 'ranged');
+            }
+            let actions = token.actor.data.data.actions?.filter(a=>a.type == 'strike');
             for (let a of actions) {
                 a.img = a.imageUrl;
                 a.data = {
@@ -257,38 +326,188 @@ export class pf2e{
     }
 
     getFeatureUses(item) {
-        if (item.data.type == 'class') return {available: item.actor.data.data.details.level.value};
+        if (item.data.type == 'class') return {available: item.actor.details.level.value};
         else return;
     }
 
     /**
      * Spells
      */
+    buildSpellData(token) {
+        let spellData = [[],[],[],[],[],[],[],[],[],[],[],[]];
+        let spellcastingEntries = token.actor.spellcasting;
+        const actorLevel = token.actor.data.data.details.level.value;
+        spellcastingEntries.forEach(spellCastingEntry => {
+            let highestSpellSlot = Math.ceil(actorLevel/2);
+            while (spellCastingEntry.data.data.slots?.[`slot${highestSpellSlot}`]?.max <= 0) highestSpellSlot--;
+            //Prepared (not flexible)
+            if (spellCastingEntry.data.data.prepared?.value == 'prepared' && !spellCastingEntry?.data.data?.prepared?.flexible == true) {
+                for (let slotLevel = 0; slotLevel < 11; slotLevel++) {
+                    for (let slot = 0; slot < spellCastingEntry.data.data.slots?.[`slot${slotLevel}`].max; slot++) {
+                        let spellId = spellCastingEntry.data.data.slots?.[`slot${slotLevel}`].prepared?.[slot].id;
+                        let spell = spellCastingEntry.spells.get(spellId);
+                        if (spellId != null) {
+                            spellData[slotLevel].push(spell);
+                        }
+                    }
+                }
+            } else {
+                spellCastingEntry.spells.forEach( ses => {
+                    if ((spellCastingEntry.data.data.prepared.value == 'spontaneous' || spellCastingEntry.data.data.prepared?.flexible == true) && ses.data.data.location.signature == true) {
+                        let baseLevel = this.getSpellLevel(ses);
+                        for (let level = baseLevel; level <= highestSpellSlot; level++) {
+                            spellData[level].push(ses);
+                        }
+                    } else {
+                        spellData[this.getSpellLevel(ses)].push(ses);
+                    }
+                });
+            }
+        });
+        this.tokenSpellData.set(token.id,  {spellData: spellData, timeStamp: Date.now()});
+        return spellData;
+    }
+
+    getSpellData(token) {
+        let existingSpellData = this.tokenSpellData.get(token.id);
+        if (existingSpellData == undefined) return this.buildSpellData(token);
+        let milisSinceCreation = Date.now() - existingSpellData.timeStamp;
+        if (milisSinceCreation > 10000) {
+            this.tokenSpellData.delete(token.id);
+            return this.buildSpellData(token);
+        }
+        return existingSpellData.spellData;
+    }
+
+    getSpellLevel(spell) {
+        if (spell.isFocusSpell == true) return 11;
+        if (spell.isCantrip == true) return 0;
+        return spell.level;
+    }
+
     getSpells(token,level) {
+        if (this.isLimitedSheet(token.actor)) return '';
         if (level == undefined) level = 'any';
-        const allItems = token.actor.items;
-        if (level == 'any') return allItems.filter(i => i.type == 'spell')
-        if (level == '0') return allItems.filter(i => i.type == 'spell' && i.isCantrip == true)
-        else return allItems.filter(i => i.type == 'spell' && i.level == level && i.isCantrip == false)
+        let spellData = this.getSpellData(token);
+
+        if (level == 'f') return this.getUniqueSpells(spellData[11]);
+        if (level == 'any') return this.getUniqueSpells(spellData.flat());
+        return this.getUniqueSpells(spellData[level]);
+    }
+
+    getUniqueSpells(spells) {
+        return Array.from(new Set(spells));
     }
 
     getSpellUses(token,level,item) {
+        if (this.isLimitedSheet(token.actor)) return '';
         if (level == undefined || level == 'any') level = item.level;
         if (item.isCantrip == true) return;
-        const spellbook = token.actor.items.filter(i => i.data.type === 'spellcastingEntry')[0];
+        if (item.isFocusSpell == true) return {
+            available: token.actor.data.data.resources.focus.value,
+            maximum: token.actor.data.data.resources.focus.max
+        }
+        const spellbook = this.findSpellcastingEntry(token.actor, item);
         if (spellbook == undefined) return;
+        if (spellbook.data.data.prepared.value == 'innate') {
+            return {
+                available: item.data.data.location.uses.value,
+                maximum: item.data.data.location.uses.max
+            }
+        }
+        if (spellbook.data.data.prepared.value == 'prepared') {
+            if (!spellbook.data.data.prepared?.flexible == true) {
+                let slotsExpended = 0;
+                let slotsPrepared = 0;
+                for (let slot = 0; slot < spellbook.data.data.slots?.[`slot${level}`].max; slot++) {
+                    let slotEntry = spellbook.data.data.slots?.[`slot${level}`].prepared?.[slot];
+                    if (slotEntry.id == item.id) {
+                        slotsPrepared++;
+                        if (slotEntry?.expended == true) {
+                            slotsExpended++;
+                        }
+                    }
+                }
+                return {
+                    available: slotsPrepared - slotsExpended,
+                    maximum: slotsPrepared
+                }
+            }
+        }
         return {
             available: spellbook.data.data.slots?.[`slot${level}`].value,
             maximum: spellbook.data.data.slots?.[`slot${level}`].max
         }
     }
 
-    rollItem(item) {
+    findSpellcastingEntry(actor, spell) {
+        let spellcastingEntries = actor.spellcasting;
+        let result;
+        spellcastingEntries.forEach(spellCastingEntry => {
+            if (spellCastingEntry.spells.get(spell.id) != undefined) {
+                result = spellCastingEntry;
+            }
+        });
+        return result;
+    }
+
+    rollItem(item, settings) {
         let variant = 0;
         if (otherControls.rollOption == 'map1') variant = 1;
         if (otherControls.rollOption == 'map2') variant = 2;
+        if (item?.parent?.type == 'hazard' && item.type==='melee') return item.rollNPCAttack({}, variant+1);
         if (item.type==='strike') return item.variants[variant].roll({event});
-        if (item.type==='weapon' || item.type==='melee') return item.parent.data.data.actions.find(a=>a.name===item.name).variants[variant].roll({event});
+        if (item?.parent?.type !== 'hazard' && (item.type==='weapon' || item.type==='melee')) return item.parent.actions.find(a=>a.name===item.name).variants[variant].roll({event});
+        if (item.type === 'spell') {
+            const spellbook = this.findSpellcastingEntry(item.parent, item);
+            if (spellbook != undefined) {
+                let spellLvl = item.level;
+                if (settings.spellType == 'f' || settings.spellType == '0') {
+                    const actorLevel = item.parent.data.data.details.level.value;
+                    spellLvl =  Math.ceil(actorLevel/2);
+                } else if (settings.spellType != 'any') {
+                    spellLvl = settings.spellType;
+                }
+                if (spellbook.data.data.prepared.value == 'prepared' && !spellbook.data.data.prepared?.flexible == true) {
+                    for (let slotId = 0; slotId < spellbook.data.data.slots?.[`slot${spellLvl}`].max; slotId++) {
+                        let slotEntry = spellbook.data.data.slots?.[`slot${spellLvl}`].prepared?.[slotId];
+                        if (slotEntry.id == item.id) {
+                            if (!slotEntry?.expended == true) {
+                                return spellbook.cast(item, {slot: slotId, level: spellLvl});
+                            }
+                        }
+                    }
+                } else {
+                    return spellbook.cast(item, { level: spellLvl});
+                }
+            }
+        }
         return game.pf2e.rollItemMacro(item.id);
     }
+
+    isLimitedSheet(actor) {
+        return limitedSheets.includes(actor.type);
+    }
+
+    /**
+    * Ring Colors
+    */
+    getSkillRingColor(token, skill) {
+        return this.getRingColor(this.findSkill(token, skill));
+    }
+
+    getSaveRingColor(token, save) {
+        save = this.fixSave(save);
+        return this.getRingColor(this.findSave(token, save));
+    }
+
+    getRingColor(stat) {
+        if (stat == undefined) return;
+        let statModifiers = stat?.modifiers || stat?._modifiers;
+        const profLevel = statModifiers?.find(m => m.type == 'proficiency')?.slug;
+        if (profLevel != undefined) {
+            return proficiencyColors?.[profLevel];
+        }
+        return;
+    }
 }

src/systems/starfinder.js

@@ -0,0 +1,242 @@
+import {compatibleCore} from "../misc.js";
+
+const proficiencyColors = {
+    0: "#000000",
+    0.5: "#804A00",
+    1: "#C0C0C0",
+    2: "#FFD700"
+}
+
+export class starfinder{
+    constructor(){
+        
+    }
+
+    getHP(token) {
+        const hp = token.actor.data.data.attributes.hp;
+        return {
+            value: hp.value,
+            max: hp.max
+        }
+    }
+
+    getTempHP(token) {
+        return;
+    }
+
+    getStamina(token) {
+        const stamina = token.actor.data.data.attributes.sp;
+        return {
+            value: stamina.value,
+            max: stamina.max
+        }
+    }
+
+    getAC(token) {
+        return token.actor.data.data.attributes.eac.value;
+    }
+
+    getKinAC(token) {
+        return token.actor.data.data.attributes.kac.value;
+    }
+
+    getShieldHP(token) {
+        return;
+    }
+
+    getSpeed(token) {
+        const movement = token.actor.data.data.attributes.speed;
+        let speed = "";
+        if (movement.burrowing.value > 0) speed += `Burrow: ${movement.burrowing.value}Ft`;
+        if (movement.climbing.value > 0) {
+            if (speed.length > 0) speed += '\n';
+            speed += `Climb: ${movement.climbing.value}Ft`;
+        }
+        if (movement.flying.value > 0) {
+            if (speed.length > 0) speed += '\n';
+            speed += `Fly: ${movement.flying.value}Ft`;
+        }
+        if (movement.land.value > 0) {
+            if (speed.length > 0) speed += '\n';
+            speed += `Land: ${movement.land.value}Ft`;
+        }
+        if (movement.swimming.value > 0) {
+            if (speed.length > 0) speed += '\n';
+            speed += `Swim: ${movement.swimming.value}Ft`;
+        }
+        return speed;
+    }
+
+    getInitiative(token) {
+        let initiative = token.actor.data.data.attributes.init.total;
+        return (initiative >= 0) ? `+${initiative}` : initiative;
+    }
+
+    toggleInitiative(token) {
+        return;
+    }
+
+    getPassivePerception(token) {
+        return;
+    }
+
+    getPassiveInvestigation(token) {
+        return;
+    }
+
+    getAbility(token, ability) {
+        if (ability == undefined) ability = 'str';
+        return token.actor.data.data.abilities?.[ability].value;
+    } 
+
+    getAbilityModifier(token, ability) {
+        if (ability == undefined) ability = 'str';
+        let val = token.actor.data.data.abilities?.[ability].mod;
+        return (val >= 0) ? `+${val}` : val;
+    }
+
+    getAbilitySave(token, ability) {
+        if (ability == undefined) ability = 'fort';
+        else if (ability == 'ref') ability = 'reflex';
+        let val = token.actor.data.data.attributes?.[ability].bonus;
+        return (val >= 0) ? `+${val}` : val;
+    }
+
+    getSkill(token, skill) {
+        if (skill == undefined) skill = 'acr';
+        const val = token.actor.data.data.skills?.[skill].mod;
+        return (val >= 0) ? `+${val}` : val;
+    }
+
+    getProficiency(token) {
+        return;
+    }
+
+    getConditionIcon(condition) {
+        if (condition == undefined) condition = 'removeAll';
+        if (condition == 'removeAll') return window.CONFIG.controlIcons.effects;
+        else return CONFIG.statusEffects.find(e => e.id === condition).icon;
+    }
+
+    getConditionActive(token,condition) {
+        if (condition == undefined) condition = 'removeAll';
+        return token.actor.effects.find(e => e.isTemporary === condition) != undefined;
+    }
+
+    async toggleCondition(token,condition) {
+        if (condition == undefined) condition = 'removeAll';
+        if (condition == 'removeAll'){
+            for( let effect of token.actor.effects)
+                await effect.delete();
+        }
+        else {
+            if (this.getConditionActive(token,condition)) token.actor.setCondition(condition,false);
+            else token.actor.setCondition(condition,true);
+        }
+        return true;
+    }
+
+    /**
+     * Roll
+     */
+     roll(token,roll,options,ability,skill,save) {
+        if (roll == undefined) roll = 'ability';
+        if (ability == undefined) ability = 'str';
+        if (skill == undefined) skill = 'acr';
+        if (save == undefined) save = 'str';
+
+        if (roll == 'ability') token.actor.rollAbilityTest(ability,options);
+        else if (roll == 'save') token.actor.rollAbilitySave(save,options);
+        else if (roll == 'skill') token.actor.rollSkill(skill,options);
+        else if (roll == 'initiative') token.actor.rollInitiative(options);
+        else if (roll == 'deathSave') token.actor.rollDeathSave(options);
+    }
+
+    /**
+     * Items
+     */
+    getItems(token,itemType) {
+        if (itemType == undefined) itemType = 'any';
+        const allItems = token.actor.items;
+        if (itemType == 'any') return allItems.filter(i => i.type == 'weapon' || i.type == 'shield' || i.type == 'equipment' || i.type == 'consumable' || i.type == 'goods' || i.type == 'container' || i.type == 'technological' || i.type == 'fusion' || i.type == 'upgrade' || i.type == 'weaponAccessory' || i.type == 'augmentation');
+        else if (itemType == 'enhancers') return allItems.filter(i => i.type == 'fusion' || i.type == 'upgrade' || i.type == 'weaponAccessory');
+        else return allItems.filter(i => i.type == itemType);
+    }
+
+    getItemUses(item) {
+        return {available: item.data.data.quantity};
+    }
+
+    /**
+     * Features
+     */
+    getFeatures(token,featureType) {
+        if (featureType == undefined) featureType = 'any';
+        const allItems = token.actor.items;
+        if (featureType == 'any') return allItems.filter(i => i.type == 'class' || i.type == 'race' || i.type == 'theme'|| i.type == 'asi' || i.type == 'archetype' || i.type == 'feat' || i.type == 'actorResource')
+        else if (featureType == 'activeFeat' || featureType == 'passiveFeat') {
+            const features = allItems.filter(i => i.type == 'feat');
+            if (featureType == 'activeFeat') return features.filter(i => i.labels.featType == 'Action');
+            else return features.filter(i => i.labels.featType == 'Passive');
+        }
+        return allItems.filter(i => i.type == featureType)
+    }
+
+    getFeatureUses(item) {
+        if (item.data.type == 'class') return {available: item.data.data.levels};
+        else return {
+            available: item.data.data.uses.value, 
+            maximum: item.data.data.uses.max
+        };
+    }
+
+    /**
+     * Spells
+     */
+     getSpells(token,level) {
+        if (level == undefined) level = 'any';
+        const allItems = token.actor.items;
+        if (level == 'any') return allItems.filter(i => i.type == 'spell')
+        else if (level == 'innate') return allItems.filter(i => i.type == 'spell' && i.data.data.preparation.mode == 'innate');
+        else return allItems.filter(i => i.type == 'spell' && i.data.data.preparation.mode == '' && i.data.data.level == level)
+    }
+
+    getSpellUses(token,level,item) {
+        if (level == undefined) level = 'any';
+        if (item.data.data.level == 0) return;
+
+        const spellSlots = token.actor.data.data.spells;
+        const allowedClasses = item.data.data.allowedClasses;
+
+        let uses = {available: 0, maximum: 0};
+        if (allowedClasses.myst && spellSlots?.[`spell${level}`].perClass?.mystic?.max > uses.maximum) 
+            uses = {available: spellSlots?.[`spell${level}`].perClass?.mystic.value, maximum: spellSlots?.[`spell${level}`].perClass?.mystic.max}
+        if (allowedClasses.precog && spellSlots?.[`spell${level}`].perClass?.precog?.max > uses.maximum) 
+            uses = {available: spellSlots?.[`spell${level}`].perClass?.precog.value, maximum: spellSlots?.[`spell${level}`].perClass?.precog.max}
+        if (allowedClasses.tech && spellSlots?.[`spell${level}`].perClass?.technomancer?.max > uses.maximum) 
+            uses = {available: spellSlots?.[`spell${level}`].perClass?.technomancer.value, maximum: spellSlots?.[`spell${level}`].perClass?.technomancer.max}
+        if (allowedClasses.wysh && spellSlots?.[`spell${level}`].perClass?.witchwarper?.max > uses.maximum) 
+            uses = {available: spellSlots?.[`spell${level}`].perClass?.witchwarper.value, maximum: spellSlots?.[`spell${level}`].perClass?.witchwarper.max} 
+
+        return uses;
+    }
+
+    rollItem(item) {
+        return item.roll()
+    }
+
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token, skill) {
+        const profLevel = token.actor.data.data?.skills[skill]?.proficient;
+        if (profLevel == undefined) return;
+        return proficiencyColors?.[profLevel];
+    }
+
+    getSaveRingColor(token, save) {
+        const profLevel = token.actor.data.data?.abilities[save]?.proficient;        
+        if (profLevel == undefined) return;
+        return proficiencyColors?.[profLevel];
+    }
+}

src/systems/tokenHelper.js

@@ -1,9 +1,13 @@
-import {dnd5e} from "./dnd5e.js"
-import {dnd35e} from "./dnd35e.js"
-import {pf2e} from "./pf2e.js"
+import {dnd5e} from "./dnd5e.js";
+import {dnd35e} from "./dnd35e.js";
+import {pf2e} from "./pf2e.js";
 import {demonlord} from "./demonlord.js";
-import {wfrp4e} from "./wfrp4e.js"
+import {wfrp4e} from "./wfrp4e.js";
+import {forbiddenlands} from "./forbidden-lands.js";
+import {starfinder} from "./starfinder.js";
 import {compatibleCore} from "../misc.js";
+import {gamingSystem} from "../../MaterialDeck.js";
+
 
 export class TokenHelper{
     constructor(){
@@ -12,10 +16,12 @@ export class TokenHelper{
     }
 
     setSystem() {
-        if (game.system.id == 'D35E' || game.system.id == 'pf1') this.system = new dnd35e();
-        else if (game.system.id == 'pf2e') this.system = new pf2e();
-        else if (game.system.id == 'demonlord') this.system = new demonlord();
-        else if (game.system.id == 'wfrp4e') this.system = new wfrp4e();
+        if (gamingSystem == 'D35E' || gamingSystem == 'pf1') this.system = new dnd35e();
+        else if (gamingSystem == 'pf2e') this.system = new pf2e();
+        else if (gamingSystem == 'demonlord') this.system = new demonlord();
+        else if (gamingSystem == 'wfrp4e') this.system = new wfrp4e();
+        else if (gamingSystem == 'forbidden-lands') this.system = new forbiddenlands();
+        else if (gamingSystem == 'sfrpg') this.system = new starfinder();
         else this.system = new dnd5e();     //default to dnd5e
     }
 
@@ -31,7 +37,7 @@ export class TokenHelper{
         else if (type == 'actorId') return this.getTokenFromActorId(identifier);
     }
     getTokenFromTokenId(id) {
-        return canvas.tokens.children[0].children.find(p => p.id == id);
+        return canvas.tokens.get(id);
     }
 
     getTokenFromTokenName(name) {
@@ -129,7 +135,7 @@ export class TokenHelper{
     }
 
     /***********************************************************************
-     * System agnostic functions
+     * System specific functions
      ***********************************************************************/
     getHP(token) {
         return this.system.getHP(token);
@@ -227,6 +233,36 @@ export class TokenHelper{
         return this.system.getPerception(token)
     }
 
+    /* forbidden-lands */
+    getAgility(token) {
+        return this.system.getAgility(token)
+    }    
+
+    /* forbidden-lands */
+    getWits(token) {
+        return this.system.getWits(token)
+    }
+
+    /* forbidden-lands */
+    getEmpathy(token) {
+        return this.system.getEmpathy(token)
+    }
+     /* forbidden-lands */
+    getWillPower(token) {
+        return this.system.getWillPower(token)
+    }
+
+    /* starfinder */
+    getStamina(token) {
+        return this.system.getStamina(token);
+    }
+
+    /* starfinder */
+    getKinAC(token) {
+        return this.system.getKinAC(token);
+    }
+    
+
     /**
      * Conditions
      */
@@ -292,7 +328,17 @@ export class TokenHelper{
         return this.system.getSpellUses(token,level,item);
     }
 
-    rollItem(item) {
-        return this.system.rollItem(item);
+    rollItem(item, settings) {
+        return this.system.rollItem(item, settings);
+    }
+
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token,skill) {
+        return this.system.getSkillRingColor(token,skill);
+    }
+    getSaveRingColor(token,save) {
+        return this.system.getSaveRingColor(token,save);
     }
 }

src/systems/wfrp4e.js

@@ -104,7 +104,6 @@ export class wfrp4e {
     }
 
     roll(token,roll,options,ability,skill,save) {
-        //console.log("roll(", token, roll, options, ability, skill, save, ")");
         if (ability == undefined) ability = 'ag';
         return game.wfrp4e.utility.rollItemMacro(ability, "characteristic", false);
     }
@@ -125,7 +124,6 @@ export class wfrp4e {
 
 
     getItemUses(item) {
-        console.log("getItemUses(" , item , ")")
         if ( item.type == 'ammunition') {
             return {available: item.data.data.quantity.value};
         }
@@ -168,5 +166,14 @@ export class wfrp4e {
         return;
     }
 
+    /**
+     * Ring Colors
+     */
+     getSkillRingColor(token, skill) {
+        return;
+    }
 
+    getSaveRingColor(token, save) {
+        return;        
+    }
 }

src/token.js

@@ -1,5 +1,6 @@
 import * as MODULE from "../MaterialDeck.js";
 import {streamDeck, macroControl, otherControls, tokenHelper} from "../MaterialDeck.js";
+import { compatibleCore } from "./misc.js";
 
 export class TokenControl{
     constructor(){
@@ -106,6 +107,59 @@ export class TokenControl{
                         };
                         
                 }
+
+                if (stats == 'Agility') { /* forbidden-lands */
+                    const wits = tokenHelper.getAgility(token);
+                    txt += wits.value + "/" + wits.max;
+                    
+                    if (icon == 'stats')
+                        uses = {
+                            available: wits.value,
+                            maximum: wits.max,
+                            heart: "#FF0000"
+                        };
+                        
+                }
+
+                if (stats == 'Wits') { /* forbidden-lands */
+                    const wits = tokenHelper.getWits(token);
+                    txt += wits.value + "/" + wits.max;
+                    
+                    if (icon == 'stats')
+                        uses = {
+                            available: wits.value,
+                            maximum: wits.max,
+                            heart: "#FF0000"
+                        };
+                        
+                }
+
+                if (stats == 'Empathy') { /* forbidden-lands */
+                    const wits = tokenHelper.getEmpathy(token);
+                    txt += wits.value + "/" + wits.max;
+                    
+                    if (icon == 'stats')
+                        uses = {
+                            available: wits.value,
+                            maximum: wits.max,
+                            heart: "#FF0000"
+                        };
+                        
+                }
+
+                if (stats == 'WillPower') { /* forbidden-lands */
+                    const wits = tokenHelper.getWillPower(token);
+                    txt += wits.value + "/" + wits.max;
+                    
+                    if (icon == 'stats')
+                        uses = {
+                            available: wits.value,
+                            maximum: wits.max,
+                            heart: "#FF0000"
+                        };
+                        
+                }
+
                 if (stats == 'CriticalWounds') { /* WFRP4e */
                     const criticalWounds = tokenHelper.getCriticalWounds(token);
                     txt += criticalWounds.value + "/" + criticalWounds.max;
@@ -136,6 +190,13 @@ export class TokenControl{
                             heart: "#00FF00"
                         };
                 }
+                else if (stats == 'Stamina') {    //starfinder
+                    const stamina = tokenHelper.getStamina(token);
+                    txt += `${stamina.value}/${stamina.max}`;
+                }
+                else if (stats == 'KinAC') {    //starfinder
+                    txt += tokenHelper.getKinAC(token);
+                }
                 else if (stats == 'AC') txt += tokenHelper.getAC(token);
                 else if (stats == 'ShieldHP') txt += tokenHelper.getShieldHP(token);
                 else if (stats == 'Speed') txt += tokenHelper.getSpeed(token);
@@ -144,8 +205,16 @@ export class TokenControl{
                 else if (stats == 'PassiveInvestigation') txt += tokenHelper.getPassiveInvestigation(token);
                 else if (stats == 'Ability') txt += tokenHelper.getAbility(token, settings.ability);
                 else if (stats == 'AbilityMod') txt += tokenHelper.getAbilityModifier(token, settings.ability);
-                else if (stats == 'Save') txt += tokenHelper.getAbilitySave(token, settings.save);
-                else if (stats == 'Skill') txt += tokenHelper.getSkill(token, settings.skill);
+                else if (stats == 'Save') {
+                    txt += tokenHelper.getAbilitySave(token, settings.save);
+                    ringColor = tokenHelper.getSaveRingColor(token, settings.save);
+                    if (ringColor != undefined) ring = 2;
+                }
+                else if (stats == 'Skill') {
+                    txt += tokenHelper.getSkill(token, settings.skill);
+                    ringColor = tokenHelper.getSkillRingColor(token, settings.skill);
+                    if (ringColor != undefined) ring = 2;
+                }
                 else if (stats == 'Prof') txt += tokenHelper.getProficiency(token);
                 else if (stats == 'Fate') txt += tokenHelper.getFate(token) /* WFRP4e */
                 else if (stats == 'Fortune') txt += tokenHelper.getFortune(token) /* WFRP4e */
@@ -372,7 +441,7 @@ export class TokenControl{
                 iconSrc = "modules/MaterialDeck/img/token/hp_empty.png";
             if (stats == 'TempHP') //Temp HP
                 iconSrc = "modules/MaterialDeck/img/token/temp_hp_empty.png";
-            else if (stats == 'AC' || stats == 'ShieldHP') //AC
+            else if (stats == 'AC' || stats == 'ShieldHP' || stats == 'KinAC') //AC
                 iconSrc = "modules/MaterialDeck/img/token/ac.webp";
             else if (stats == 'Speed') //Speed
                 iconSrc = "modules/MaterialDeck/img/token/speed.webp";
@@ -390,7 +459,6 @@ export class TokenControl{
             }
             else if (stats == 'Ability' || stats == 'AbilityMod' || stats == 'Save') {
                 overlay = true;
-                ring = 1;
                 let ability = (stats == 'Save') ? settings.save : settings.ability;
                 if (ability == undefined) ability = 'str';
                 if (ability == 'con') iconSrc = "modules/MaterialDeck/img/token/abilities/cons.png";
@@ -398,10 +466,9 @@ export class TokenControl{
             }
             else if (stats == 'Skill') {
                 overlay = true;
-                ring = 1;
                 let skill = settings.skill;
                 if (skill == undefined) skill = 'acr';
-                else iconSrc = "modules/MaterialDeck/img/token/skills/" + skill + ".png";
+                else iconSrc = "modules/MaterialDeck/img/token/skills/" + (skill.startsWith('lor')? 'lor' : skill) + ".png";
             }
             else if (settings.onClick == 'center' || settings.onClick == 'centerSelect') {
                 overlay = true;
@@ -556,23 +623,30 @@ export class TokenControl{
                 if (isNaN(dimVision)==false) data.dimSight = dimVision;
                 if (isNaN(brightVision)==false) data.brightSight = brightVision;
                 if (isNaN(sightAngle)==false) data.sightAngle = sightAngle;
-                if (isNaN(dimRadius)==false) data.dimLight = dimRadius;
-                if (isNaN(brightRadius)==false) data.brightLight = brightRadius;
-                if (isNaN(emissionAngle)==false) data.lightAngle = emissionAngle;
-                data.lightColor = lightColor;
-                data.lightAlpha = Math.sqrt(colorIntensity).toNearest(0.05)
+
+                let light = {};
+
+
+                if (isNaN(dimRadius)==false) light.dim = dimRadius;
+                if (isNaN(brightRadius)==false) light.bright = brightRadius;
+                if (isNaN(emissionAngle)==false) light.angle = emissionAngle;
+                light.color = lightColor;
+                light.alpha = Math.sqrt(colorIntensity).toNearest(0.05)
+
                 let animation = {
                     type: '',
-                    speed: tokenData.lightAnimation.speed,
-                    intensity: tokenData.lightAnimation.intensity
+                    speed: tokenData.light.animation.speed,
+                    intensity: tokenData.light.animation.intensity
                 };
                 if (animationType != 'none'){
                     animation.type = animationType;
                     animation.intensity = animationIntensity;
                     animation.speed = animationSpeed;
                 }
-                data.lightAnimation = animation;
-                token.update(data);
+                light.animation = animation;
+                data.light = light;
+                if (compatibleCore('0.8.1')) token.document.update(data);
+                else token.update(data);
             }
             else if (onClick == 'initiative'){
                 tokenHelper.toggleInitiative(token);
@@ -610,7 +684,8 @@ export class TokenControl{
                 else return;
 
                 iconSrc = images[imgNr];
-                token.update({img: iconSrc})
+                if (compatibleCore('0.8.1')) token.document.update({img: iconSrc});
+                else token.update({img: iconSrc})
             }
             else if (onClick == 'macro') {  //call a macro
                 const settingsNew = {
@@ -753,7 +828,8 @@ export class TokenControl{
                                 if (path != '') path += '.';
                                 path += targetArray[i][j];
                             }
-                            await token.update({[path]:value})
+                            if (compatibleCore('0.8.1')) await token.document.update({[path]:value});
+                            else await token.update({[path]:value})
                             this.update(token.id);
                         }
                         
@@ -778,7 +854,7 @@ export class TokenControl{
 
             const item = items[itemNr];
             if (item != undefined) {
-                tokenHelper.rollItem(item);
+                tokenHelper.rollItem(item, settings);
             }
             
         }

templates/deviceConfig.html

@@ -0,0 +1,41 @@
+<form autocomplete="off" onsubmit="event.preventDefault()">
+
+  <style>
+    .columnLabel {
+        max-width:30%;
+        min-width:30%;
+        text-align: left;
+    }
+    .columnId {
+        max-width:25%;
+        min-width:25%;
+        text-align: left;
+        text-overflow: hidden;
+    }
+    .columnCB {
+        width:10%;
+        text-align: left;
+    }
+  </style>
+
+  <table style="width:100%; min-width:400px">
+    <tr>
+      <th class='columnLabel'>{{localize "MaterialDeck.Name"}}</th>
+      <th class='columnLabel'>{{localize "MaterialDeck.Type"}}</th>
+      <th class='columnId'>{{localize "MaterialDeck.Id"}}</th>
+      <th class='columnCB'>{{localize "MaterialDeck.Perm.ENABLE.ENABLE.label"}}</th>
+    </tr>
+    {{#each devices as |d|}}
+    <tr>
+      <td class='columnLabel'>{{d.name}}</td>
+      <td class='columnLabel'>{{d.type}}</td>
+      <td class='columnId'><input type="text" value={{d.id}} disabled></td>
+      <td class='columnCB'><input type="checkbox" name="enable" id={{d.id}} {{checked d.en}}></td>
+    </tr>
+    {{/each}}
+
+  </table>
+
+    
+
+</form>

templates/downloadUtility.html

@@ -51,9 +51,10 @@
           <td class='columnVersion' id='masterMsVersion'>{{masterMsVersion}}</td>
           <td class='columnOS'>
             <select id="os" default="" {{#if msDlDisable}}disabled{{/if}}>
-                <option value="win">{{localize "MaterialDeck.DownloadUtility.Windows"}}</option>
-                <option value="macos">{{localize "MaterialDeck.DownloadUtility.Macos"}}</option>
-                <option value="linux">{{localize "MaterialDeck.DownloadUtility.Linux"}}</option>
+                <option value="win32-x64">{{localize "MaterialDeck.DownloadUtility.Windows"}}</option>
+                <option value="macos-x64">{{localize "MaterialDeck.DownloadUtility.MacosIntel"}}</option>
+                <option value="macos-arm64">{{localize "MaterialDeck.DownloadUtility.MacosM1"}}</option>
+                <option value="linux-x64">{{localize "MaterialDeck.DownloadUtility.Linux"}}</option>
                 <option value="source">{{localize "MaterialDeck.DownloadUtility.Source"}}</option>
             </select>
           </td>