# How long can my character survive without sleep?

I got into a discussion over Discord this morning about whether the Dream spell could be used to kill someone. The claim was, if I remember correctly, that it would only take 6 days/nights because that's how many level of exhaustion it takes until exhaustion leads to 'Death'.

Exhaustion table from the DMG, as sent to me in Discord, transcribed below

Level Effect
2 Speed halved
3 Disadvantage on Attack rolls and Saving throws
4 Hit point maximum halved
5 Speed reduced to 0
6 Death

And, from the spell text:

On a failed save, echoes of the phantasmal monstrosity spawn a nightmare that lasts the duration of the target's sleep and prevents the target from gaining any benefit from that rest.

Emphasis mine.

It turned out they were also assuming the alternative rule from Xanathar's Guide to Everything, and sent this picture of the rules:

Rules for 'Going without a long rest rules' as sent to me in Discord, from Xanathar's, transcribed below

### GOING WITHOUT A LONG REST

A long rest is never mandatory, but going without sleep does have its consequences. If you want to account the effects of sleep deprivation on characters and creatures, use these rules.
Whenever you end a 24-hour period without finishing a long rest, you must succeed on a DC 10 Constitution saving throw or suffer one level of exhaustion.
It becomes harder to fight off exhaustion if you stay awake for multiple days. After the first 24 hours, the DC increases by 5 for each consecutive 24-hour period without a long rest. The DC resets to 10 when you finish a long rest.

(I've included images in case they sent a wrong version/edition, but transcribed where I can.)

Altogether the assumption was that failing to get a long rest for six lots of 24 hours would lead to six levels of exhaustion and thus death.

Given that the spell Dream just replaces a steadily increasing Constitution saving throw (DC 10 + 5 for each 24hr without a long rest) for the flat Wisdom saving throw against a spell caster's DC, is it possible to calculate how long a character with a 10 in Constitution and a 10 in Wisdom would survive in either scenario (with or without Dream interruption)? It won't be just $$\P(\text{fail save})^6\$$ because of the third level of exhaustion leading to disadvantage on saving throws and/or increasing DC in the case of willingly not sleeping.

In the case of using Dream you can assume the caster can't impose disadvantage, and has a $$\\text{Spell DC} = 8 + 4 (\text{proficiency}) + 5 (\text{ability score}) = 17\$$. Also assume there're no 'tricks' loopholes like granting the wouldbe sleeper bonuses to saving throw bonuses, or using spell or abilities to remove exhaustion or making sleeping unnecessary (e.g. being an Elf, Warforged, or high level monk or having taken Aspect of the Moon as a PAct of the Tome warlock...)

That is, voluntarily or otherwise, how long can my character survive without sleep?

• Comments are not for extended discussion; this conversation has been moved to chat. Jun 24 at 21:21

Dream doesn't replace the mechanic for going without sleep, it forces into effect. That is, if you fail the saving throw against dream, you then still have to make a constitution saving throw against gaining exhaustion. However, if you succeed the save against dream you get a long rest, reducing your exhaustion and resetting that DC.

If we assume you always fail against dream, which would be equivalent to voluntarily not sleeping, you die between 6 days (if you just fail every roll) and 9 days (since the DC will rapidly become mathematically impossible for you), surviving on average 6.9 days (see the Monte Carlo simulation below).

If you do include the possibility of passing the Wisdom saving throw imposed by dream it gets a lot more complicated and you have a theoretical chance of never actually dying (e.g. if you never fail against the spell, you suffer no ill-effects). You could still succumb in 6 days, but per the below simulation a spell DC 17 will kill a Con 10, Wis 10 character in 9.85 days on average. This is not counting the damage dealt by the spell, though that would make it much more complicated (and dependant on target level and any available healing from other other sources).

The survival time plot for being repeatedly target by dream is shown below (percent died at that day vs days):

However, a targeted creature can reattempt a long rest. So assuming the target attempts three long rests each 24 hour cycle, and each one get's dreamed the maths changes significantly. In order to be exposed to a constitution save it needs to fail three dream saves. The modification to the simulation is fairly simple, but the survival time is drastically increased to an average of 26.9 days.

Simulating for additional dream uses and/or determining how much non-long rest time the target will get on average is left as an exercise to the reader.

The above calculations are obtained from using the Monte Carlo method, which basically equate to simulating the events with (computer) dice rolling many times so that the result is (hopefully) representative of actual events. The below python code does that for these two situations, including outputting both the raw data and a frequency table.

import random

def d(N):
return random.randint(1, N)

return min(d(20), d(20)) + mod >= saveDC
else:
return d(20) + mod >= saveDC

def simSleepless():
day = 0
exhaustion = 0
while exhaustion < 6:
if not roll(0, 10+5*day, exhaustion>= 3):
exhaustion += 1
day += 1
return day

def simDream():
casterDC = 17
day = 0
sleeplessday = 0
exhaustion = 0

while exhaustion < 6:
if not roll(0, casterDC, exhaustion>= 3):
if not roll(0, 10+5*sleeplessday, exhaustion>= 3):
exhaustion += 1
sleeplessday += 1
else:
exhaustion -= 1
sleeplessday = 0
if exhaustion < 0:
exhaustion = 0
day += 1
return day

def simMultiDream():
casterDC = 17
day = 0
sleeplessday = 0
exhaustion = 0

while exhaustion < 6:
if not roll(0, casterDC, exhaustion>= 3) and not roll(0, casterDC, exhaustion>= 3) and not roll(0, casterDC, exhaustion>= 3):
if not roll(0, 10+5*sleeplessday, exhaustion>= 3):
exhaustion += 1
sleeplessday += 1
else:
exhaustion -= 1
sleeplessday = 0
if exhaustion < 0:
exhaustion = 0
day += 1
return day

def printDataTable(data):
res = [0]*(max(data)+1)
for point in data:
res[point] += 1
f = open('dreamTable.txt', 'w+')
for i in range(len(res)):
f.write(str(i) + '\t' + str(res[i]) + '\t' + str(res[i]/len(data)) + '\n')
f.close()

def MonteCarlo(func, Count=100000):
data = [0]*Count
for i in range(Count):
data[i] = func()
f = open('dreamdata.txt', 'w+')
f.write('\n'.join(map(str,data)))
f.close()
printDataTable(data)
return sum(data)/Count, min(data), max(data)

print(MonteCarlo(simDream, Count=1000000))

• This is the way to do it! I had started writing a simulation program myself, because there are so many branches and dependencies, theoretical calculations will always be off. Jun 24 at 13:28
• Might want to add and day < 1000 or the like to each of the while exhaustion < 6: loops to limit how far out you'll simulate. Because as is, if you tweak to see the effects of, say, a Wisdom save modifier of +2 (from first level proficiency or Wis 14-15), simMultiDream will run forever (with a one in four chance to save vs. Dream, and three chances per day, and any success undoing 3-5 failures, you need pretty bad luck to die); better modifiers make even simDream pretty survivable. Jun 25 at 2:31

## On average against Dream attacks, they survive 26 days, 9 days if they only sleep once per day

Because there are so many branches, the best way to handle this is to simulate it. Someone_evil has already done so. You can consider this a scientific experiment to reproduce the results (replacing the earlier back of the envelope estimate solution). Spoiler: same results, so upvote his answer, he did it first.

Based on 100,000 simulated attacks, the average time to survive this is about 26 days. On average, the victim will die on the 27th day. After around 185 days, the remaining chance of survival is lower than 1 in 10,000. Overall, while a low-riks, remote method to kill someone, not that effective, and giving the target plenty of time to take measures against it, like finding the caster and trying to kill them.

If the victim only sleeps one time per 24-hour period, then survival is drastically reduced, and death happens on average on the 10th day, pretty close to the 9 days originally estimated for this case.

Here is the code (sorry nearly dead language in perl)

use List::Util qw(min);
my $tries = 100000; my$wis_dc = 17;
my $con_dc = 10; my @died = (); for (my$try = 0; $try <$tries; $try++) { my$exhaustion = 0;
my $days_not_slept = 0; my$calendar_day = 0;
while ($exhaustion < 6) {$calendar_day++;
$ad =$exhaustion >= 3? "DIS" : "";
if (fail(roll($ad),$wis_dc) && fail(roll($ad),$wis_dc) &&
fail(roll($ad),$wis_dc)) { # 3 tries a day to sleep
if(fail(roll($ad),$con_dc+$days_not_slept*5)) {$exhaustion++;
}
$days_not_slept++; } else {$days_not_slept = 0 if $days_not_slept > 0;$exhaustion-- if $exhaustion > 0; } }$died{$calendar_day}++; } for (my$i = 0; $i < 1001;$i++) {
print "$i\t",$died{$i}/$tries || 0, "\n";
}
sub roll {
my $AD = shift; my$result = int(rand(20)) + 1;
my $r2 = int(rand(20)) + 1;$result = min($result,$r2) if $AD eq "DIS"; return$result;
}
sub fail {
my ($roll,$DC) = @_;
return ($roll <$DC);
}


• Using dead languages to predict whether your dreams will kill you... Seems thematic enough. Jun 24 at 19:02