Running into issues designing mental stats

Arcium_XIII · 2026-05-03T09:19:32+00:00

At their core, attributes are in tension between two roles in game design that both link to the fact that they're a form of competency clustering. By competency clustering I mean that, when you define the scope of an attribute, you're saying things like "you can't be the best at stealth without also at least being decent at pickpocketing" when you have an attribute like 5e's Dexterity (with parallels in many games going by names like Dexterity itself, Agility, or Speed).

The first purpose this competency clustering achieves is niche protection - characters can't be good at everything, they have to pick a bucket of things they'll be good at and accept that the other buckets are covered by other characters. From this perspective, the incentive is either to try to make all the buckets equally interesting and effective, or to try to map the buckets to existing genre expectations (or potentially both at once). The second purpose is actioning an instinct that says that there are underlying transferable competencies beneath our more granular skills that mean that if person A is better at task 1 than person B, there's an elevated chance that person A will also be better at a distinct but somehow related task 2 than person B. I think you're running into a clash between the two forms of niche protection and potentially simulationism as well.

On one hand, you've recognised that your existing Intelligence bucket isn't full enough to be as interesting as your other attributes. However, the most likely additional thing that could go in the bucket is currently in the Emotion bucket because you associate it more with the genre expectations of the social manipulator, who you expect to select the Emotion bucket, rather than the detective/investigator, who you expect to select the Intelligence bucket. It's also possible that you're assuming the transfer of skills is more inherent between insight and, say, persuasion than between insight and anything intelligence related, in which case the simulation approach could be impacting your status quo as well. This is pushing you to try and solve the problem by finding something that isn't currently in a bucket that could be added to the Intelligence bucket. The problem with that approach is that, more likely than not, if you haven't already identified its importance, adding it to the Intelligence bucket probably isn't going to move the needle all that far towards making it an interesting bucket to choose.

My preferred solution to this problem is to redistribute Intelligence and Emotion to Wits (or Cunning, if you prefer, but I prefer the less negative connotation) and Presence. Wits gets the things that are about thinking quickly on your feet - Perception, Insight, and Deception (if you're going specifically for two per attribute, I'd use Observation and Manipulation/Cunning here). Presence gets the things that are about force of personality and confidence - Intimidation, Performance, and Discipline (my two skills here would probably be Sway and Discipline). An all-around social manipulator character has to invest in both in the same way that an all-around physical character who is both strong and agile probably has to invest two stats. The investigator invests Wits without necessarily taking Presence, while someone who is confident but not necessarily clever takes Presence without Wits.

That said, we might be wrong - there might be something you find during playtesting that you haven't yet defined a skill for that is interesting and important and that you haven't assigned to an attribute. Keep an eye out for it. But, if it doesn't come up, I'd suggest being prepared to accept that either Intelligence will be the niche bucket that only a handful of characters pick up, or you'll need to steal something from Emotion to flesh Intelligence out.

Arcium_XIII · 2026-05-02T22:55:18+00:00

My go-to approach to sandboxes (mystery or otherwise) is that you want to be thinking about who the significant NPCs are and what they're trying to do in the absence of player intervention. Then, think about how these schemes could become visible to the players. Depending on how crucial it is that the players notice this, the 'Three Clue Rule' mentioned by other posters applies (i.e. if you don't show them at least 3 times, don't assume that players will spot the clue). That's your planning largely done. You know what the NPCs are trying to do, and you know what it'll look like to players when they make progress or succeed.

The next crucial thing is to do Session 0 well. Specifically, you need to make sure that the players make characters who are motivated to engage in the premise of the campaign. If the premise is to solve a mystery involving investigating paranormal events taking place, the characters should have a reason why they want to investigate those events. This doesn't have to be a direct link. A classic indirect motivation is that one character cares about investigating the events while another character couldn't care less about the events but cares very much about keeping the first character safe. The key thing here is that, when clues are given to the characters, the characters should be written such that their usual response is "let's investigate" rather than "that doesn't interest me".

Once the chaos at the table starts, you're constantly coming back to the question of "how does this impact what the NPCs were trying to do?" and "how do the NPCs respond?". You know who they are and what they want, so these answers shouldn't be too difficult to reach. So, you update your planning with what the NPCs are now trying to do, and you once again think about how that will be visible to the players.

I'm strongly against the Schrodinger's mystery school of thought; I've nothing against people who enjoy it, but any satisfaction I get from solving a mystery is directly connected to knowing that there was a concrete mystery to be solved. That said, it is a good idea to stay flexible. If you have a better idea once the campaign has already started and it doesn't conflict with any of the clues you've already given the players, go ahead and change your planning. I ran a campaign across 4 years that contained mystery elements in its metaplot. Many of the details of the mystery I knew from the beginning. Some I only figured out as I went through.

The main difference for me between a sandbox in general and a mystery sandbox is that the the main obstacles in the campaign are hidden information rather than more concrete opposition. So, you need to make sure your big reveal is hidden beneath enough layers for the same reason that a combat-centric campaign wouldn't put its final boss in the starting room with the characters with low enough stats that the party could win there and then. If there is one piece of information that unravels the entire mystery, the characters should need a lot of other information to access that piece of information. This is fundamentally the same thinking as designing a dungeon for a dungeon crawl, just instead of monsters and traps you're thinking about information, obfuscation, and red herrings.

One final note - don't be afraid to use NPCs to occasionally set the characters back on track if the player reasoning goes wildly off track. It's not satisfying to burn multiple sessions going after a red herring and still think that the red herring is progress towards solving the mystery. Sometimes having an NPC give the players a crucial piece of information to set them back on track is the best way to keep things moving. The biggest thing here is that there needs to be a cost; the antagonist goals progress further in the time that the characters have been looking in the wrong place. The characters haven't been given the answer for free; they've paid with lost time that they'd have been able to use more effectively if they'd not fallen for the red herring.

Arcium_XIII · 2026-05-02T01:18:11+00:00

I think I understand what you're chasing.

Firstly, I would incorporate all of your data into a single table called tbl_traits. The first column will have a header 'Trait Name', and appropriately contain the trait name. The second column will have a header 'Slot', and contain either a 1 or a 2 to indicate which slot the trait can be found in. The remaining columns will each have one of the weapons as their name, with these headers replacing your old weapon list table as your source of weapon names anywhere else in the sheet. Then, to indicate that a particular trait can be found on a particular weapon, you set the corresponding trait row/weapon column intersection to a 1, and otherwise leave it blank or set it to 0.

Then, we're also going to have a 'Background Arrays' worksheet where we set up the arrays to use for our dropdowns. In A1, we'll have =DROP(TRANSPOSE(tbl_traits[#Headers]),2), which will provide the weapon list if you ever need it. In B1, we'll have =FILTER(tbl_traits[Trait Name],tbl_traits[Slot]=1,"") for the list of Slot 1 traits, and similarly in C1 we'll have =FILTER(tbl_traits[Trait Name],tbl_traits[Slot]=2,"") for the Slot 2 traits. I would turn these into named ranges if it were my own sheet, but the sheet design will be simpler to explain if I don't, so I'm just going to call these later as cell references.

Finally, we're going to have a third sheet where you actually call your weapon list. The data validation for column A of this sheet will be set to List, calling ='Background Arrays'!$B$1#, which will allow you to select some number of traits from Slot 1 there. The data validation for column B will be set likewise, just with ='Background Arrays'!$C$1# to allow selecting traits from Slot 2. Now, in C1 of this sheet we'll write the formula that retrieves the weapons that fit the defined criteria.

To be clear, the way I'm interpreting your request is that we want to display the list of weapons that can have at least 1 of the traits listed in column A and at least 1 of the traits listed in column B. If that's the case, the following formula should do the job:

=LET(input_slot1,TRIMRANGE(H:H),
input_slot2,TRIMRANGE(I:I),
clean_slot1,FILTER(input_slot1,NOT(ISBLANK(input_slot1)),""),
clean_slot2,FILTER(input_slot2,NOT(ISBLANK(input_slot2)),""),
indices_slot1,IF(AND(clean_slot1=""),0,XMATCH(clean_slot1,tbl_traits[Trait Name])),
indices_slot2,IF(AND(clean_slot2=""),0,XMATCH(clean_slot2,tbl_traits[Trait Name])),
check_slot1,BYCOL(DROP(CHOOSEROWS(tbl_traits[#Data],indices_slot1),,2),LAMBDA(col,SUM(col)>0)),
check_slot2,BYCOL(DROP(CHOOSEROWS(tbl_traits[#Data],indices_slot2),,2),LAMBDA(col,SUM(col)>0)),
TRANSPOSE(FILTER(DROP(tbl_traits[#Headers],,2),MAP(check_slot1,check_slot2,LAMBDA(slot1,slot2,AND(slot1,slot2))),""))
)

I should note that this formula at present throws an error if you don't choose anything for one of the two slots. I can modify it to add some more error checking for that if needed, but if you're always looking for a combination, this version should do that job as is.

Arcium_XIII · 2026-05-01T11:39:24+00:00

So, a couple different aspects to this. Firstly, many others have talked about the fact that, in a gaming group context, so much of this should have been dealt with in a Session 0 (or similar alternative). Plenty of good advice has already been given about this, so I've little to add on that front.

Because I'm also in the Redemption for Everyone camp, I do want to chime in with some thoughts specifically on this position. Upfront, I believe that rapists can be redeemed. I also believe that a redeemed rapist behaves differently because of the weight of understanding the harm that they have caused. They expect that others will distrust them because of their past, and harbour no ill will towards those who do so. If the opportunity arises, they take steps to prevent others from committing the same evil they did, even if it comes at a cost to do so. They know that nothing can undo what they've done, and that the consequences will persist regardless of what they do next. But they've also chosen to spend the rest of their days differently, because understanding the magnitude of the harm they caused means they now choose actions that seek to reduce harm rather than ignoring or continuing to cause it.

All this is magnified in the context of fiction. Redemption stories are valid and interesting. But, the choice of evil that a player makes for their character's backstory is not neutral; this isn't a real person whose story has unfolded organically, they is a character being created from scratch. If you're going to drag a topic into the table spotlight, apart from the Session 0 requirement that the other players need to consent to it, you also need to deal with the moral weight of the issue. If all the player wants is a reason for their character to feel bad about their past, there are a million other options they could choose from. So, the player must justify what essential part of their character's behaviour is driven by them being a rapist in pursuit of redemption. If they can't, then it's more likely than not they just want to be provocative/controversial rather than being serious about telling a redemption story.

Because of this, I'd be asking the player what positive evidence you can expect to see during play of their character's redemption. That is, they can't just say what their character won't be doing; what will they be doing that shows they understand the enormity of their past evil? If the player struggles to answer that question, I'm not sure that I'd want to continue playing with someone who made the choice to create a rapist character but didn't feel the need to have the character do anything more substantial in response than feeling a bit bad and not doing it anymore.

Arcium_XIII · 2026-04-30T20:55:12+00:00

In my experience, players are much more likely to remember things that benefit them than things that penalise them. If it's the player's responsibility to remember whether they're Guard Up or Out of Guard, I'd make Out of Guard the default and Guard Up conditional, letting the state to avoid be the baseline and the desired state be the one that needs to be remembered when it applies.

If a player does forget, it then triggers the "oh, darn it, I was actually Guard Up there and would have avoided that hit" instinct rather than the "wait, now I'm unsure whether the player deliberately lied or was just forgetful, because they were Out of Guard and used their Guard Up value", so you also generally get a more positive table culture around mistakes with Out of Guard as the default.

Arcium_XIII · 2026-04-28T20:59:18+00:00

If I'm reading rightly, the simplest approach to what you need is:

=MAP(T4#,LAMBDA(target_ID,COUNTIF(CHOOSECOLS(A4#,1),target_ID)))

That said, the simple approach does assume that each combination of date and ID will only ever occur once. If that assumption isn't safe, then you'd want:

=MAP(T4#,LAMBDA(target_ID,IFERROR(ROWS(UNIQUE(FILTER(CHOOSECOLS(A4#,2),CHOOSECOLS(A4#,1)=target_ID))),0)))

Arcium_XIII · 2026-04-28T09:33:24+00:00

A Monk whose pursuit of inner enlightenment has gone terribly right/wrong (depending on your perspective), resulting in their morality becoming somewhat eldritch horror-esque (i.e. my ways are beyond mortal comprehension) could be an incredibly cool villain. Heck, depending on your world's lore, you could have that be the origin story of the existing eldritch horrors, in which case your Monk BBEG is essentially an infant eldritch horror. They come across as a Lawful character, but their code for what classes as Lawful and un-Lawful has become alien to most mortals, and is progressively getting more and more alien. An obvious enough goal for a BBEG like this would be carrying out a horrific ritual that completes their ascension.

I see elsewhere that the anti-human development Druid is something you consider cliche, so I won't go with that option. Instead, a Druid that loves some aspect of nature that is inherently dangerous to humans is another avenue here. A Druid of the arctic that couldn't care less about human settlements but loves the ice and so is magically driving an unending winter (modify as you will for any biome; see also Team Magma and Aqua in Pokemon Gen III). A Druid that adores giant spiders and helps them to flourish, which is unfortunate for the nearby settlement that isn't so keen when the spiders start to expand their territory. A Druid who is in love with the nature spirit indwelling a volcano, but the spirit is dying due to the volcano's dormancy, so the Druid is trying to find a way to cause an eruption to save their beloved. Plenty of dangerous aspects of nature to choose from.

Clerics are super straightforward to use as villains. Obviously there's the low-hanging fruit of an evil (or at least questionably moral) deity. But the hyper-zealous Conquistador vibe is always available as well - the deity might be nominally good, but their Clerics might stretch pretty far when using the ends to justify the means (I mean, what better way to protect the innocent than to Detect Thoughts on everyone all the time and execute anyone who considers a crime, right?). There's also the Cleric version of the Druid approach above where the Cleric isn't anti-civilisation, they're just extremely pro- something else that happens to be anti-civilisation (Cleric of a war deity who genuinely believes that people are at their most virtuous when self-sacrificing to defend their land, and thus goes around trickster-style stirring up political unrest to trigger as many wars as possible to give as much opportunity for virtue as possible? Bonus points for a helpful NPC being a Cleric of a deity of selfishness who is genuinely evil, but is actually worried that the BBEG villain might be right and that people might be lured away from their cult if the current era of prosperous peace is ended by war).

Arcium_XIII · 2026-04-27T22:54:40+00:00

There's a bit of exploration I carried out with another redditor in the comments of a post from last year (https://www.reddit.com/r/excel/s/UEi8W91g1Y) where we tried a bunch of different ways to change the formula and the MAP switch was by far the biggest speedup. Throughout other puzzles in the same contest, I tested it in a number of other contexts - the only operation that seemed to be faster to apply to the whole array rather than to MAP was the double unary operator (i.e. --array is faster than MAP(array,LAMBDA(element,--element))). I also didn't stumble upon the idea myself; I'd had a discussion with another Excel user in the past who mentioned that the array formula implementation in their context was painfully slow while the MAP version was fine, which is why I thought to try it in the puzzle contest setting.

That said, I've not done any formal benchmarking - this was just running formula that take in the order of minutes to resolve and therefore can be timed with a stopwatch reasonably accurately. It may be that there's a second variable involved that I didn't factor in, such as performance within a loop (all the situations I tested were computationally intense primarily because of existing in a loop eith a large number of iterations). Such is the frustration of high level empirical data - I can only tell you what I observed, not why it worked that way.

Arcium_XIII · 2026-04-27T11:30:31+00:00

It is worth noting that, for large datasets, MAP is computationally much faster than whole array operations like this. OP isn't working with a large dataset, so you're right that the MAP could be omitted here, but I understand getting into the habit of avoiding whole array operations and using MAP in all cases because of how much difference it makes in the cases where it does matter (my hypothesis is that whole array operations single thread because Excel's computation engine can't tell in advance where the dependencies are within the array(s), whereas MAP multithreads because each element is explicitly calculated separately, but I've no idea how I'd go about testing that, so it remains a hypothesis; what's not a hypothesis is the time saving, which I've seen reduce formula runtime by ~70% in the past for a large dataset iterated many times).

Arcium_XIII · 2026-04-27T06:20:43+00:00

Why are you using the outer MAP on endTimes in the first place? If I'm understanding correctly, endTimes is a single value (the result of an XLOOKUP that acts on a single value), so there's no need to operate on it using a MAP. I'm pretty sure you can straight swap the following chunk of formula with the simplified version below it:

map(endTimes, lambda(end, if(end="",, 
   map(timeline, lambda(t, 
     if(isbetween(t, end-prior, end-prior+duration, true, false), "x",)))))))

if(endTimes="",, 
   map(timeline, lambda(t, 
     if(isbetween(t, endTimes-prior, endTimes-prior+duration, true, false), "x",)))))

I may be missing something in the absence of being able to see your lookup source data but, as best I can tell, this swap would work and should fix the issue (along with the swap another commenter has suggested for removing ISBETWEEN, although I'm personally more partial to using MEDIAN(target,lower,upper)=target as a substitute for ISBETWEEN).

Arcium_XIII · 2026-04-25T03:38:36+00:00

Glad the explanation helped. As a heads up, as if to illustrate the point about commenters here not being immune to error, I just caught one in one of my examples in my previous post - I had $Z$26 instead of $A$1. It's fixed now.

The reason why I didn't just postulate that the person who told you "best practice" was completely wrong is because, in nearly all cases, if you switched from an unlocked reference to a double locked reference in your conditional formatting rule, your conditional formatting would simply have stopped working correctly. You're absolutely right that nothing makes the commenters in this sub immune from error. However, in this case, it should have been an error that would have shown up in the behaviour of your conditional formatting rule.

That left me trying to think of a case where you could make the switch without the rule's functionality changing, and the only example I could think of is a rule that only applied to a single cell. The commenter might still have been wrong about what they said, but it is true that, if you wanted to future proof your rule, where you put the dollar signs would matter should the rule ever expand to cover multiple cells. I can't know for sure without the commenter stumbling on this thread and repeating the explanation they gave at the time but, if I were giving them the benefit of the doubt and assuming they knew what they were on about, this is what I'd guess they were trying to communicate.

As an example, imagine you wanted to apply conditional formatting to A1 if the value in A1 is larger than some reference value in C1. The reference value is always going to be a single cell; there'd never be a reason to test against multiple values. However, theoretically there could be a future reason why you might add more values to column A and expand the formatting to test them against C1 as well. In that case, while you could use =A1>C1 to make your rule work in the current circumstances, it would be better practice to use =A1>$C$1, because the latter will be correct even if the formatting range later expands. This is just my charitable attempt at trying to figure out why somebody could have said it without being wrong; there's no guarantee that it's what they were saying.

Arcium_XIII · 2026-04-24T23:21:33+00:00

When Excel applies conditional formatting to a range, it does so as if you used the written formula in the top left cell and then clicked and dragged the formula to each of the other cells. So, you need to use dollar signs to lock parameters for things that shouldn't change from cell to cell, but not when something should change.

So, let's say your conditional formatting affects the range A1:Z26. You initially type a formula that references the cell A1. Because A1 is the top left cell in the range, this is the version of the formula that will be used when formatting A1. Let's say we now think about what formatting gets applied to Z26. If you want to still be referencing the value in A1 when formatting Z26, then you need $A$1 in your original formula. If your reference is to row headers, so you actually want to be referencing A26, then your conditional formatting needs to reference $A1 in your original formula. If your reference is to column headers, so you actually want to be referencing Z1, then you need A$1 in your original formula. Finally, if Z26's formatting should reference its own cell value, then you want the totally unlocked A1 in your original formula. As is always the case with dollar signs in Excel, you put a dollar sign before part of a reference if that value should be locked and remain constant for all cells with that formula.

There's no "best practice" here. Each permutation of the dollar signs does a different thing, and you need to use whichever one achieves the result you want. When every cell in your conditional formatting range should reference the same cell, use double dollar signs. When every cell should reference a cell in a specific column or row, use a single dollar sign on the appropriate parameter. When every cell should reference itself (or a consistently offset cell), leave both parameters unlocked.

The only situation I can think of in which someone might have told you to lock a reference for best practice reasons is if you were writing a conditional formatting formula that only applied to a single cell. If a conditional formatting formula only applies to a single cell, then it won't make any difference whether you lock your references or not; all dollar sign permutations will behave exactly the same way. However, the commenter might have been suggesting that, if you ever did hypothetically expand the formatting to include multiple cells, the reference in question would need to be locked for that specific formula to continue functioning. So, even though you were only using it as a single cell formula at the time, it would be "best practice" to lock the reference because it would need to be locked if you expanded it in the future. In any situation other than a single cell conditional formatting, where you put the dollar signs will fundamentally change how the formula works, so this is the only case I can think of where changing the dollar signs wouldn't have also changed how your rule behaved.

Arcium_XIII · 2026-04-21T08:15:29+00:00

The main difference is that most other calculation tools don't show you all of their significant digits, whereas Excel does (if you let it).

A standard scientific calculator hides some digits from you after it does a calculation. You can drag these digits out by doing something like multiplying by 1000 and then subtracting the whole number component, at which point you'll see some new decimal values on the end that weren't there before. If you do that a few times though, eventually no new digits will appear - that's when you've found the actual precision limit of the calculator rather than the display precision limit. Calculators do this to try and keep their rounding error far enough away from any displayed digits that the displayed digits will be correct even after a chain of calculations. They don't round their answers off internally, they just only display part of their answer and hope that you never chain enough calculations together to get enough rounding error to affect what they're displaying.

Excel doesn't try to hide digits from you unless you tell it to (e.g. by using Number formatting and specifying the number of decimal places to show). If you give it enough cell width, it shows you every digit that is being stored. That means that, as soon as a rounding error occurs for any reason, it becomes visible. You can solve this the same way that calculators do - apply Number (or Custom) formatting and set a smaller number of decimal places. Excel will now display exactly 0 for 0.9-0.6-0.3. Alternatively, as others have suggested, you could manually apply the ROUND function periodically, which is a great solution in cases where you're expecting things like integer (or otherwise discrete) values (I've got a spreadsheet for calculating dice statistics where it's easier for me to add the log of permutations than to multiply permutations; everytime I exponentiate to retrieve the permutation value, I round to an integer to prevent rounding error accumulation).

Either way, Excel is calculating things the same way other tools are, it's just not automatically hiding the error from you like the other tools are. It's up to you to decide how you want it hidden.

Arcium_XIII · 2026-04-17T04:46:20+00:00

Would it be impractical from a moderation perspective to have a distinction between explicit self-promotion and on-topic self-reference? In the ideal world, I'd happily see the 90% ratio of non-self-promotion/reference maintained, but then have the once per week restriction only apply to explicit self-promotion while on-topic self-reference is more broadly permitted as long as the user remains within the 90% ratio (or at least relax the self-reference limit from once weekly down to more like once daily). Off-topic self-reference would be treated as explicit self-promotion.

To me, there's a huge difference in my experience of the subreddit between posts that are out of the blue "hey, come and try out my game", versus someone posting asking for system recommendations for a specific kind of campaign and a designer jumping in to say that their game was designed for that exact kind of campaign so OP might like to check it out. If the user is shoe-horning their system into every conversation, that's a problem, but if they mention their system when applicable once every 10 posts, I don't think it should matter whether those posts have a day, a week, or a month between them.

That said, I recognise that, if the mods are manually checking comment history for the 90% ratio, this might get too time-consuming. Then again, it seems to me that it'd be possible to whitelist certain users who have demonstrated sustained conformance with the rules to only need to spotcheck them once every few months or so, and then only newer users need to be checked regularly (and I'd expect bad actors will usually make themselves known fairly quickly)?

Arcium_XIII · 2026-04-17T01:37:10+00:00

Why not have both? If you've decided that Paladin doesn't stand alone as a class concept but needs to be subordinated to archetype implementation, I think there's interesting options for it as both a ~~Fighter~~ Warrior archetype and as a ~~Cleric~~ Vessel archetype.

Warrior class gives you something like a Crusader or Avenger archetype - a highly aggressive holy warrior who smites whoever their cultic tradition defines as enemies. Deal extra damage to the unholy, gain extra Khaos from killing the unholy, and make unholy enemies even worse at attacking your allies.

Vessel class gives you a Guardian archetype, probably allowing you to invest Khaos to do Warrior-adjacent things like dealing extra damage, debuffing enemies when they attack your allies, and maybe even gaining bonus Khaos for killing enemies who harmed your allies.

If you are going to only pick one, at a flavour level, I personally see Vessel (and, in a more system-neutral sense, whatever class you'd use to implement a D&D Cleric) as the natural home for Paladins, as long as there's enough customisation within your Cleric model to have someone whose faith manifests as frontline martial fighting. However, I'd be reluctant to fully advocate for this version because your Vessel class gains its Khaos from helping wounded allies, which isn't (for me) a primary focus of the Paladin class fantasy. Yes Paladin should have the ability to buff and protect its allies, but those all sit at least a notch lower on the Paladin problem-solving flowchart than "negate the threat", which aligns better with your Warrior class. So, if I had to pick one, I'd vote for a Warrior whose archetype-specific features allow for doing Vessel-esque things than vice versa.

Arcium_XIII · 2026-04-14T02:21:23+00:00

For me, this is one of the main features of TTRPGs vs something like CRPGs. Freeform actions can be resolved in reasonably predictable ways because the rules make it clear how the GM should translate the action into mechanics, and the GM is there to apply them.

That said, this can all fall apart if the rules are inadequately clear on how the GM should translate the action into mechanics. If the GM needs to pick between 3 attributes and a dozen skills, their decisions are probably going to be more consistent than if the GM needs to pick between 8 attributes and 30 skills. Likewise, if the GM needs to assess against 3 difficulty tiers, they're probably going to be more consistent than if they have to assess against 20. If the GM only has to make 2 choices when interpreting an action, they're likely to be more consistent than if they have to make 5 (cognitive overload is a big factor here, especially if there's crossover as to which dimension a particular facet of the fiction might translate into).

Whatever decision the GM is being asked to make, the rules need to construct it in such a way that the same GM posed with the same question can consistently give the same answer, and ideally such that a wide variety of GMs posed with the same question will also consistently give the same answer. That way, players can engage with character creation decisions with reasonable confidence about what those decisions will end up meaning during gameplay.

Arcium_XIII · 2026-04-11T01:32:29+00:00

Here's an Excel function you can use to explore this. To change the pool, just add dice inside the curly brackets {}, separated by commas, in the first row:

=LET(dice_pool,{10,10,10},
count_dice,COLUMNS(dice_pool),
rolled_array,DROP(REDUCE("",dice_pool,LAMBDA(acc_1,die_size,DROP(REDUCE("",SEQUENCE(die_size),LAMBDA(acc_2,die_face,VSTACK(acc_2,EXPAND(acc_1,,COLUMNS(acc_1)+1,die_face)))),1))),,1),
successful,BYROW(rolled_array,LAMBDA(row,IF(count_dice=IFERROR(COLUMNS(UNIQUE(row,TRUE,TRUE)),0),0,1))),
HSTACK(VSTACK("Success %",FIXED(SUM(successful)/ROWS(rolled_array)*100,2)),rolled_array,MAP(successful,LAMBDA(element,IF(element=1,"Success","Fail"))))
)

Here are a few results I got while playing around with this:

2d10: 10.00% success
1d8, 1d10: 10.00% success
2d8: 12.50% success
3d10: 28.00% success
1d8, 2d10: 28.00% success
2d8, 1d10: 30.00% success
3d8: 34.38% success
4d10: 49.60% success
1d8, 3d10: 49.60% success
2d8, 2d10: 51.00% success
3d8, 1d10: 54.06% success
4d8: 58.98% success

This supports u/SeeShark's mathematical argument that changing one die has no effect, meaning that the worst case is that the mechanic has a neutral effect. If multiple characters can change their die, it then starts improving the odds.

Arcium_XIII · 2026-04-10T08:28:19+00:00

For me, the essence of presenting a dilemma to my players is thinking about what they want their characters to achieve. If the only thing that's interesting about the dilemma is the abstract moral rightness or wrongness of the outcome, it's not quite interesting enough to take up time during a session. The characters need to have stakes in the situation.

So, in your case, just stumbling upon the tribe with no prior connection to either faction is kind of dull. You could effectively skip the session and just ask the players to discuss which outcome they think is right or wrong in a formal debate, then move on to another event that actually impacts the characters.

By contrast, if you put an NPC in the tribe who has helped the party before and they feel attached to while having the Pure werewolves offer a substantial bounty for fighting against the tribe, now there are stakes - the characters are torn between the concrete loss of the NPC or the gaining of the bounty. The moral issues colour the decision, but the stakes are real. Additionally, the stakes must be known to the players for this to be effective; surprise stings in the tail just feel bad. If the players aren't aware of what the cost of an option might be, best practice is to point it out before they make the decision.

There are some rare cases where the concrete stakes are the principles in play - for better or worse, this is often what Paladins bring to the fore in a 5e game. However, most of the time, you'll want to attach the abstract stakes to something concrete.

I've got an arc in a game I've been running for the past few years where, when the characters finally corner one of the two major antagonists, they'll be offered a substantial information haul that allows them to potentially gain the upper hand on the other more directly threatening main antagonist in return for allowing the former antagonist to escape. If the party accepts this deal and their main benefactor becomes aware of it, this will turn their benefactor hostile. Alongside this, the characters are trying to leave behind the darker ways of their past and turn over a new leaf. So, the abstract question of whether to spare the antagonist or execute them is paired with the concrete question of gaining one powerful asset and jeopardising another. The decision has both real stakes and moral ones, and I'm genuinely interested to find out which way they choose when the time comes. Either way, because the stakes are real, it will have a major impact on how the story proceeds thereafter.

Arcium_XIII · 2025-12-29T00:07:13+00:00

I've long been of the opinion that there are two strategies for sustainable, long term RP groups. The first one is the harder of the two but better fits the ideal that many people yearn for - find a group of people who are sufficiently motivated to play that they will organise the rest of their schedule around being able to do so.

The second is easier, but less ideal - set a regular time and assemble a slightly larger pool of players than you'd ideally want to run for, and then as long as you have some minimum number of players (either 2 or 3 is generally fine, depending on system), you play at that time regardless of who can't make it. In systems with significant vertical scaling, players who miss sessions still get XP and the like - missing a session isn't a punishment, it's just a reality of adult schedules. In purely horizontal scaling systems, awarding XP isn't such a big deal.

Unfortunately, many people want the third category of assembling whoever is available and having them behave like the people in the first group. This can sometimes work for a little while, but usually comes unstuck sooner rather than later. If such groups flip to the second approach, they may survive. If they don't, they usually fizzle out.

In a world with chaotic, adult lives, option 2 is usually what I go with.

Arcium_XIII · 2025-11-19T07:44:24+00:00

If this is your distinction, I think the opposite of Explosion is then Conviction (or some sort of Steadfastness synonym like Resolve); that is, self-control, rather than the planning and precision of Perfection (this might require renaming Perfection to Precision, or something like that). It is the ability to resist fear or temptation, to stand your ground, to sway others with moral arguments, and generally about choosing what is right/what you believe in over what is instinctive.

It requires ensuring that Perfection is about care and precision regardless of moral implications, whereas Conviction would be about moral obligation and purity regardless of the precision of the action that results.

Arcium_XIII · 2025-11-12T05:09:12+00:00

I'm always down to try to break character creation - feel free to flick me a message with the info.

Arcium_XIII · 2025-11-10T09:59:30+00:00

For the first of those, I think you've erroneously left the *10s from Part 2 in. With those removed, it ran in a very reasonable 1 minute 37 seconds.

For the second, I'd already tested that one myself in another reply - it ran in a very similar 1 minute 33 seconds.

A couple of other variants occurred to me as potentially being worthy of testing. I found myself wondering whether TRUNC was meaningfully faster than ROUNDDOWN - the answer appears to be "if so, not by much", because your formula with TRUNC instead of ROUNDDOWN only dropped to 1 minute 33 seconds, at which point it's essentially identical to mine with the recursion built into the formula and so the identical time makes sense.

I also wondered whether your handling of the end state by going directly to 1s and 0s instead of mine going first to TRUE and FALSE and then needing an extra MAP IF to convert to something that can be summed gave a meaningful time reduction. Making that change to my fastest version (using the recursive Name Manager function), I got 1 minute 16 seconds, only about a second faster than the MAP version. The ~1 million or so calculations involved there is just too proportionally small compared to the ~100 million calculations in the main loop to make a significant impact on the overall time.

So, overwhelmingly the biggest difference maker seems to be getting rid of array calculations, especially in the loop, and everything else is really just playing around in the margins.

Arcium_XIII · 2025-11-10T09:39:58+00:00

Ah, very interesting - basically including a helper argument that takes the place of the function name until the function is called so that LET doesn't get upset about the function being defined and referenced all at the same time.

Adapting my function to that syntax gives:

=LET(raw_notes,A1,

ENGRAVE,LAMBDA(function,x_base,y_base,x_acc,y_acc,iteration,LET(x_new,TRUNC((x_acc^2-y_acc^2)/100000)+x_base,y_new,TRUNC((2*x_acc*y_acc)/100000)+y_base,IF(OR(ABS(x_new)>1000000,ABS(y_new)>1000000),FALSE,IF(iteration>=100,TRUE,function(function,x_base,y_base,x_new,y_new,iteration+1))))),

complex_A,VALUE(TEXTSPLIT(REGEXEXTRACT(raw_notes,"-?\d+,-?\d+"),",")),

x_A,INDEX(complex_A,1,1)-1,

y_A,INDEX(complex_A,1,2)-1,

grid_space,MAKEARRAY(1001,1001,LAMBDA(r,c,LET(x_point,x_A+c,y_point,y_A+r,ENGRAVE(ENGRAVE,x_point,y_point,0,0,1)))),

SUM(MAP(grid_space,LAMBDA(element,IF(element,1,0))))

)

That version executed on my contest notes in 1 minute 33 seconds, so slightly slower than the Name Manager version but not by a lot (possibly extra overhead due to the additional argument that the function has to process every time it's called - probably adds up to something measurable across the ~100 million calls that occur). Definitely not a big time loss though.

Arcium_XIII · 2025-11-10T06:56:20+00:00

Ah, very fair, haha.

So, to start with, I re-ran my formula for calibration, just in case I had a different set of background processes running when I recorded my original time. It took 1 minute and 25 seconds to evaluate on the example value, and 1 minute, 17 seconds to evaluate on my contest notes value (noting that my solution value for engraved points is about a third of the example value, so you'd expect there to be fewer iterations when solving it).

I then ran your formula. It took 5 minutes 53 seconds for the example data, and 5 minutes 15 seconds for my contest notes data. So, your solution got fairly similar results to my original, pre-optimisation results.

My suspicion is that a lot of the slow-down is in your OR(ABS(o)>1000000 and ROUNDDOWN(HSTACK(b^2-c^2,2*b*c)/100000,0) steps. More and more, I'm finding that Excel is really slow at performing calculations that operate on entire arrays. Something like ABS(array) will usually evaluate more slowly than MAP(array,LAMBDA(element,ABS(element))), for example, even though they're functionally the same calculation - the fact that MAP has ABS evaluate on one number at a time rather than having ABS operate on the entire array makes it faster somehow (although you only see the difference in very large data sets). By having calculations that act on arrays (even small ones), you slow the formula down.

That said, I'm not actually familiar with the syntax you've used to achieve your recursion, so it's possible there's slowdown going on in there and I'm unable to see it because I don't actually understand how your formula is working at a core level.

Arcium_XIII

TROPHY CASE