Toggleable template fields, an update on reusing rolls

Following on from the earlier toggleable template fields post: Attempting to reuse rolls in a hide-able section would prevent that section from being hidden. However this problem can be avoided by using HTML entities to partially escape any roll reference. So $[[0]] becomes $[[0]]. Reusing a roll this way doesn't interact with the rest of the roll parsing making it safe to use for our purposes here. (Note: It only works when using roll templates)

Toggleable template fields, roll controlled

Those familiar with reusing rolls know that trying to reuse a roll before it happens breaks any roll it was nested inside of. This behaviour can be used to control if a set of template fields is inside a working roll or not, since a "broken" roll won't hide the fields but a working roll will. By using a dynamic roll reference to conditionally reference a nested roll within a hide-able section. That hide-able section can then be hidden or shown based on a roll result.

A single section example

In this example 2d4 is rolled and on double one will show "Snake Eyes!" after the roll plus a "Bonus Section"

$[[$[[1]]]] [[[ [[ {0,[[2d4]]}=2*2 ]] ]]] &{template:default} {{2d4=$[[0]]}} [[[0 [[0]] {{2d4=$[[0]] Snake Eyes!}} {{Bonus Section}}]]]

A multi section example

In this example a d6 is rolled that highlights a roll of 1 and a roll of 6 with bonus d6

$[[$[[1]]]] [[[ [[ {1,6,6}=[[d6]]*2 ]] ]]] &{template:default} {{d6=$[[0]]}} [[[0 [[0]] {{d6=$[[0]] One!}} ]]] [[[0 [[0]] {{d6=$[[0]] Six!}} {{Bonus d6=$[[5]]}} ]]] [[d6 Bonus]]

You never cease to astound, Rainbow Encoder!

Collapsing rows and Bleeding CSS to next row in a template

As it's been noted, using CSS styling in a standard template can be a bit tricky, because the template uses = as a separator in the content rows. But, by some clumsy experimentation, I accidentally managed to break the rows to allow CSS to be applied to the left side of the equation (with a caveat I'll get to). Here's how:

First, we make our CSS row - this row needs not have content, though it can have some - what we care about is the end:

Putting it all together...

Ta-dah! The first row has disappeared (or more specifically, collapsed into the second, but the broken link is not displayed - if there's other content on that row, it'll replace the left side of the bottom row, either as a normal left side entry, if left of the =, or as an indented, stylable right-left - I haven't fully explored what you can do with that), and the CSS styling has been applied to the left side of the second row! Now, you'll notice the caveat I mentioned - there's a very noticeable indent on the left side of the template - the left side starts at about the same position as the right would in a normally partitioned template. However, the left side is still fully functional as a row name, meaning you can use overwrite trick to all kinds of clever effects, from hiding the name fields with a display:none; to shifting around the CSS bleed rows, to maybe even more clever things with the row-collapsing trick. Go wild!

EDIT: You can even add a tooltip to the left-side field using this trick, by placing the whole tooltip trick before the collapse trick:

Relatedly, you can daisy chain collapsed rows to turn multiple rows into files on a single row instead, like so:

Though the template dimensions can get pushed out of the right side of the chat if there's too many too wide files. If you do not hide the left elements, they appear at the end of the file to the left of its content (think of them as an index starting with 0, with 0 being the empty file at the left).

EDIT: I figured out how to solve the indent issue (or rather, how to apply the trick to the actual first row name) - it's as simple as putting the collapser at the end of the name space, like so:

The text defaults to bold in the first file, but you can use CSS styling to make it look however you like - it's content on the left side of the = on its row, so if you like, you can style every single letter differently. This also means you can make a full width text field in a template , where you can style individual segments as you wish.

TLDR; this tech 1. collapses a template row (but not the namespace) into the next row 2. applies the CSS declarations to the name (left side) of the next row and 3. allows you to place the content of a row where the name of the row would be, or vice versa, and create extra files in the row.

Thanks for breaking that long dry spell, Tuo, with a real whizbanger!

Health Bars in Chat

Given an attribute with a known maximum, such as health in most games, you can make use of reusing rolls to display them as bars, by overlaying elements with position: absolute;, anchoring the elements to the left (or right, if you prefer) side of the chat with left: 0px; and using the reused roll containing the desired value, divided by the max value and multiplied by 100, for width: %;, and the original "roll" is hidden by placing it outside template rows, like so:

(example of multiple simple green bars placed in chat one after another)

With that basic format, you can adjust the declarations to your heart's content, add new elements and variables to make more complex and fancier bars. Here's a much more complex example, featuring health bar changing color as it gets lower, and supporting multiple health bars laid on top of each other, using @{hp} character attribute, max hp defined in @{Cinematic Weight|hp} (due to the game I wrote this macro for), @{bars} and it's sheet-defined max for the bar count (accessed through some nested attribute calls, because calling max values in abilities is needlessly complicated if you want to use the exact same macro across multiple sheets without changing attribute references).

That could make for a very nice party readout for a healer character. Very impressive!

Using queries to carry variable data to a follow-up macro

Following up on building an entire macro within a chat roll button, you can have a macro print data inside a query option, and then use the property of queries to copy the input to all copies of the query to reuse that data in as many places within the second macro as you like. Here's a testable example, replicating the function of a roll table:

Here, a d100 is rolled, called early to access a plain numeric result, that result is within a query, and when that query is resolved, when the second macro is activated, that result is applied into the nested rolls across the macro. This is getting around the issue of a roll being able to be operated on only once - in the second macro, every copy of that result from the first macro can be operated on individually.

Of course, for this particular use case. a roll table is much more practical, but this is more flexible - you can print whatever you like within the query, and it'll be used just fine.

Tuo said:

Using queries to carry variable data to a follow-up macro

Following up on building an entire macro within a chat roll button, you can have a macro print data inside a query option, and then use the property of queries to copy the input to all copies of the query to reuse that data in as many places within the second macro as you like...

This is a useful technique for carrying text data across macros. For purely numerical data you can use Reusing Rolls with the caveat that any random roll has to be wrapped in another inline roll. So in your example instead of pulling the plain numeric result via $[[0]] and copying via queries you could actually just use $[[1]] wherever it's needed and skip the query. This also allows you to use the value in other rolls without problems.

That being said this can be used to overwrite queries from existing macros/abilities using earlier data. For example consider the following macro

#rollWithMod

&{template:default} {{Roll=$[[0.computed]] + $[[1.computed]] = [[ [[1d20]] + [[ [[?{Modifier|d4|d6|d8|d10|d12}]] ]] ]]}} {{=[Roll Again](` ?{Modifier|Modifier Result ($[[2]]),$[[2]]|d4|d6|d8|d10|d12} #rollWithMod)}}

When run this macro will query for a modifier of d4 to d12. Rolls 1d20 + the selected modifier showing the individual rolls and sum result. Finally showing a prompt to 'Roll Again'. When 'Roll Again' is clicked it will call the macro again but pre-empts the query and inserts a new default option of the prior modifier result allowing the user to keep the same modifier roll and just reroll the d20.

RainbowEncoder said:

This is a useful technique for carrying text data across macros. For purely numerical data you can use Reusing Rolls with the caveat that any random roll has to be wrapped in another inline roll. So in your example instead of pulling the plain numeric result via $[[0]] and copying via queries you could actually just use $[[1]] wherever it's needed and skip the query. This also allows you to use the value in other rolls without problems.

I don't see how - a roll cannot be iterated on multiple times, so if you want to compare the same roll against multiple different targets, calling the same roll index doesn't work - and the non-plain numeric results break the escaped secondary macro. The plain numeric result copied via the query isn't in the roll index, so it doesn't have the same limitations.

Tuo said:

I don't see how - a roll cannot be iterated on multiple times, so if you want to compare the same roll against multiple different targets, calling the same roll index doesn't work - and the non-plain numeric results break the escaped secondary macro. The plain numeric result copied via the query isn't in the roll index, so it doesn't have the same limitations.

You are correct in that a roll index cannot be used multiple times in a single macro and a random roll will break the escaped secondary macro. However a calculation-only roll does work, which is why you have to wrap any random roll in an additional roll making it calc-only. Specifically a calc-only roll generates HTML that gets stripped out by the sanitiser leaving only the numeric result; whereas the HTML for a random roll doesn't get correctly removed leaving a bunch of junk which is what breaks attempts to use it.

RainbowEncoder said:

You are correct in that a roll index cannot be used multiple times in a single macro and a random roll will break the escaped secondary macro. However a calculation-only roll does work, which is why you have to wrap any random roll in an additional roll making it calc-only. Specifically a calc-only roll generates HTML that gets stripped out by the sanitiser leaving only the numeric result; whereas the HTML for a random roll doesn't get correctly removed leaving a bunch of junk which is what breaks attempts to use it.

Oh, I see - that is a great tip, I'll make sure to stick it to memory, thank you!

thank you for this post!

This isn't the thread for that kind of thing - it's specifically for finished methods that people might not be aware of.

You should open a new thread asking about that.

Hello, Roll20 geniuses. Thank you all for this treasure trove! I've lost a lot of time happily poking through here, and have learned so much about r20 and slick tricks to bust out for my friends in game. :)

I hope this is okay to post in the whole thread as it's relevant to the OG index post. May I humbly request a cleanup of amazing-at-the-time tricks which may no longer be useful? I'm not sure how many that would apply to. I was checking out Robert S' trick for representing conditions with tokens. I realized, however, that there is now both a way to link to the compendium in game and a native round counting tool in the Turn Tracker (at least in the r20 D&D 5e games).

I realize that could become overly complicated with the different sheets. Perhaps a footnote/asterisk if something is still useful in some sheets/systems but not others, if that's not too unwieldy. For the noobs like me who are still learning the ins and outs of r20 itself, sheets, and macros, it would be a big time saver. To be fair, going down that rabbit hole led to others where I learned more. Thanks for considering!

ETA: I didn't mean they should be removed—only demarcated in some fashion. That could look like an archive section in the index post (clearest and lowest effort if universal), a shared footnote, or even adding a parenthetical to the title to note that some part of it is now native to the r20 5e sheet, for example.

Just some way for those of us who are still learning the intricacies to filter out what may be more or less salient for our more pressing needs. I'm sure I'm not the only one who did a deep dive into trying to understand a trick only to later realize it could have been waaayyy down on my reading list. Honestly, the "archive" subsection is more like a Best Of—the tricks so good that r20 and sheet-designers baked them in.

Thanks again to keithcurtis and everyone else for sharing your know-how and wisdom with those of us who are muddling through. :)

The index does need some love, since the last few pages have not been added. I am not likely to remove anything, since even a trick that has become obsolete may reveal techniques that could be used to solve other problems. But I'll take a look soon™.

I'm glad it's still up. I'm taking a day to review a page each week to glean ideas and up my game :)

Puzzlebook

A fun and simple little gimmick of questionable use I came up with - by using a query set in an escaped template in a button, and combining that with template overriding, you can set up a template that outputs either a custom output for wrong input, or calls a custom row matching a keyword.

Your word is [?{Keyword} ](`/w gm &{template:default} {{name=Book of Secrets}} {{=The Book reveals no secrets}} %{Puzzlebook|?{Keyword}} &{noerror})

To create the matching pages, create abilities in a sheet (here, "Puzzlebook") that the players have edit rights to but that isn't in their journal (so they can access the abilities via calls but cannot look at them on the sheet), with the desired keywords as the ability name and the content between {{= and }}.

This result in a macro that the players can take guesses at to find specific output - you could even have multiple riddles leading to one another, for instance.

i don`t know if this will help, i don't know really html or css but with reading some post and reading a bit in w3schools, i made this to alter the default template

and with the ideas of others commenters  i made a buttom with imagen &{template:default}  {{name= bottom}}  {{bottom= [Button](~Mr. Yang|chibar" style="font-size:0px; background: transparent;  width: 30%; height: 30%; border-style: none"><img src="https://i.pinimg.com/originals/c2/2c/d1/c22cd13dfcbe23a743507dfbc7caf31d.gif?v=2 ) }} this will give you something like this

and call the ability like a normal api bottom

now using a lot of stuff i made this

using this i even manage to use overflow for the text

&{template:default} {{name=[Still the Fluttering Wing](#" style=" 

  color:DarkRed;

  font-size:25px;

  font-family: Patrick hand ; 

  font-weight: bold ;

  font-style: italic ;

  text-shadow: 0px 5px 4px black; 

  text-align:center;

  line-height:44px;

  display:block; 

  margin-top: -5px;

  margin-left: -5px;

  margin-right: -5px;

  margin-bottom: -5px;

  background-color: DarkOrange;

  width: 260px;

  height: 50px;

  position: center;

  box-sizing: content-box;  

  background-repeat: no-repeat;

  background-attachment: fixed; 

  border: 5px solid blue; 

  border-color: DarkOliveGreen;

  padding: 0px;

  box-shadow: 5px 8px 4px black;

  border-radius: 0px 0px 30px 0px;

)}} {{Type= Cascade Spell}} {{Level= 1}} {{Dice Pool=[Occult+Lung Tan](` /r [[@{Mr. Yang|Occult}+@{Mr. Yang|Lung Tan}]]d10>?{DC}f1) }} {{Difficulty= target’s Willpower}} {{Effect= [Paralysis](#"  style=" 

color: auto; 

font-family: arial black;

font-size: 15px;

" class="showtip" title=" 

**Immobilized / Paralyzed**

Attacking a partly immobilized target: +2 dice

Attacking a fully immobilized or paralyzed target: minimum 1 success) until they have “burned” actions equal to the spell’s successes}} {{=[Many demons have powers granting them preternatural speed. This spell — or rather, family of spells— evens the playing field by countering such advantages.

Targets affected by Still the Fluttering Wing suffer brief paralysis and can do nothing until they have “burned” the spell’s successes by declaring an equal number of actions.

**Note** that targets cannot actually perform the actions they declare while paralyzed; such declaration serves only to represent their struggle to regain control.

 Although supernatural targets can use powers granting extra actions to end their paralysis faster (this is the only kind of action paralyzed targets can actually take), targets without such powers cannot split their dice pools to reduce the spell’s duration. 

Still the Fluttering Wing requires physical contact with the target, demanding a reflexive attack roll in combat. 

The paralysis inflicted by this spell inhibits voluntary action only. It cannot stop a living target’s heart or otherwise cause any injury. 

Paralyzed targets also retain full use of their senses, though their eyes remain locked in the direction they faced when the spell took effect. 

Each version of this spell generates near-identical results differentiated only by power, since the caster cannot spend more successes on canceling actions than the spell’s level. Lifeforce cost equals half the spell’s level (rounded down) plus one if the caster chooses to project the spell at range. Still the Fluttering Heart can be learned for any level of Lung Tan](~Mr. Yang|chibar#" style=" 

color: auto;

width: auto;

  height: 100px;

  border: 1px solid;

  overflow: auto;

margin-left: -73px;

text-align: center;

background: transparent; style="font-size:0px;"><img src="https://i.pinimg.com/originals/c2/2c/d1/c22cd13dfcbe23a743507dfbc7caf31d.gif?v=2;  " class="showtip" title= [ ](#" style=" background-color: transparent;  padding: 10px 0px 10px; margin-top: -18px; display: block; width: 15%;  position: absolute; bottom: 10px; left: 60px)[Chi @{selected|bar1} / @{selected|bar1|max}](#" style=" cursor: default; text-decoration: none; color: white; background-color: darkgreen; opacity: 0.5; padding: 5px 5px 3px 5px; margin-top: -8px; display: block; width: auto;  position: absolute; bottom:30px; left: 50px; z-index: 4 )[ ](#" style=" background-color: green;  padding: 10px 0px 10px; margin-top: -5px; display: block; width: $[[0]]%;  position: absolute; bottom: 20px; left: 50px)}} [[ [[ @{chi}*10]] ]]  class="showtip" title=)}} {{[ ](#)= Equals half the spell’s level (rounded down) plus one if the caster chooses to project the spell at range  

}}

Kuro, though you can't style non-link/button elements with that, you can make them not appear as a button by giving it the cursor:default or cursor:text and text-decoration:none properties.

[D&D 5e 2014] Modifier mass toggle via token bar

Just a tiny little trick with the 2014 sheet - if you link one of the global modifier flag fields (global_X_mod_flag) to a token bar, you can with a single change of 1 to 0 toggle off every modifier in that category without having to open the character sheet, and by reversing it, enable every checked on modifier. Could be useful if you have a bunch of discrete modifiers that you want to turn off all at once (or if you get frustrated with the current bug with sheetworkers - changing the value gets around the bug and disables/enables modifiers reliably).

That's brilliant!

Here's a technique I figured out while thinking of a macro for magic missile -

Recursive Roll Index Storage

To put it simply (as simple as anything related to roll indexes can be, anyway), when you place a roll index call into a button, you can then place that index call into an inline roll to produce an inline roll when the button roll is parsed - which can then be referenced by an index call. With some clever arrangement, you can use this to create an array that records numeric values from multiple follow-up macros, with values being pushed along the array as new numbers are added. Here's an example to play around with - a self-referencing recursive ability call that stores 1d10 rolls:

storage

&{template:default} {{[storage](`/w gm {{[[$[[1]]]] [[$[[2]]]][[$[[3]]]][[$[[4]]]][[$[[5]]]] }} %{@{character_name}|storage})[[[[1d10]]]]}} [[0]] [[0]] [[0]] [[0]]

There are a few quirks to this - you'll notice the first roll result gets placed in the left-most position before being pushed out, and all subsequent rolls are added to the right side. The zeroes at the end are needed to pad out the index - the inline rolls crash the macro if their content is an index reference to an invalid inline roll.

Tuo said:

Here's a technique I figured out while thinking of a macro for magic missile -

Recursive Roll Index Storage

...

There are a few quirks to this - you'll notice the first roll result gets placed in the left-most position before being pushed out, and all subsequent rolls are added to the right side. The zeroes at the end are needed to pad out the index - the inline rolls crash the macro if their content is an index reference to an invalid inline roll.

Single ability recursion is always hampered the fact that the roll structure changes; my go-to for recursion is to use a startup ability that basically just has the contents of the ability button (but unencoded). Using one here would fix the first roll getting pushed out.

storage-startup

/w gm {{[[0]][[0]][[0]][[0]][[0]]}} %{@{character_name}|storage}

It also has the benefit that those extra zeroes at the end of the main ability are no longer required (Although they cause no harm here). Having a startup ability is doubly useful if you want your initial values to be the result of queries since you can then avoid having to reprompt on every loop.

RainbowEncoder said:

Single ability recursion is always hampered the fact that the roll structure changes; my go-to for recursion is to use a startup ability that basically just has the contents of the ability button (but unencoded). Using one here would fix the first roll getting pushed out.

storage-startup

/w gm {{[[0]][[0]][[0]][[0]][[0]]}} %{@{character_name}|storage}

It also has the benefit that those extra zeroes at the end of the main ability are no longer required (Although they cause no harm here). Having a startup ability is doubly useful if you want your initial values to be the result of queries since you can then avoid having to reprompt on every loop.

That's a great addition, and in line with what I plan on further doing with this technique - the practical use case I see here is using it to track choices made in a macro with variable number of steps (specifically how many magic missiles are aimed at a given target) and then at the final step using those numbers in rolls - though it'll be a hot mess of queries, abilities and reused rolls. But for now, this proof of concept is enough.

A little inline quirk I accidentally found while testing other stuff - you can put a part of the content of link in front of the link label - including inline rolls, without stripping them down.

[ ](#"title=>[[1d20]]<coconut=)

This puts the 1d20 inline roll as the link label, but it is still an inline roll, which is normally impossible. I tried to find a way to apply style properties to it, but I've had no luck so far. Still, this could have some utility.

Infinite Multi-Attack Macro

I thought I'd share a macro I made for multi-attacks. It prompts for the number of attacks, the attack roll with options for d20 + Mod including advantage/disadvantage or a custom roll ( in the format XdYkhAdhB + C), and the damage roll (in the format XdY + C). It will then show upto 5 attacks at a time with thier respective damage rolls and a continue button if there are more attacks. Continuing works without any query reprompts.

The macro itself is in two parts to be stored on a character as an ability.

multi-attack-start - This is the main ability to be used

%{@{character_id}|multi-attack-continue} {{name=

PTTF Index	[[[ [[13-{6, ?{Number of Attacks|2} }kl1 ]] ]]]

Start Atk°	[[[1]]]
Atk°2		[[[2]]]
Atk°3		[[[3]]]
Atk°4		[[[4]]]
End Atk°	[[[ {?{Number of Attacks},+5}kl1 ]]]

PTTF Deferrer	[[[-1]]]
Index Corrector	[[[ [[ [[ [[ [[ [[ [[9]] ]] ]] ]] ]] ]] ]]]
Total Attacks	[[?{Number of Attacks|2} Total Attacks]]
Remaining Atks	[[{0,?{Number of Attacks|2}-5}k1 Remaining Attacks]]

Attack Roll Query	?{Attack Roll|
d20, [[1]]d[[20]]kh[[1]]dh[[0]]
	[[d20+?{Attack Mod|0}]]
	[[d20+?{Attack Mod}]]
	[[d20+?{Attack Mod}]]
	[[d20+?{Attack Mod}]]
	[[d20+?{Attack Mod}]]|
d20 w/Advantage, [[2]]d[[20]]kh[[1]]dh[[0]]
	[[2d20k1+?{Attack Mod|0}]]
	[[2d20k1+?{Attack Mod}]]
	[[2d20k1+?{Attack Mod}]]
	[[2d20k1+?{Attack Mod}]]
	[[2d20k1+?{Attack Mod}]]|
d20 w/Disadvantage, [[2]]d[[20]]kh[[2]]dh[[1]]
	[[2d20dh1+?{Attack Mod|0}]]
	[[2d20dh1+?{Attack Mod}]]
	[[2d20dh1+?{Attack Mod}]]
	[[2d20dh1+?{Attack Mod}]]
	[[2d20dh1+?{Attack Mod}]]|
Custom, [[?{Dice Count|1}]]d[[?{Die Size|20}]]kh[[?{Keep High|1}]]dh[[?{Drop High|0}]]
	[[?{Dice Count}d?{Die Size}kh?{Keep High}dh?{Drop High}+?{Attack Mod|0}]]
	[[?{Dice Count}d?{Die Size}kh?{Keep High}dh?{Drop High}+?{Attack Mod}]]
	[[?{Dice Count}d?{Die Size}kh?{Keep High}dh?{Drop High}+?{Attack Mod}]]
	[[?{Dice Count}d?{Die Size}kh?{Keep High}dh?{Drop High}+?{Attack Mod}]]
	[[?{Dice Count}d?{Die Size}kh?{Keep High}dh?{Drop High}+?{Attack Mod}]]}

Atk Mod	[[?{Attack Mod}]]

Dmg Die°	[[?{Damage Dice Count|1}]]
Dmg Die Size	[[?{Damage Die Size|6}]]
Dmg1	[[?{Damage Dice Count}d?{Damage Die Size} + ?{Damage Mod|0}]]
Dmg2	[[?{Damage Dice Count}d?{Damage Die Size} + ?{Damage Mod}]]
Dmg3	[[?{Damage Dice Count}d?{Damage Die Size} + ?{Damage Mod}]]
Dmg4	[[?{Damage Dice Count}d?{Damage Die Size} + ?{Damage Mod}]]
Dmg5	[[?{Damage Dice Count}d?{Damage Die Size} + ?{Damage Mod}]]
Dmg Mod	[[?{Damage Mod}]]

}} {{name=Multi-Attack}}

multi-attack-continue - This is the backbone and not used directly

&{template:default} {{name= $[[$[[0]]]] 
}} {{Attacks=$[[1.computed]] **to** $[[5.computed]][_](" null=)}} {{[0.2](" hidden)=**of** $[[15]]
}} {{Attack=**Roll**[_](" null=)}} {{[1.2](" hidden)=**Damage**
}} [[[1 {{#$[[1]]=$[[21]][_](" null=)}} {{[2.2](" hidden)=$[[29]]
}} [[2 {{#$[[2]]=$[[22]][_](" null=)}} {{[3.2](" hidden)=$[[30]]
}} [[3 {{#$[[3]]=$[[23]][_](" null=)}} {{[4.2](" hidden)=$[[31]]
}} [[4 {{#$[[4]]=$[[24]][_](" null=)}} {{[5.2](" hidden)=$[[32]]
}} [[5 {{#$[[5]]=$[[25]][_](" null=)}} {{[6.2](" hidden)=$[[33]]
}} [[6 {{$[[16]]=**Remaining**[_](" null=)}} {{[7.2](" hidden)=[Continue](!/
%{@{character_id}|multi-attack-continue} {{name=

PTTF Index	[[[ [[13-{6, $[[16]]}kl1]] ]]]
Start Atk°	[[[ $[[5]] +1 ]]]
Atk°2		[[[ $[[5]] +2 ]]]
Atk°3		[[[ $[[5]] +3 ]]]
Atk°4		[[[ $[[5]] +4 ]]]
End Atk°	[[[ {$[[15]],$[[5]]+5}kl1 ]]]

PTTF Deferrer	[[[-1]]]
Index Corrector	[[[ [[ [[ [[ [[ [[ [[ 9 ]] ]] ]] ]] ]] ]] ]]]

Total Attacks	[[ $[[15]] Total Attacks]]
Remaining Atks	[[ {0,$[[16]]-5}k1 Remaining Attacks]]

Atk Die°	[[ $[[17]] ]]
Atk Die Size	[[ $[[18]] ]]
Atk KH	[[ $[[19]] ]]
Atk DH	[[ $[[20]] ]]
Atk1	[[ $[[17]]d$[[18]]kh$[[19]]dh$[[20]] + $[[26]] ]]
Atk2	[[ $[[17]]d$[[18]]kh$[[19]]dh$[[20]] + $[[26]] ]]
Atk3	[[ $[[17]]d$[[18]]kh$[[19]]dh$[[20]] + $[[26]] ]]
Atk4	[[ $[[17]]d$[[18]]kh$[[19]]dh$[[20]] + $[[26]] ]]
Atk5	[[ $[[17]]d$[[18]]kh$[[19]]dh$[[20]] + $[[26]] ]]
Atk Mod	[[ $[[26]] ]]

Dmg Die°	[[ $[[27]] ]]
Dmg Die Size	[[ $[[28]] ]]
Dmg1	[[ $[[27]]d$[[28]] + $[[34]] ]]
Dmg2	[[ $[[27]]d$[[28]] + $[[34]] ]]
Dmg3	[[ $[[27]]d$[[28]] + $[[34]] ]]
Dmg4	[[ $[[27]]d$[[28]] + $[[34]] ]]
Dmg5	[[ $[[27]]d$[[28]] + $[[34]] ]]
Dmg Mod	[[ $[[34]] ]]

}} {{name=Multi-Attack}} )}} [[ $[[6]] ]] ]] ]] ]] ]] ]] ]]] $[[14]] 

It primarily relys on three tricks

A new progressive variant of Toggleable template fields to show the correct number of attacks and continue button

Recursive storage to remember the query answers whilst continuing

This is incredible work, Rainbow! And I picked out you have a very clever way of calling follow-up templates without having to use /w  or /ooc in

!/
%{@{character_id}|multi-attack-continue}

- that's a big annoyance I've had for a while that you've solved there.

Styling inline rolls as links without stripping them

I tinkered some more with the title class, and figured out you can use tooltips to have a later link inherit properties from the former, which will not be shown (this is closely related to my row collapsing trick). Following this, I started testing stuff out - here's the results:

An intact inline roll, that is also a link, styled with custom color, font size, font, text shadow, and tooltip. Here's the macro for this example:

[main part](#" style=" color: white; text-shadow: 2px 2px black, -1px 0 black, 0 1px black, 1px 0 black, 0 -1px black; font-size: 20px; font-family: cursive; class="showtip" title=cucumber class="showtip" title=) [](#"title>[[1d20]][sanitizer](#" hidden)

The main part contains all the content (so if you want it to do something on click, place that in the main part) and properties of the link, and the empty `class="showtip" title=` passes those on to the following link - where the title class places its content as the label. Finally, a third sanitizer link makes sure everything closes nicely (a closing parenthesis on the title link doesn't quite work right in this setup, hence a forced closing with the sanitizer).

With no style properties set:

[main part](#" class="showtip" title=tooltip class="showtip" title=) [](#"title>link label[sanitizer](#" hidden)

Tuo said:

Styling inline rolls as links without stripping them

...

Playing around with this it seems any HTML attribute will do to connect the links to each other. So you can avoid having a messy tooltip or title. Your first example can be rewritten as

[main part](#" style=" color: white; text-shadow: 2px 2px black, -1px 0 black, 0 1px black, 1px 0 black, 0 -1px black; font-size: 20px; font-family: cursive;" null=) [](">[[1d20]][sanitizer](" hidden)

The class and title from the first link are replaced by "null=", nor is title required in the second link.

RainbowEncoder said:

Playing around with this it seems any HTML attribute will do to connect the links to each other. So you can avoid having a messy tooltip or title. Your first example can be rewritten as

[main part](#" style=" color: white; text-shadow: 2px 2px black, -1px 0 black, 0 1px black, 1px 0 black, 0 -1px black; font-size: 20px; font-family: cursive;" null=) [](">[[1d20]][sanitizer](" hidden)

The class and title from the first link are replaced by "null=", nor is title required in the second link.

I managed to squish out the second link entirely (though it might be still a useful technique):

[ ](#" style=" color: white; text-shadow: 2px 2px black, -1px 0 black, 0 1px black, 1px 0 black, 0 -1px black; font-size: 20px; font-family: cursive; ">[[1d20]]</null)

Maxwell said:

Ive built a macro as a character sheet ability and tried to use css styling to change from the pink buttons to a link style appearance. It works fine, other than the first button item instead displays the css code.

This is the wrong thread to ask for help.  This thread is for posting completed tips and tricks for others to use in their games. You should create a new thread for your question. 

Also, when you create your new thread, if you need to, you can provide a link back to the original trick so people have the reference.

EDIT:  I am no expert (beginner as of 2 weeks ago) with any of this webm and codec stuff so greater minds than mine may be able to come up with improvements.  Ok the below guide does work BUT, every 2-4 seconds the image blurs for a couple of seconds then snaps back to clear before repeating the blurry cycle.  I have downloaded the webm from roll 20 and it does the same locally so whatever re-encoding post processing they do is messing up the file.  I have also got this guide to work with mp4 files but they do the same blurring.  I am sticking with webm as they are smaller.  As a group we are ok with it but would prefer sharper images. 
Metadata comparison of "My" webm vs download of roll20 webm (med.webm) shows roll20 uses a different codec and uses "alpha_mode : 1"

So I have been experimenting with animated maps and I think I have managed to find the sweet spot of how to get it working 100% of the time using Handbrake.  I only have Mac so can only comment on my own experience doing all of this on a mac.  All  was done using a Jumpgate game.  It isn't perfect quality but it is really quite good any so far my players have liked it.

The secret is to encode using the VP8 video encoder (VP9 fails to encode on the Roll20 side), remove the audio tracks, chapters and where you can cut the file to the minimum amount of seconds, lower the better.  Whatever the size it will take some time to upload BUT it will upload.  Check your web browser console if you have any issues, errors will be in there.  

I use the preset Web -> Creator 720p60 and then tweak it as seen below.

Errors will appear here (This is a good upload and will 100% work):

Just a reminder, it is not connection speed that takes the time it is post processing server side.  I have not had a file under 20mb (the maximum filesize for Roll20) take longer than 30 minutes.  Be patient, leave it to do its thing and don't do any other Roll20-ing and it will work.

Hope this is of use to people and Credit for the map goes to DynamicDungeons on Patreon who I am a CG subscriber of.  They create AWSOME maps!

DMD

DM Donkey said:

The secret is to encode using the VP8 video encoder (VP9 fails to encode on the Roll20 side), remove the audio tracks, chapters and where you can cut the file to the minimum amount of seconds, lower the better.  Whatever the size it will take some time to upload BUT it will upload.  Check your web browser console if you have any issues, errors will be in there.  I use the preset Web -> Creator 720p60 and then tweak it as seen below.

Thank you DM Donkey!  This is very helpful.

There may be even better settings to use, if you find them let me know as I spent a lot of time on it but gave up when I got it to a point I was happy with if I am honest

Thanks DM Donkey!

That is very helpful, since there aren't a lot of guides for this. If you refine your technique, please update your original post.

Someone cleverer may have already made something better than this, but I recently wrote a little macro I use for terrain effects (especially those usable by PCs). These are best-suited to a game like D&D 4e/5e, but I'm sure it could be applied to anything with a battlemap.

Macro

&{template:default} {{name=@{selected|token_name}}} {{Action= @{selected|bar1}}} {{Skill Check=@{selected|bar1|max}}} {{Effect=@{selected|bar2}}}
@{selected|bar3|max}

Essentially, you plop a token on the battlemap, then edit its various bars to populate the associated macro.

As an example:

• Token Name: Residuum Crystal
• Bar 1: Shatter
• Bar 1 Max: DC 13 Athletics
• Bar 2: Close blast 2: All creatures take [[2d10+3]] slashing damage.
• Bar 3 Max: /fx glow-water @{selected|token_id} @{selected|token_id}

Hi Kyle!

You might find also more useful tidbits there:

Invisible Tokens - The Notes Token -keithcurtis — (Video by Nick O)
Invisible Tokens - The Notes Token (API version) - keithcurtis

FFG Warhammer style dice resolution (with reversible digits)

In Fantasy Flights Games Warhammer line of games, checks are resolved with a 1d100 roll against a target, with every full 10 under/over the target giving an additional degree of success/failure. As part of a larger project, I wrote this snippet to resolve that cleanly:

[[ceil([[ [[ceil([[ [[?{target}+?{modifier|0}-[[ [[ [[1d10]] ]]*10+[[ [[1d10]] ]]-10]] ]]d1/10+0.01]])*-1]]d1/10+0.01]])*-1]]

This uses parser halting to round a number conditionally up or down, depending on whether it's positive or not, and contains the simulated d100 roll with reversible digits, as follows:

&{template:default} {{name= Warhammer style roll
}} {{Target=?{target|50} + ?{modifier|0}
}} {{Roll= $[[4.computed]] 
}} {{Degrees of success/failure=[[ceil([[ [[ceil([[ [[?{target}+?{modifier|0}-[[ [[ [[1d10]] ]]*10+[[ [[1d10]] ]]-10]] ]]d1/10+0.01]])*-1]]d1/10+0.01]])*-1]]
}} {{=[reverse](!/
[[$[[3.computed]]*10+$[[1.computed]]-1-{0,$[[3]]}>10*99]])}}

For Jumpgate D&D 2024 Character Sheets: Under the Advanced Tools tab of the player character sheet, a player or a DM can create a macro. When I click on the macro shortcut as a DM, it is visible to all.   However, when the player clicks on the macro shortcut it is visible only to them.  How can this be adjusted so that the player can click on the macro shortcut and have it visible to all via the chat?  

Mr. DM said:

For Jumpgate D&D 2024 Character Sheets: Under the Advanced Tools tab of the player character sheet, a player or a DM can create a macro. When I click on the macro shortcut as a DM, it is visible to all.   However, when the player clicks on the macro shortcut it is visible only to them.  How can this be adjusted so that the player can click on the macro shortcut and have it visible to all via the chat?  

This thread is for sharing finished tricks that use the Roll20 interface in a creative or novel way. Instead you should create a new post for your question in the "Specific Use Questions and Macros" forum.

Thanks Jarren. I have created a new thread as suggested.

In the interest of this thread, this is one of the player macros that I added.  It rolls the player's Navigator Tool check from a shortcut rather than from their glitchy Jumpgate character sheet.  

I have several of these types of macros.  Unfortunately, only the player can see it.

Jarren said:

Mr. DM said:

For Jumpgate D&D 2024 Character Sheets: Under the Advanced Tools tab of the player character sheet, a player or a DM can create a macro. When I click on the macro shortcut as a DM, it is visible to all.   However, when the player clicks on the macro shortcut it is visible only to them.  How can this be adjusted so that the player can click on the macro shortcut and have it visible to all via the chat?  

This thread is for sharing finished tricks that use the Roll20 interface in a creative or novel way. Instead you should create a new post for your question in the "Specific Use Questions and Macros" forum.

Inverse Overwrite

Or how to show a single template row and hide many with a single determiner

As I was up to my usual, playing around with template overwriting and CSS bleed, I figured out a neat trick to solve a particular problem with un-tabled random tables in templates, that is, being unable to determine a row to display based on a single die roll (or other inline roll based determiner). Though I have ways around that, they are clumsy and not always applicable, and tend to cause a lot of roll lag due to the amount of rolls required. But, I figured, if I can use collapsers to hide entire rows, then I can use template overwriting to show the row below the overwritten row. Here's an example:

&{template:default} {{name=Inverse Overwrite [collapser](#" hidden null=)
}} {{[0]=[collapser](#" hidden null=)
}} {{[1]=Result 1, $[[0.computed]] [collapser](#" hidden null=)
}} {{[2]=Result 2, $[[0.computed]] [collapser](#" hidden null=)
}} {{[3]=Result 3, $[[0.computed]] [collapser](#" hidden null=)
}} {{[4]=Result 4, $[[0.computed]] [collapser](#" hidden null=)
}} {{[5]=Result 5, $[[0.computed]] [collapser](#" hidden null=)
}} {{[6]=Result 6, $[[0.computed]] [collapser](#" hidden null=)
}} {{[[[ [[1d6]]-1[determiner] ]]]=[neutralizer](#)}}

(Brackets filled for explanation) Each collapser, due to the open inline CSS, will hide everything between it and the next link - here, they're daisy chained to hide every row, as where one ends, another starts. But, the 1d6-1 roll replaces one of the rows, breaking the chain, and the row below that one will display, as the collapser is terminated at the neutralizer. A single die is rolled, and one of 6 text results is shown. As long as the determiner matches one of the rows, the row directly below it will be displayed, and this will work with very large lists too, where splitting dice becomes inconvenient and slow.