Melvin the Mediocre said: What I have googled and googled for is an example of a command that first rolls a die that will show up in chat, then catches that result and assigns it a variable. Can you show me how to do that? If so you will be my personal hero for say... 1 hour? I can negotiate on the duration. My hero-dom is bookable in 4 hour blocks, minimum. =D What you're going to run into in what you described (the roll hitting chat AND a script working with it) is that when you send a message through chat, you're sending one of 2 types: a normal/flat message that hits the chat output, or a message intended for the Script Moderator which does not hit the chat output. Scripts can listen for both kinds of messages and take action based on them, however in the case of a normal message, anything a script would do would come separately (and after the message hit the chat output). CustomizableRollListener is one script that listens to normal messages in order to take action, but I believe it is checking for a particular kind of roll template that clues it in that there will be rolls. You won't have that luxury. There are dozens and dozens of rolls made during a game; how will your script know which to act on? That's why most scripts operate on a script handle (like yours is looking for "!Sacred Geometry"), so that they know "this message is intended for me and I should take this/that action." However, relying on a script handle and a bangsy message (prepended with an "!"), nothing hits the chat automatically, so it's up to your script to construct the output (ie, if you want the roll/hover tip with the roll result). This can be done, but it's a bit of a pain. It's much easier to use libInline and let it construct the roll tip for you, and then your script just inserts it where it needs to be. That's also a bit down the road for you. Right now you just want to capture the rolls, so let's start there. Where Rolls Come From Your rolls will either be in your command line, or you will need to build your equation for the roll and then use the sendChat callback to issue/catch a message with the inline roll in its command line. I'll try to give an example of each... First, I would suggest your command line logic gets a bit stiffer. Currently you have a space in your script handle, and your three variables are hard-coded to appear in positions 16, 17, and 18. Not only are they therefore limited to a single digit, but you have to remember what order to supply them. That's not ideal. Let's try for a command line more like this: !sacredgeometry [[4d6]] [[3d6]] ...for the example of getting rolls from your command line, and more like this: !sacredgeometry --level=2 --roll1=4 --roll2=3 ...for building the roll equation from your supplied arguments and then using the sendChat callback. Before we split into 2 paths, validating the script handle will be the same for both approaches, so let's do that: on("ready",function() { on("chat:message",function(msg){ if(msg.type!=="api" || !/^!sacredgeometry\b/i.test(msg.content) return; I prefer to save white-space indenting for the rest of the code by reversing the check, here. Look for a reason to exit and then return. After that, your lines of code can continue at a normal indentation. I used a regular expression (you can play with it here ), but if you're not comfortable with that, you can still use your indexOf() method, or even a startsWith() method... just make sure you negate it (as in, "does not start with") so that you're looking for a reason to exit. Now let's parse the line and get the rolls. Rolls in the Original Command Line When you send rolls through the chat, your command line will change, removing the roll formation and leaving behind the roll index marker. So this command line: !sacredgeometry [[4d6]] [[3d6]] ...becomes !sacredgeometry $[[0]] $[[1]] You don't know how convoluted or complex the roll equation was for that roll -- someone could have homebrewed a method for arriving at the number of dice that took into account averages of attributes from a character, turned that into a number of d2, then used that result as the number of d6 to roll... You. Don't. Know. What you do know is that however many nested rolls and operations are in that position, the roll marker returned from Roll20 parsing will represent the outer-most roll (the one that would report to the chat if you just sent it through as part of a normal message). So if the roll had 10 nested rolls, it would appear to be $[[10]] (the index is zero based, so this is actually the 11th roll). The index of the roll marker is important because if an inline roll is included in the command line of the message, your message object will have an inlinerolls property, which will be an array of all of the rolls included in the message. This array is also zero-based, so your roll marker tells you exactly which roll index you need from the array for this position in the command line. For this method, where you're expecting inline rolls in the command line, you'll want to make sure they're there. I'm showing a command line with multiple rolls (and honestly, if as a scripter I'm going to allow multiple rolls like this supplied to my script, without argument names, it's only because I'm going to treat every roll the same -- ie, I'm going to try to make sure the user doesn't have to remember the order you'd enter the rolls; if the rolls would be used differently, I'd include the formatting and steps I'll discuss with the alternate command line... parsing arguments by name). Even though I show multiple rolls, your need is just to make sure that there is at least 1 roll there. So our next step would be to test if the inlinerolls property is there: if (!(msg.inlinerolls && msg.inlinerolls.length)) { // handle bad message syntax here... sending a notification to the user... return; } If we survive past that, we're ready to parse our line. let args = msg.content.split(/\s+/).slice(1); That says we'll split the command line on whitespace. split() returns an array, and the first (0 th ) entry of the array will be the script handle, which we don't need, so we finish that line by using slice() to get everything after the 0 th item in the array. Now we have an array of one or more things that may, or may not, be rolls... so let's sanitize them by filtering for only those that match a regular expression of what a roll marker should look like. This can happen as a new assignment back to the args object, or it can happen tagged right onto the back of the slice() from the previous step (slice() returns an array, and filter() requires an array). I'll do that, and reformat the line since line breaks won't affect it: let args = msg.content
.split(/\s+/)
.slice(1)
.filter(a => /^\$\[\[\d+]]$/.test(a)); Now one more step... if we tweak that regular expression to capture the digits between the double brackets, we can use it to pull the correct roll from the inlinerolls property. We can do that in a map operation. Again, we can chain that on the back end of filter() (since filter() returns an array and map() requires an array): let args = msg.content .split(/\s+/) .slice(1) .filter(a => /^\$\[\[\(d+)]]$/.test(a))
.map(a => msg.inlinerolls[/^\$\[\[(\d+)]]$/.exec(a)[1]]); That one is a bit of a doozy. To read/understand it, start with the regex exec-ing on a (which is our individual argument under evaluation in every iteration). Most times you'll see people use exec and assign it to an object, then test if the object is "undefined" (meaning the regex didn't match): let result = rx.exec(a);
if (result) { // there is a result, it was a good match } else { // there was no match, result is undefined } In our case, we know the regex will find a match, because we just filtered for the args that matched the same regex. We also know that the first matching group (represented by [1] ) will be the digits we are looking for. All of that is enclosed by brackets attached to the msg.inlinerolls property: msg.inlinerolls[ ... ] msg.inlinerolls is an array. We can get an n th element using [n]. We use the digits extracted by the regex to pull the correct roll, and the map operation remaps this entry in the args array to be the roll object. Make sense? Now you have an array of your inline rolls, you can do what you like with them. This bit of code will be very helpful to you in this endeavor, as inlinerolls can be nested pretty deep: args.forEach((a,i) => log(`Roll ${i}: ${JSON.stringify(a, undefined, 2)}`)); Rolls Built from Command Line Components The other way of going about getting rolls would parse command line elements to let you build your own roll, which you then pass to the Roll20 parser through a sendChat(). Before I show that method, I should point out that unless you specifically want to display the roll as an inline roll in your scripts output (ie, with a hover roll tip), you can get an array of random numbers much more easily. The Roll20 randomInteger() function is, as I understand it, also tied into the quantum roll server algorithms to produce better randomized results... so if you know how many dice and of what type, you can just call it. A quick way to get an array is by using Array(), then fill(), then map(). This will ensure an array that has independent/unique elements. To get an array of 6 items would be: let dice = Array(6); To get the slots able to accept data, however, we have to initially fill them: let dice = Array(6).fill(); You can fill with whatever you want, but supplying nothing in this case is fine (it will use "undefined"). Next we will map each entry (e) into a new random integer. We'll pretend we're looking for d10 results, so we'll use a 10 in the randomInteger() function: let dice = Array(6).fill().map(e => randomInteger(10)); OK, so imagining a command line of: !sacredgeometry --level=2 --roll1=4 --roll2=3 ...where level is your spell level and roll1 and roll2 are the two components that work together to produce the maximum number of rolls, we just have to parse our line to isolate those arguments. We'll split on whitespace-double-hyphen first: let args = msg.content.split(/\s+--/); That will give us an array of entries like: level=2 roll1=4 roll2=3 So we see we could then map() those entries into a form where we've split them at the "=": let args = msg.content.split(/\s+--/).map(a => a.split(/=/)); Now we have entries more like: [level, 2] [roll1, 4] [roll2, 3] Each item is an individual array. The first item (0 th ) is the name of the argument; the next item is the value. So now let's make sure that the names of the supplied arguments are what we're looking for... we don't need to do anything with a supplied argument that doesn't read "level", "roll1", or "roll2". We can accomplish that with a filter() that checks the 0 th item against an array of those three strings. First, though, we'll use another map operation to render the name as lowercase. Again, I'll reformat the line to add line breaks for readability: let args = msg.content .split(/\s+--/) .map(a => a.split(/\s*=\s*/))
.map(a => [a[0].toLowerCase(),a[1]]) .filter(a => [ "level", "roll1", "roll2"].includes(a[0])) ; EDIT : You'll always want to be looking for ways that a user could break what you've written. For instance, in the above, if the user supplied an argument without an equals sign, then you wouldn't end up with a 2 item array when you split on an equals sign, and the reference to a[1] would be undefined. If the user supplied text or a decimal number on the right side of the equals instead of an integer, you'll encounter an error when you try to treat that as an integer (like in a roll equation). As you think of these edge cases, you can plug the fixes into what your doing (perhaps filtering for a regex that detects properly formatted arguments prior to splitting on the equals: .filter(a => /[A-Za-z]+\s*=\s*\d+$/.test(a)) ...that would take care of both issues. At this point, you might want to consider whether you have ALL of the components you need, and/or whether you have EXTRA instances of them (ie, if the command line included two values for "level"). An easy way to manage both is to convert these [key,value] entries to properties on an object. We can do that with Object.fromEntries() . Since the object we create will have properties that must have unique names, we'll preserve only one copy of each supplied argument (the last instance). Then, once we know we have a unique set of properties, we can count them to make sure there are 3 of them: let argObj = Object.fromEntries(args); if (Object.keys(argObj).length !== 3) { // handle user notification here ... return; } If we still survive past this point in the code, we now have an argObj with three properties of our 3 required components for the roll. Maybe you want to test that the values of each of the properties is an integer... I'll leave that to you (I would do it during the maps and filters, above, before the Object.fromEntries()). But basically at this point you're ready to send your message to the sendChat callback . The idea of the callback is that instead of your message going to the chat output, it comes straight back to your code. Your callback function is like the chat handler for those specific messages... but the kicker is that it will run asynchronously. That can be a real mind-twist if you're just learning. The pitfall you have to worry about is that your code will progress up to your asynchronous sendChat() call, it will dispatch that call, and then it will continue on past the sendChat() . In other words, it will not wait for the sendChat callback to complete. For this reason, as you're just learning, I would suggest a very simple solution... when we get the return from the sendChat(), we'll pipe everything we need into another function. Here's what that would look like... I don't know how the spell level affects the rolls, so I'll leave it off for now and just use roll1 + roll2: const continueHandler = (msg, rolls) => { // code to continue processing your rolls, here }; sendChat('',`[[${roll1+roll2}d6]]`,(msgs => { let rolls = []; msgs.forEach(m => rolls = [...rolls,...m.inlinerolls]); continueHandler(msg, rolls); })); I build the command line I want to send through the sendChat() function (really, just the inline roll notation), then I capture the return as "msgs". I use the plural, here, because the callback returns an array of message objects. I use a forEach() to loop through the messages and append the inline rolls to an array object I declared (rolls). That "..." is the spread operator . The rolls variable is only block scoped, so it won't persist beyond the callback block if we just let the function finish, so while we're still in there, we'll call the continueHandler() function and pass the original message object (msg), and the rolls array we just built. Note that the callback can access the variables in the parent closure (your on('chat:message') function), so it can utilize the message object. (Also, we could have just assigned the rolls to occupy the inlinerolls property of the original message object if we'd wanted to, then passed only our message object to the continueHandler() function. These things come down to preference...) Eyes Glazed Over, Yet? I know you said you were looking for something simpler to start learning with, but by that point I had 2/3 of this post written. If it doesn't help you (at least right now), it might help you later. Or it might help someone else. The point is these are a couple of ways to connect with the inlinerolls of a message to work with the data. When it comes to crafting an output from your script (where you might want to show the inline rolls with a hover roll tip), that's where libInline can help. When you get to that point, if the documentation for that library isn't enough to get you where you need to be, start a new post and ask your questions!
