## dnd 5e – What hit dice do sages use?

There is two different associations with hit dice:

1: Class. Wizards have a D6 hit die, Fighters have a D10, Barbarians have a D12, and so on. This is the one player characters use, but isn’t used that commonly for NPC’s/

2: Size. Most NPC’s have hit dice dependent on their size. Tiny have a D4, Small have a D6, Medium have a D8, and so on. If you are building an NPC, this is how you determine their hit dice.

There is a Apprentice Wizard NPC in VGTM, if you are looking for a stat block as a DM. As a player, your hit die is dependent on your class. Sage is a background.

## beginner – Adding random numbers to the python dice game

I was asked to code the following programme in an assignmnet. After i created it my proffesor asked to meet the foolowing requirements. Can anyone please help me to modify it.

1. The program should welcome the user and ask how many players (1…4).
2. The program should explain briefly the rules of the game.
3. Depending on the game each player should have their “turn” and the results displayed.
4. The program should keep a record of the winner of the game.
5. After the results are displayed the user should be asked if they wish to play again.
6. If they answer ‘y’ then the program should repeat from the beginning.
7. Random Numbers should be added automatically(use import random or else) not manually.

THE GAME (Odd/even)
-Each player rolls four dice,
-For each odd number rolled the number is subtracted from their total,
-For each even number rolled the number is added to their total,
-Even numbered dice can be rerolled (once) if the player wants to try to get a higher score.
-The highest total wins.

``````replay="y"
throws=4
while(replay=="y"):
points=()
print("...welcome...")
print("Each player rolls four dice")
print("For each odd number rolled the number is subtracted from their total")
print("For each even number rolled the number is added to their total")
print("Even numbered dice can be rerolled (once) if the player wants to try to get a higher score.")
print("The highest total wins.")

players=int(input("Number of players(1..4) :"))
for j in range(0,players):
print("...Player",j+1,"...")
for k in range(1,throws+1):
n=int(input("value obtained :"))
if(k==1):
if(n%2!=0):
points.append(-n)
else:
points.append(n)
continue
if(n%2!=0):
points(j)=points(j)-n
else:
d=input("reroll(y/n)?")
if(d=="y"):
n-int(input("value obtained :"))
if(n%2!=0):
points(j)=points(j)-n
else:
points(j)=points(j)+n
else:
points(j)=points(j)+n
print("Player",j+1,"total is",points(j))
maxpoints=max(points)
winner=points.index(maxpoints)
print("...Winner is player",winner+1,"!!...")
replay+input("play again(y/n)?")
``````

## beginner – How to write a 4 player odd/even dice game in python

Each player rolls four dice,
For each odd number rolled the number is subtracted from their total,
For each even number rolled the number is added to their total,
Even numbered dice can be rerolled (once) if the player wants to try to get a higher score.
The highest total wins

1. The program should welcome the user and ask how many players (1…4).
2. The program should explain briefly the rules of the game.
3. Depending on the game each player should have their “turn” and the results displayed.
4. The program should keep a record of the winner of the game.
5. After the results are displayed the user should be asked if they wish to play again.
6. If they answer ‘y’ then the program should repeat from the beginning.

import random

def main():

``````player1 = 0

player2 = 0

player3 = 0

player4 = 0
``````

## dice – D10 alternative long diameter

dice – D10 alternative long diameter – Role-playing Games Stack Exchange

## random – This code is a non-static C# class for rolling a number of dice

Fellow human beings, today I present to you my dice rolling script! Behold, in my amateurish attempt at some raw C# code. Perhaps this will remain here regardless of the dozens of other dice rolling scripts out there.

### Contains a ‘for’ loop, a ‘switch’, and a method that returns a value.

I have indeed read through other, similar iterations of this class, and I have found them to be lacking in what I might learn from, usually due to over-complication for my tiny brain, or because it invoked the use of libraries I have yet to hear of.

I did my best to make it easy to read for whichever intrigued person stumbles upon this. I deeply respect and appreciate any who may take the time to offer any criticism on my code. What did I do right? What did I do wrong? I don’t have anyone or anywhere else to share it with.

``````using System;

namespace C_
{
class RollDice : Program
{

//Variables

int numOfDice;
int numOfSides;

int maxDice = 100;
int minDice = 1;
int maxSides = 100;
int minSides = 1;
int totalRolled;

//Start method for number of Dice to throw - take the player input in InputMethod() which returns an int. If returning 0, then restart. Clamp the value between min/max. Continue to next function.

public void GetDice()
{
Console.WriteLine("Welcome to Roll Dice!");
Console.WriteLine("How many dice do you want to throw?");
numOfDice = InputMethod();
if(numOfDice == 0)
{
GetDice();
}
if (numOfDice > maxDice || numOfDice < minDice)
{
numOfDice = Math.Clamp(numOfDice, minDice, maxDice);
Console.WriteLine(\$"Number of Dice set to {numOfDice}");
}

GetSides();
}

// Get the sides of each dice by using a similar process. Roll() for each dice, then sum the totals in RollTotal().

public void GetSides()
{
Console.WriteLine("How many sides does each dice have?");
numOfSides = InputMethod();
if(numOfSides == 0)
{
GetSides();
}
if (numOfSides > maxSides || numOfSides < minSides)
{
numOfSides = Math.Clamp(numOfSides, minSides, maxSides);
Console.WriteLine(\$"Number of Sides set to {numOfSides}");
}

for (int x = 1; x <= numOfDice; x++)
{
Roll();
}

RollTotal();
}

// Create a new Random() instance for the number of sides and add it to the totalRolled variable.

public void Roll()
{
Console.WriteLine(".....");
Console.WriteLine("Rolling");
Random r = new Random();
var result = r.Next(1, numOfSides + 1);
Console.WriteLine(\$"You rolled {result}");
totalRolled += result;
}

// Output the total and prompt to roll again or quit. Reset the total..

public void RollTotal()
{
Console.WriteLine(\$"Total sum rolled is {totalRolled}");
Console.WriteLine(" ");
Console.WriteLine("Enter 1 to re-roll or 2 to quit.");

{
case 0:
RollTotal();
break;

case 1:
totalRolled = 0;
GetDice();
break;

case 2:
totalRolled = 0;
Environment.Exit(0);
break;

default:
Environment.Exit(0);
break;
}
}

//Convert the input to an integer if valid and return the value. Else return 0.

public int InputMethod()
{
if(!Int32.TryParse(input, out int convertedStringToInt))

{
Console.WriteLine("You need to enter a valid number!");
return 0;
}

else

{
return Convert.ToInt32(input);
}

}

}
}
``````

## dnd 5e – Does the Elemental Adept (fire) feat let you reroll non-fire damage dice?

I think we are all in agreement that the Elemental Adept (Fire) Feat, Rules as Written, should allow for the potentially increased damage to the radiant damage portion of Flame Strike.

The divide comes for those who consider the Feat not clearly worded, and Rules as Intended to exclude the radiant damage dice.

In reflecting on how other rulings might help us think about this, what comes to my mind are the rulings on Critical hits and “extra damage”.

How does extra damage work for critical hits?

If an exceptionally well-placed sword blow (slashing) is intended to allow a paladin extra damage dice on the subsequent Divine Smite (radiant), that to me is enough to argue that the elemental (fire) feat is intended to apply to the additional radiant damage as well, unless and until something specifically disallowing it is official.

## dnd beyond – How do dndbeyond.com’s dice work?

dnd beyond – How do dndbeyond.com’s dice work? – Role-playing Games Stack Exchange

## No, they are not fair unless you ignore the sides

There are a few requirements for a uniform solid die to be fair.

## The active sides must be face-transitive.

Dice are only fair if all of the sides that are being used are equally likely to be landed on. In order for this to be true, it needs to be face-transitive, meaning all the sides are the same shape. More specifically…

Isohedral Figure

In geometry, a polytope of dimension 3 (a polyhedron) or higher is isohedral or face-transitive when all its faces are the same. More specifically, all faces must be not merely congruent but must be transitive, i.e. must lie within the same symmetry orbit. In other words, for any faces A and B, there must be a symmetry of the entire solid by rotations and reflections that maps A onto B. For this reason, convex isohedral polyhedra are the shapes that will make fair dice.

Isotoxal Figure

Regular Polyhedra are isohedral (face-transitive), isogonal (vertex-transitive) and isotoxal (edge transitive).

This 7 sided die is neither of those things. But it is if we ignore every result on the pentagonal sides.

Put another way, given a face on the die, there must be a rotation (at least one) that results in every other face, edge, and vertex being mapped onto the same place as a different face, edge, and vertex, respectively. Let’s try it in 2-d. This makes a good 2 dimensional die. Rotating the triangle 120 degrees around the center maps every vertex and edge of the triangle to another one. Let’s take that to 3 dimensions, say a cube. A d6. We’re all familiar. A d6 is a fair die because there exists at least one rotation that results in each face, edge, and vertex being mapped onto the location of a different one. One of those rotations would obviously be a rotation that can be represented by “90 degrees on one axis, and 90 degrees on another”. Or, in Euler Angles, 90, 90, 0. Or, if it helps, 90 degrees pitch, and 90 degrees yaw. Or any combination of pitch, yaw, and roll.

All other fair dice have this property. A rotation exists that maps every face, edge, and vertex of a d4 onto a different face, edge, and vertex. There exists one for a d20. There are in fact, many rotations that do this for these fair dice. But there is no rotation that does this for a d7. You could spin it 180 degrees around the “up” axis (sitting on neither 6 or 7), but then the top edge would not have been translated into the position of another edge. You could lay it flat on 6 and spin it 72 degrees, but then the pentagonal faces would not have been translated into another face.

## The center of each face must be equidistant to the center of mass.

When it comes to (fair) dice, the centre of mass is in the exact centre of the object. This means all the faces are equidistant from it. The result of this is, after a roll, every face has equal opportunity to come up. However, if the centre of mass is moved from the geographical centre of the die, then the axis of rotation is changed, and the die is no longer fair. source

Changing the center of mass is known as weighting the die. As the centre of mass is moved further from the middle of the die, the effectively lighter face will roll upwards more often than not.

## Making fair dice by ignoring faces

Dice with an odd number of flat faces can be made as “long dice”.(26) They are based on an infinite set of prisms. All the (rectangular) faces they may actually land on are congruent, so they are equally fair. (The other 2 sides of the prism are rounded or capped with a pyramid, designed so that the die never actually rests on those faces) Source

That last sentence is the most important part. This 7 sided die is fair for ranges 1-5, provided you ignore the 6 and 7th face. As we read above, any prism can be fair provided the ends are “capped” or ignored (see Long Dice). So, a real d7 would be made of a heptagonal prism. So, ignoring the ends, there exists a rotation that maps every face, vertex, and edge onto the location of a different face, edge, and vertex. Lets go back to that example above. We lay it flat on the 6th edge and spin it 72 degrees. Voila! Each of the faces is now in the location of where a face used to be, each edge is in the place of where a different edge was, and each vertex is in the place of a different vertex. Except for the caps, which we’ve ignored.

More recently, you may have noticed barrel dice. They use the same basic principle, except their sides are triangles rather than rectangles. ## Why don’t non-symmetric unorthodox shapes work?

The result of the die being face-transitive and having a center of mass equidistant from the centers of the faces is that it requires the same amount of force in one direction to turn it over no matter what face it has landed on. When we look back at the d7, we can easily guess that applying force to go from face 1 to face 2 is the same amount of force that will change it from face 2 to face 3 as it rests on the table. This is due to the fact that the angles between the faces are the same, and because the faces are the same on those sides. There is as much surface area touching the table when “1” is up as there is when “2” is up. Let us consider faces 6 and 7.

When face 6 is up, face 7 is down. There is now a greater surface area on the table. Moreover, the angle between face 6 and any other face touching it is greater (90 degrees versus 72 degrees). Both of these mean that it requires more force to push it onto one of the other faces. So when the die is tumbling and face 6 or 7 hits the table near the end of the tumble and loses some of its velocity and rotational velocity, it is more likely that X amount of force will not result in the die tumbling over that face to land on 1-5.

## dice – 100 sides vs 10 sides

dice – 100 sides vs 10 sides – Role-playing Games Stack Exchange

## dnd 5e – What is the maximum amount of dice needed to play DnD

If I would like to be prepared to play any character build and roll any die only once. What is the maximum amount of dice that I would need to get.

The highest I have heard so far would be 144 d6 (meteor swarm, blast fire ball)
But whats the maximum of the other dice needed?