Removed chat reporting of blocked commands, and fixed the issue where ClockTokens would report on commands sent to other scripts. Also corrected .readme file.

Author: Tyson

ClockTokens/1.2/ClockTokens.js

@@ -0,0 +1,239 @@
+/*
+ * ClockTokens.js
+ * Current version: 1.2
+ * Last updated: 2022-04-24 by Tyson Tiatia
+ * 
+ * See README.md for full description
+ * 
+ * Commands:
+ *      !clocktokens [next|prev|first|last]
+ * 
+ * User Options:
+ *      [GM Only]
+ *      [Use Macros]
+ */
+var ClockTokens = ClockTokens || (function () {
+    'use strict';
+
+    var version = "1.2",
+        lastUpdate = "2022-04-24",
+        listenerActive = false,
+        userOptions = (globalconfig && globalconfig.ClockTokens) || {
+            "GM Only": true,
+            "Use Macros": true
+        },
+
+        /** Prints script info to log */
+        checkInstall = function () {
+            log("ClockTokens v" + version + " installed.");
+        },
+
+        /** Prints script user options to log */
+        checkOptions = function () {
+            log("-GM Only: " + userOptions["GM Only"] + "\n-Use Macros: " + userOptions["Use Macros"]);
+        },
+
+        /** Adds the chat event handler */
+        registerEventHandlers = function () {
+            if (!listenerActive) {
+                on('chat:message', handleInput);
+                listenerActive = true;
+            }
+        },
+
+        /** Returns a usable string for imagesrc
+        * @param {string} imgscr The raw source string
+        */
+        getCleanImagesrc = function (imgsrc) {
+            var parts = imgsrc.match(/(.*\/images\/.*)(thumb|med|original|max)([^?]*)(\?[^?]+)?$/);
+            if (parts) {
+                return parts[1] + 'thumb' + parts[3] + (parts[4] ? parts[4] : `?${Math.round(Math.random() * 9999999)}`);
+            }
+            return;
+        },
+
+        /** 
+        * Processes input from the user
+        * @param {*} msg - The Roll20 chat message object/
+        */
+        handleInput = function (msg) {
+            if (msg.type == "api") {
+                var cmds = msg.content.trim().toLowerCase().split(/[ ]+/);
+
+                if (cmds[0] === "!clocktokens") {
+
+                    // Based on user setting, ignore non-GM players' commands
+                    if (userOptions["GM Only"] && !playerIsGM(msg.playerid) && cmds[0] === "!clocktokens") {
+                        log("ClockTokens: Command from " + msg.who + " blocked due to GM-only mode being active");
+                        return;
+                    }
+
+                    if (cmds.length !== 2) {
+                        sendChat("API", "Error with !clocktokens command.");
+                    }
+                    if (msg.selected && msg.selected.length > 0) {
+                        var tokens = msg.selected.flatMap(function (o) {
+                            return o._type == "graphic" ? getObj("graphic", o._id) : [];
+                        });
+
+                        tokens.forEach(obj => {
+                            var allSides = getSides(obj);
+                            if (allSides.length <= 1) {
+                                // Nothing to change
+                                return;
+                            }
+
+                            var currentSide = getCurrentSide(obj, allSides);
+                            switch (cmds[1]) {
+                                case "next":
+                                    if (currentSide < allSides.length + 1) {
+                                        setSide(obj, allSides, currentSide + 1);
+                                    }
+                                    break;
+                                case "prev":
+                                    if (currentSide > 0) {
+                                        setSide(obj, allSides, currentSide - 1);
+                                    }
+                                    break;
+                                case "first":
+                                    setSide(obj, allSides, 0);
+                                    break;
+                                case "last":
+                                    setSide(obj, allSides, allSides.length - 1);
+                                    break;
+                            }
+                        });
+                    }
+                }
+            }
+        },
+
+        /** 
+        * Retrieves all data on token sides
+        * @param {*} obj - the Roll20 graphic object
+        */
+        getSides = function (obj) {
+            return obj.get("sides").split("|");
+        },
+
+        /** 
+        * Retrieves the index of the current token side
+        * @param {*} obj - the Roll20 graphic object
+        * @param {array} allSides - the array of image data for the token
+        */
+        getCurrentSide = function (obj, allSides) {
+            var side = obj.get("currentSide");
+            return allSides.indexOf(side);
+        },
+
+        /**
+        * Changes the token's active side to the specified index
+        * @param {*} obj - The Roll20 graphic object
+        * @param {array} allSides - the array of image data for the token
+        * @param {int} newIndex - the index of th
+        */
+        setSide = function (obj, allSides, newIndex) {
+            var nextURL = getCleanImagesrc(decodeURIComponent(allSides[newIndex]));
+            if (nextURL) {
+                obj.set({
+                    currentSide: allSides[newIndex],
+                    imgsrc: nextURL
+                });
+            }
+        },
+
+        /** Adds the macros for this script */
+        manageMacros = function () {
+            if (userOptions["Use Macros"]) {
+                var gmId = findObjs({ _type: 'player' })[0].id;
+                var whoCanSee = !userOptions["GM Only"] ? "all" : getAllGmPlayerNames().join(",");
+                addMacro("TokenNext", "!clocktokens next", gmId, whoCanSee);
+                addMacro("TokenPrev", "!clocktokens prev", gmId, whoCanSee);
+                addMacro("TokenFirst", "!clocktokens first", gmId, whoCanSee);
+                addMacro("TokenLast", "!clocktokens last", gmId, whoCanSee);
+            }
+            else {
+                removeMacro("TokenNext");
+                removeMacro("TokenPrev");
+                removeMacro("TokenFirst");
+                removeMacro("TokenLast");
+            }
+        },
+
+        /**
+        * Either creates a new macro or updates an existing one to match the specifications
+        * @param {string} mName - The Name of the macro
+        * @param {string} mAction - The contents of the macro (what it does when it runs)
+        * @param {string} gmId - A playereId to be recorded as the creator
+        * @param {string} visibleTo - Comma-delimited list of players who should be able to see the macro
+        */
+        addMacro = function (mName, mAction, gmId, whoCanSee) {
+            var macro = findObjs({ type: "macro", name: mName });
+            if (macro.length == 0) {
+                createObj("macro", {
+                    name: mName,
+                    action: mAction,
+                    playerid: gmId,
+                    istokenaction: true,
+                    visibleto: whoCanSee
+                });
+            }
+            else {
+                macro[0].set({
+                    action: mAction,
+                    istokenaction: true,
+                    visibleto: whoCanSee
+                });
+                if (macro.length > 1) {
+                    for (var i = 1; i < macro.length; i++) {
+                        macro[i].remove();
+                    }
+                }
+            }
+        },
+
+        /**
+        * Deletes the specified macro, if it exists
+        * @param {string} mName - The Name of the macro
+        */
+        removeMacro = function (mName) {
+            var macro = findObjs({ type: "macro", name: mName });
+            if (macro.length > 0) {
+                macro.forEach(function (m) {
+                    m.remove();
+                });
+            }
+        },
+
+        /**
+        * Returns a list of GM names 
+        */
+        getAllGmPlayerNames = function () {
+            var names = [];
+            var currentPlayers = findObjs({
+                _type: "player",
+            });
+            _.each(currentPlayers, function (obj) {
+                if (playerIsGM(obj.get("_id"))) {
+                    log("GM found \"" + obj.get("_displayname") + "\"");
+                    names.push(obj.get("_id"));
+                }
+            });
+            return names;
+        };
+
+    return {
+        CheckInstall: checkInstall,
+        CheckOptions: checkOptions,
+        ManageMacros: manageMacros,
+        RegisterEventHandlers: registerEventHandlers
+    };
+}());
+
+on("ready", function () {
+    'use strict';
+    ClockTokens.CheckInstall();
+    ClockTokens.CheckOptions();
+    ClockTokens.ManageMacros();
+    ClockTokens.RegisterEventHandlers();
+});

ClockTokens/READEME.md ClockTokens/README.md

@@ -1,26 +1,39 @@
 # Clock Tokens
 
-##What is it?
+## What is it?
+
 This script gives you an easy way to manage multi-sided tokens which are being used to represent [progress clocks](http://bladesinthedark.com/progress-clocks), or any other kind of incrementing timer or countdown.
 
-##What does it do?
+## What does it do?
+
 The script changes the token image of currently selected tokens based on the command given:
+
 * ``!clocktokens next`` changes to the next 'side' of a multi-sided token. If already on the last side, no change.
 * ``!clocktockens prev`` changes to the previous 'side' of a multi-sided token. If already on the first side, no change.
 * ``!clocktockens first`` changes to the first 'side' of a multi-sided token. If already on the first side, no change.
 * ``!clocktockens last`` changes to the last 'side' of a multi-sided token. If already on the last side, no change.
 
-##User Options
+## User Options
+
 * _GM Only_: (Default On) If enabled then only the GM can use the ``!clocktokens`` commands.
 * _Use Macros_: (Default On) If enabled then token macros will automatically be created an maintained, one for each of the four commands above.
 
-##Why use this over other token scripts?
+## Why use this over other token scripts?
+
 This script was designed specifically for handling the large number of _Forged In The Dark_ and _Powered By The Apocolpyse_ games that I run. Multi-sided tokens take far too many clicks to move between sides, and there is no way to change multiple at once.
 
 There are other token scripts with far more functionality, and if you feel you'll benefit from them then I recommend using those instead. However if you only want to flip multi-sided tokens back and forth in sequence then there's no need to bloat your game with a larger, more complicated script.
 
-##Changelist
-###_v1.0_ (2021-01-01)
+## Changelist
+
+### _v1.0_ (2021-01-01)
+
 * Script created
-###_v1.1_ (2021-05-09)
+
+### _v1.1_ (2021-05-09)
+
 * Changed logic to accomodate multi-GM games or games where the creator is not a GM.
+
+### _v1.2_ (2022-04-24)
+
+* Removed chat reporting of blocked commands, and fixed the issue where ClockTokens would report on commands sent to other scripts. Also corrected .readme file.

ClockTokens/script.json

@@ -1,7 +1,7 @@
 {
     "name": "Clock Tokens",
     "script": "ClockTokens.js",
-    "version": "1.1",
+    "version": "1.2",
     "authors": "Tyson Tiatia",
     "description": "A script for GMs utilising Multi-sided tokens to track 'clocks', a common mechanic for tracking progress in Power By The Apocolypse and Forged In The Dark games, among others. Accepts the command !clocktokens with one of the following parameters: 'next', 'prev', 'first', 'last', and changes any multi-sided tokens selected to the corresponding image. Automatically adds four token macros for these commands.",
     "roll20userid": "514883",
@@ -22,6 +22,7 @@
     }
   ],
   "previousversions": [
-    "1.0"
+    "1.0",
+    "1.1"
   ]
 }