Character Vault
Any Concept / Any System
Your System Come To Life
Roll20 for Android
Streamlined for your Tablet
Roll20 for iPad
Streamlined for your Tablet

Personal tools

Sheetworker examples for Non-programmers

From Roll20 Wiki

Jump to: navigation, search

While the majority of Roll20's character sheets are written using only HTML and CSS, sheetworker scripts(javascript) are often necessary to either simplify complicated HTML or add more advanced functionality to a character sheet. For those of us "non-programmers", the examples given on the Sheet Worker Scripts page may be less than exhaustive. This page was created to help better explain how to use sheetworker scripts in your character sheets.

This page may or may not contain specific examples of sheet worker code, however the information provided is invaluable to learning how to implement sheet workers into your character sheet.


Understanding sheet workers.

(credit: Jakob)

Usually, the best way to learn something is to do it! Start solving the problems you want to solve using sheet workers, and learn along the way :).

Now, that probably wasn't very helpful. I could also encourage you to look at code others have written, which you should do; just realize that many sheet authors are also amateurs (such as me), hence the code may not be the most elegantly-written example.

That probably also wasn't helpful. Let me try something else: depending on what your course taught you, much of it (everything dealing with manipulation of the DOM) is not going to be very helpful. Here's some important things you need to keep in mind that might make sheet workers different from what you've learned:

1. Sheet workers are event-driven. Everything interesting your workers do will happen in response to a certain event on the sheet; most of the time, the triggering event will be changing an attribute on the sheet (i.e., the value of some input, be it a checkbox, radio, text, number input, or textarea). This is what the on("change:attr", function () { ...}) is there for: it's about registering a function that's supposed to be executed every time attr changes.
2. Sheet workers can only really do one thing. Sheet workers can change the value of attributes, and that's pretty much it (they can also remove repeating rows, but that's not their main use). If you want your sheet workers to do a thing, ask yourself if it can be accomplished by changing the value of an attribute (this includes being able to (un)check checkboxes), +perhaps some CSS. If yes, you can do it with sheet workers. If not, you cannot.
3. Sheet workers are asynchronous. The main interesting functions you have access to in sheet workers, namely getAttrs, setAttrs, and getSectionIDs, take as their second argument functions that do other stuff. This means that you cannot trust that your code will simply be executed from top to bottom, and have to write in such a way that it makes sense no matter when asynchronous functions are executed. This is often a source of confusion for people.

Good Practices

(credit: GiGs)

  • I think it's a good idea (especially when still learning) to get into the habit of putting all the values you are using in variables at the top of the code. It makes writing the code a bit more laborious, but if you reuse values, or have long macros, it can make things clearer, and most importantly, you can then use console.log statements to check what their values are. (they will appear in the browser's dev console, which you can usually find by pressing f12).
  • Another tip is its a good idea to just use a single setAttrs statement, at the end of the sheet worker. For this one which is just modifying a single attribute, it doesn't matter, but you'll eventually get into making workers that set multiple attributes. when that happens, you definitely want to group them into a single statement, to avoid unpredictable errors.
  • Also its a good idea to use variable names that match the value they are calling. In the code below, for example, i renamed index to currenthp, which I think is more descriptive.
  • It's also a good idea to use lower case only for attribute names, and use underscores instead of dashes or otehr symbols in the name. For example, avoid strength-mod, use strengthmod or strength_mod instead.
  • One final tip: if you are using parseInt on cells that users can enter values into, it's a good idea to add a default value. For instance parseInt('something')|||0 means that if the cell contains text, or not a number, you'll get a number in the code. Your if statements will fail without this, if the cells being called don't actually have numbers in them.

Autocalc Fields and Sheet Workers

(credit: GiGs) A common pitfall is to try to combine autocalc fields and sheet workers. Try not to do this.

First, autocalc fields need to be set as disabled, and sheet workers cannot edit a disabled input. If you want to use a sheetworker to create a value that is displayed but cant be edited, set the input to readonly. this looks the same as disabled, and cant be edited, but sheetworkers can update it.

Second, don't try to grab autocalc fields in a sheet worker. The getAttrs function in a sheet worker will grab the text of an autocalc field, not the number it resolves to. If the attribute is something like "[[@{STR} + @{DEX}]]" then getAttrs will give you a value of "[@{STR} + @{DEX}]]" and not 23 or 30 or whatever number you are expecting.

So, you need to recreate that formula in the sheet worker anyway, by using getAttrs to grab STR and DEX values, and then adding them together within the worker. Alternatively, replace the initial autocalc field with a sheet worker.

Because of these two facts, once you start using sheet workers, you tend to abandon autocalc fields. They dont interact well. You can still use autocalcs for standalone attributes that dont affect anything else, but sheet workers for everything else.

Sheet Worker Tutorial

(credit: GiGs)

All Sheet Workers have a common structure, four steps that must happen in order:

  1. Event Trigger
  2. Get Attributes
  3. Do the Work
  4. Update the Character Sheet

Event Trigger

Sheet Workers are triggered by something changing on the character sheet. Triggers are covered fully; on this page we will mainly be looking at the change event. Imagine we have a game where characters have a Hit Point attribute, that is calculated by adding two stats, SIZ and CON together. let's build a sheet worker to calculate that.

First we need to build the trigger:

on("change:siz change:con sheet:opened", function() {  


That's pretty straightforward. Notice that the attribute names are lower case. Confusingly, attributes must always be in lower case when on the event trigger line, but as you'll see, must be in their original case everywhere else. You can have as many change:attribute_name statements as you need for the script.

Note: sheet:opened tells the worker to run every time the character sheet is opened. This is optional, but is handy to keep a sheet properly updated.

Get Attributes

So an attribute changes, and its sheet worker is triggered. Now, you must collect the value of all needed attributes. The sheet worker does not automatically know anything about the rest of the character sheet: each sheet worker only knows what data you collect for it.

This is where the getAttrs function comes in.

getAttrs(["SIZ","CON"], function(values) {
        let siz = values.SIZ;
        let con = values.CON;


getAttrs has two steps: the first line, the function line, is where you grab the attributes. They are stored in an data object, whose name is defined after the word function. In this case, values. You can call it whatever you want, most people use values, or just v.

This object is a Javascript Object, and you can read up on that elsewhere. But all you really need to know is, it contains the names and values of the attributes you declared - in this case, SIZ and CON.

Since this object was named values, you get SIZ by using values.SIZ, and con by using values.CON. And that's exactly what we do above - we define two variables, one for each attribute, and assign the values of those attributes.

There is a complication. If you doing math with the stats, you need to convert them into a number. If you don't, you can get an error. There are several ways to do this, a common one is to use parseInt (for whole numbers) or parseFloat (for fractional or decimal numbers). Here's what that looks like:

getAttrs(["SIZ","CON"], function(values) {
        let siz = parseINT(values.SIZ,10)||0;
        let con = parseINT(values.CON,10)||0;


That looks a lot more complicated, but don't worry, you dont need to understand it. Just copy it. For the record, the end bit ||0 sets a default of 0. So if the SIZ attribute contains nothing, or text, it will be treated as a value of 0 and an error is avoided.

Do The Work

Each Sheet Worker is designed to do something. Sometimes that will be very complicated, other times like this one it will be very simple. We are just adding two stats, so that looks like this:

let hp = siz + con

I did say it was simple.

Update the Character Sheet

Now we have the hit point total, we need to actually save it to the character sheet. For that we need the setAttrs function. Assuming the attribute is called hit_points, that would look like this:

     hitpoints: hp

Note: some sheet workers will update multiple attributes. You seperate them with commas. That would look like this:

     hitpoints: hp,
     anotherstat: anotherscore

The final attribute must not have a comma - that breaks the script.

5. Putting It Together

So we now have all the steps needed to put the worker together.

on("change:siz change:con sheet:opened", function() {  
	getAttrs(["SIZ","CON"], function(values) {
		let siz = parseINT(values.SIZ,10)||0;
		let con = parseINT(values.CON,10)||0;
		let hp = siz + con;
			hitpoints: hp

Finishing Thoughts

This is a very simple example, but steps 1, 2, and 4, are basically the same in all sheet workers. Once you understand the basic structure, you can easily copy those, and just do the working (section 3). The Sheet Worker Snippets will contain more examples for you to copy.

See Also