D&D 5E (2014) UA and depth of complexity

[pemerton]

I hate (non-Dark Sun) clerics because they are almost-inextricably tied to offscreen uber-NPCs who, at least according to the default game lore, interfere constantly with the party's adventures (granting spells, turning undead, etc.) but never actually do anything directly without the cleric "casting a spell" first; and the gods' motives generally don't make any sense even to the DM, nor does the "worship" associated with them. Clerics are incoherent theologically and they make the story incoherent as well, unless you make the assumption that gods don't really exist and that clerics are all just deluded magical technicians of some sort, just like wizards--but most DMs don't make that assumption, so clerics are generally just a mess.

Harsh!

I prefer to think of it in reverse: because the cleric is not incoherent or a mess, it must be that clerics' use of prayers and other actions reflects the will of the gods who empower them, which means that those gods must not be NPCs in the traditional sense at all, but rather are, at least prima facie, adjuncts to the player of the cleric. (A little bit like a familiar is to a magic-user, as far as the game structure is concerned; obviously very similar from the in-fiction point of view.)

 

[FormerlyHemlock]

Harsh!

I prefer to think of it in reverse: because the cleric is not incoherent or a mess, it must be that clerics' use of prayers and other actions reflects the will of the gods who empower them, which means that those gods must not be NPCs in the traditional sense at all, but rather are, at least prima facie, adjuncts to the player of the cleric. (A little bit like a familiar is to a magic-user, as far as the game structure is concerned; obviously very similar from the in-fiction point of view.)

But that theory can't be true, or else why are clerical spells dispelled just as easily as a wizard's spells and by the same means? Are gods merely wizards with extremely long-range spellcasting? Why do the spells go away if the cleric stops concentrating on them?

Isn't it a little bit thematically uncomfortable to have a PC who is essentially just a spectator, while the player spends most of the time playing the god? "I, Cyric the Unholy, send another bolt of sacred flame down from the heavens to singe the beards of the righteous dwarves. Sacred Flame for 2d8 damage, yeah! Oh yeah, and I guess my cleric Modwin is praying to me and waving his arms around while pointing at the dwarves, but who cares about Modwin, he never does anything anyway." (Actually that sounds at least twice as awesome as a regular cleric, and if I were forced to play a god-worshipping cleric as a PC that's probably how I would do it, although it gets a little bit more incoherent if the cleric multiclasses and Cyric chooses to inexplicably sit around doing nothing while the priest/wizard casts Fireball.)

 

[pemerton]

why are clerical spells dispelled just as easily as a wizard's spells and by the same means? Are gods merely wizards with extremely long-range spellcasting? Why do the spells go away if the cleric stops concentrating on them?

These are good questions.

If I come up with an answer that makes sense from a traditional D&D perspective I'll get back to you! In Burning Wheel clerical magic isn't dispellable in the D&D sense; in 4e dispel magic is a bit of a thing, but nothing like in the traditional sense (and there is no counterspelling). The rulebooks tell us that a cleric is imbued with the power to use divine power, but is not really a conduit for his/her god (more like the god stuck a battery in him/her and then pressed the "Go" button) - a bit like Gygax's account of 1st and 2nd level cleric spells being sourced just in the cleric's training. But at upper levels this becomes a bit implausible, even if it was plausible at lower levels. But I think the idea implicit in how I run it is that the god is something like a long-range wizard ie creates an effect by will, with the cleric as conduit or agent of his/her will, and this is liable to being dispelled like a wizard's effect would be (but only a high level wizard could dispell a high level cleric's effect, so the gods are at least powerful wizards!).

 

[FormerlyHemlock]

(but only a high level wizard could dispell a high level cleric's effect, so the gods are at least powerful wizards!).

Or at least, they are powerful wizards when channeled by powerful priests. In fact, they are exactly as powerful as the priest himself... suggestive, eh?

"Pay no attention to that man behind the curtain! The great Oz has spoken!"

 

[Corpsetaker]

I think the obvious question is being overlooked in threads like this: Do they even want more complexity?

We need to look at the design goals of 5e, and I think it's clear that they are taking a more simple, streamlined approach where they want WE as the players to create additional tools that we like*, as opposed to a splat train of ever increasing complexity and options coming from them directly.

I think 5e has an identity, one that they are careful to adhere to, and expecting it to be different from that identity will result in you waiting a long, long time.


*With guidelines on how to create classes and subclasses, feats, etc, and especially with the creation of the DM's Guild seems to point to this intent strongly.

Need I remind you that 5th edition D&D was sold on the back of a "plug and play" strategy where one could have as much simplicity as they wanted or as much complexity as they wanted.

If you want to keep "your" games simple then stick to what you have, but those of us who want more complexity should be able to go to those extra options and just plug those right into our games. You know, like all options that have been a part of every edition? You choose what you want to use and discard the rest.

 

[Corpsetaker]

Hiya!

**SNIP A BIT-TOO-SNARKY-OF-A-POST**

More crunch? No thanks. I, and apparently the majority of 5e'ers, don't want more crunch for the sake of it.

Hiya!

Then don't use it and let those who do want it have it.

Bye-ya!

 

[Corpsetaker]

Congrats. I've been playing for 35. So what. This means nothing.

I knew a guy who claimed he had been a painter for 35 years. I later found out that nobody had the heart to tell him to find another profession.

 

[CapnZapp]

I think the obvious question is being overlooked in threads like this: Do they even want more complexity?

No, you may assume, for the purposes of this thread, that the answer is "yes".

If you want to discuss why you don't want to see more complexity in the game, or why you believe there will be no more complexity in the game, feel free to start a new thread.

This thread was created to discuss the subject of what forms more complexity could take

 

[Celebrim]

No, you may assume, for the purposes of this thread, that the answer is "yes".

If you want to discuss why you don't want to see more complexity in the game, or why you believe there will be no more complexity in the game, feel free to start a new thread.

This thread was created to discuss the subject of what forms more complexity could take

Though I said that you had to be careful adding more depth of complexity to a system, I do in fact think that 5e is (as it currently exists) vastly too simple with far too few options. I just don't think the problem lies in there being not enough options for existing archetypes. The existing classes are already crammed full of abilities (practically at every level) and they all have two or three dials to turn already to tweak them. Any new features would invariably mean power creep. Power creep is lethal to a game in the long run, and would in short order necessitate a 6e.

Some areas I would like to see new breadth of complexity though:

a) More feats.

b) More spells. Particularly spells that are thematic.

c) More archetypes.

d) More backgrounds.

e) More subsystems. Pursuit/Evasion, Mass Combat, Domain/Dynasty Management, Crafting, Mystery/Investigation, Research/Invention, example Skill Challenge Frameworks

f) Better refined existing subsystems. A lot of the existing subsystems - say some of the simple Downtime systems (Carousing, for example, comes to mind) - to me feel like simplified placeholders designed to give quick and easy answers to something not intended to be a major part of the game. I've got mixed feelings about this. On the one hand, I applaud them putting subsystems into the game at all. On the other hand, I feel like the only justification for the subsystems as is, is lack of space to put in better ones, and that they are better thought of as stubbed out components to be replaced by advanced systems is later supplements than as anything really useful except as inspiration.

g) Possibly more classes. See my comments earlier on the standard D&D classes and how they leave lots of design space untouched. If that design space can't be reached by swappable archetype components, you need new classes to do it. The reason I say 'possibly' is new classes is a huge danger of power creep, and the more classes you have the more risks you are taking. It doesn't matter how many classes a system has. It matters how many classes are of a viable tier. Nonviable classes will on the whole cease be played.

I guess you'd have to sale me on the idea of increased depth of complexity. I see 5e as an elegant but poorly supported system. I'd like to see it better supported, but without breaking it's elegance.

 

[Guest 6801328]

Feel free to write assertions in C++ if you think it would help.

Oh well heck you should have said so. That would help reduce miscommunication. Here's an analysis of my proposed uncertainty mechanic:

	.section	__TEXT,__text,regular,pure_instructions
	.macosx_version_min 10, 11
	.section	__TEXT,__literal8,8byte_literals
	.align	3
LCPI0_0:
	.quad	4636737291354636288     ## double 100
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_main
	.align	4, 0x90
_main:                                  ## [MENTION=98025]Mai[/MENTION]n
	.cfi_startproc
## BB#0:
	pushq	%rbp
Ltmp0:
	.cfi_def_cfa_offset 16
Ltmp1:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
Ltmp2:
	.cfi_def_cfa_register %rbp
	subq	$128, %rsp
	movl	$0, -4(%rbp)
	movl	%edi, -8(%rbp)
	movq	%rsi, -16(%rbp)
	cmpl	$4, -8(%rbp)
	je	LBB0_2
## BB#1:
	leaq	L_.str(%rip), %rdi
	movb	$0, %al
	callq	_printf
	leaq	L_.str.1(%rip), %rdi
	movl	%eax, -100(%rbp)        ## 4-byte Spill
	movb	$0, %al
	callq	_printf
	xorl	%edi, %edi
	movl	%eax, -104(%rbp)        ## 4-byte Spill
	callq	_exit
LBB0_2:
	xorl	%eax, %eax
	movl	%eax, %edi
	callq	_time
	movl	%eax, %ecx
	movl	%ecx, %edi
	callq	_srand
	movq	-16(%rbp), %rax
	movq	8(%rax), %rdi
	callq	_atoi
	movl	%eax, -20(%rbp)
	movq	-16(%rbp), %rdi
	movq	16(%rdi), %rdi
	callq	_atoi
	movl	%eax, -24(%rbp)
	movq	-16(%rbp), %rdi
	movq	24(%rdi), %rdi
	callq	_atoi
	movl	%eax, -28(%rbp)
	movl	$1000000, -32(%rbp)     ## imm = 0xF4240
	movl	$0, -36(%rbp)
	movl	$0, -40(%rbp)
	movl	$0, -44(%rbp)
LBB0_3:                                 ## =>This Inner Loop Header: Depth=1
	movl	-44(%rbp), %eax
	cmpl	-32(%rbp), %eax
	jge	LBB0_20
## BB#4:                                ##   in Loop: Header=BB0_3 Depth=1
	callq	_rand
	movl	$20, %ecx
	cltd
	idivl	%ecx
	addl	$1, %edx
	movl	%edx, -48(%rbp)
	cmpl	$0, -28(%rbp)
	je	LBB0_11
## BB#5:                                ##   in Loop: Header=BB0_3 Depth=1
	callq	_rand
	movl	$20, %ecx
	cltd
	idivl	%ecx
	addl	$1, %edx
	movl	%edx, -52(%rbp)
	movl	-52(%rbp), %ecx
	cmpl	-48(%rbp), %ecx
	jge	LBB0_10
## BB#6:                                ##   in Loop: Header=BB0_3 Depth=1
	cmpl	$0, -28(%rbp)
	jge	LBB0_8
## BB#7:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-52(%rbp), %eax
	movl	%eax, -108(%rbp)        ## 4-byte Spill
	jmp	LBB0_9
LBB0_8:                                 ##   in Loop: Header=BB0_3 Depth=1
	movl	-48(%rbp), %eax
	movl	%eax, -108(%rbp)        ## 4-byte Spill
LBB0_9:                                 ##   in Loop: Header=BB0_3 Depth=1
	movl	-108(%rbp), %eax        ## 4-byte Reload
	movl	%eax, -48(%rbp)
LBB0_10:                                ##   in Loop: Header=BB0_3 Depth=1
	jmp	LBB0_11
LBB0_11:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-20(%rbp), %eax
	addl	-48(%rbp), %eax
	movl	%eax, -48(%rbp)
	movl	-48(%rbp), %eax
	cmpl	-24(%rbp), %eax
	jl	LBB0_18
## BB#12:                               ##   in Loop: Header=BB0_3 Depth=1
	leaq	L_.str.2(%rip), %rdi
	movl	$5, %eax
	movq	l_main.dice(%rip), %rcx
	movq	%rcx, -80(%rbp)
	movq	l_main.dice+8(%rip), %rcx
	movq	%rcx, -72(%rbp)
	movl	l_main.dice+16(%rip), %edx
	movl	%edx, -64(%rbp)
	movl	-48(%rbp), %edx
	subl	-24(%rbp), %edx
	movl	%eax, -112(%rbp)        ## 4-byte Spill
	movl	%edx, %eax
	cltd
	movl	-112(%rbp), %esi        ## 4-byte Reload
	idivl	%esi
	movl	%eax, -84(%rbp)
	movl	-84(%rbp), %esi
	movb	$0, %al
	callq	_printf
	cmpl	$4, -84(%rbp)
	movl	%eax, -116(%rbp)        ## 4-byte Spill
	jle	LBB0_14
## BB#13:                               ##   in Loop: Header=BB0_3 Depth=1
	movl	$4, -84(%rbp)
LBB0_14:                                ##   in Loop: Header=BB0_3 Depth=1
	movslq	-84(%rbp), %rax
	movl	-80(%rbp,%rax,4), %ecx
	movl	%ecx, -88(%rbp)
	callq	_rand
	cltd
	idivl	-88(%rbp)
	cmpl	$0, %edx
	jne	LBB0_16
## BB#15:                               ##   in Loop: Header=BB0_3 Depth=1
	movl	-40(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -40(%rbp)
	jmp	LBB0_17
LBB0_16:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-36(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -36(%rbp)
LBB0_17:                                ##   in Loop: Header=BB0_3 Depth=1
	jmp	LBB0_18
LBB0_18:                                ##   in Loop: Header=BB0_3 Depth=1
	jmp	LBB0_19
LBB0_19:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-44(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -44(%rbp)
	jmp	LBB0_3
LBB0_20:
	leaq	L_.str.3(%rip), %rdi
	movsd	LCPI0_0(%rip), %xmm0    ## xmm0 = mem[0],zero
	cvtsi2sdl	-36(%rbp), %xmm1
	cvtsi2sdl	-32(%rbp), %xmm2
	divsd	%xmm2, %xmm1
	mulsd	%xmm0, %xmm1
	cvttsd2si	%xmm1, %eax
	movl	%eax, -92(%rbp)
	cvtsi2sdl	-40(%rbp), %xmm1
	cvtsi2sdl	-32(%rbp), %xmm2
	divsd	%xmm2, %xmm1
	mulsd	%xmm0, %xmm1
	cvttsd2si	%xmm1, %eax
	movl	%eax, -96(%rbp)
	movl	-92(%rbp), %esi
	movb	$0, %al
	callq	_printf
	leaq	L_.str.4(%rip), %rdi
	movl	-96(%rbp), %esi
	movl	%eax, -120(%rbp)        ## 4-byte Spill
	movb	$0, %al
	callq	_printf
	xorl	%edi, %edi
	movl	%eax, -124(%rbp)        ## 4-byte Spill
	callq	_exit
	.cfi_endproc


	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"Usage: 'roll [modifier] [dc] [dis/advantage]\n"


L_.str.1:                               ## @.str.1
	.asciz	"(-1 == disadvantage, 0 == normal, 1 == advantage\n "


	.section	__TEXT,__const
	.align	4                       ## [MENTION=98025]Mai[/MENTION]n.dice
l_main.dice:
	.long	4                       ## 0x4
	.long	6                       ## 0x6
	.long	8                       ## 0x8
	.long	12                      ## 0xc
	.long	20                      ## 0x14


	.section	__TEXT,__cstring,cstring_literals
L_.str.2:                               ## @.str.2
	.asciz	"%d\n"


L_.str.3:                               ## @.str.3
	.asciz	"Success Rate: %d%%\n"


L_.str.4:                               ## @.str.4
	.asciz	"False Success Rate: %d%%\n"




.subsections_via_symbols

As you can plainly see, the probabilities need some tweaking.