Game.LambdaHack.Core.Dice

Representation of dice scaled with current level depth.

Frequency distribution for casting dice scaled with level depth

data Dice

Multiple dice rolls, some scaled with current level depth, in which case the sum of all rolls is scaled in proportion to current depth divided by maximal dungeon depth.

The simple dice should have positive number of rolls and number of sides.

The Num instance doesn't have abs nor signum defined, because the functions for computing infimum, supremum and mean dice results would be too costly.

Instances

Eq Dice

Defined in Game.LambdaHack.Core.Dice

Methods

(==) :: Dice -> Dice -> Bool

(/=) :: Dice -> Dice -> Bool

Num Dice

Defined in Game.LambdaHack.Core.Dice

Methods

(+) :: Dice -> Dice -> Dice

(-) :: Dice -> Dice -> Dice

(*) :: Dice -> Dice -> Dice

negate :: Dice -> Dice

abs :: Dice -> Dice

signum :: Dice -> Dice

fromInteger :: Integer -> Dice

Show Dice

Defined in Game.LambdaHack.Core.Dice

Methods

showsPrec :: Int -> Dice -> ShowS

show :: Dice -> String

showList :: [Dice] -> ShowS

newtype AbsDepth

Absolute depth in the dungeon. When used for the maximum depth of the whole dungeon, this can be different than dungeon size, e.g., when the dungeon is branched, and it can even be different than the length of the longest branch, if levels at some depths are missing.

Constructors

AbsDepth Int

Instances

Eq AbsDepth

Defined in Game.LambdaHack.Core.Dice

Methods

(==) :: AbsDepth -> AbsDepth -> Bool

(/=) :: AbsDepth -> AbsDepth -> Bool

Ord AbsDepth

Defined in Game.LambdaHack.Core.Dice

Methods

compare :: AbsDepth -> AbsDepth -> Ordering

(<) :: AbsDepth -> AbsDepth -> Bool

(<=) :: AbsDepth -> AbsDepth -> Bool

(>) :: AbsDepth -> AbsDepth -> Bool

(>=) :: AbsDepth -> AbsDepth -> Bool

max :: AbsDepth -> AbsDepth -> AbsDepth

min :: AbsDepth -> AbsDepth -> AbsDepth

Show AbsDepth

Defined in Game.LambdaHack.Core.Dice

Methods

showsPrec :: Int -> AbsDepth -> ShowS

show :: AbsDepth -> String

showList :: [AbsDepth] -> ShowS

Binary AbsDepth

Defined in Game.LambdaHack.Core.Dice

Methods

put :: AbsDepth -> Put

get :: Get AbsDepth

putList :: [AbsDepth] -> Put

castDice :: forall m. Monad m => ((Int, Int) -> m Int) -> AbsDepth -> AbsDepth -> Dice -> m Int

Cast dice scaled with current level depth. When scaling, we round up, so that the value of 1 dL 1 is 1 even at the lowest level, but so is the value of 1 dL depth.

The implementation calls RNG as many times as there are dice rolls, which is costly, so content should prefer to cast fewer dice and then multiply them by a constant. If rounded results are not desired (often they are, to limit the number of distinct item varieties in inventory), another dice may be added to the result.

A different possible implementation, with dice represented as Frequency, makes only one RNG call per dice, but due to lists lengths proportional to the maximal value of the dice, it's is intractable for 1000d1000 and problematic already for 100d100.

d :: Int -> Int -> Dice

A die, rolled the given number of times. E.g., 1 d 2 rolls 2-sided die one time.

dL :: Int -> Int -> Dice

A die rolled the given number of times, with the result scaled with dungeon level depth.

z :: Int -> Int -> Dice

A die, starting from zero, ending at one less than second argument, rolled the given number of times. E.g., 1 z 1 always rolls zero.

zL :: Int -> Int -> Dice

A die, starting from zero, ending at one less than second argument, rolled the given number of times, with the result scaled with dungeon level depth.

intToDice :: Int -> Dice

minDice :: Dice -> Dice -> Dice

maxDice :: Dice -> Dice -> Dice

infsupDice :: Dice -> (Int, Int)

Minimal and maximal possible value of the dice.

divUp in the implementation corresponds to ceiling, applied to results of meanDice elsewhere in the code, and prevents treating 1d1-power effects (on shallow levels) as null effects.

supDice :: Dice -> Int

Maximal value of dice. The scaled part taken assuming median level.

infDice :: Dice -> Int

Minimal value of dice. The scaled part taken assuming median level.

meanDice :: Dice -> Double

Mean value of dice. The scaled part taken assuming median level, but not taking into account rounding up, and so too low, especially for dice small compared to depth. To fix this, depth would need to be taken as argument.

reduceDice :: Dice -> Maybe Int

Dice for rolling a pair of integer parameters representing coordinates.

data DiceXY

Dice for rolling a pair of integer parameters pertaining to, respectively, the X and Y cartesian 2D coordinates.

Constructors

DiceXY Dice Dice

Instances

Show DiceXY

Defined in Game.LambdaHack.Core.Dice

Methods

showsPrec :: Int -> DiceXY -> ShowS

show :: DiceXY -> String

showList :: [DiceXY] -> ShowS

supDiceXY :: DiceXY -> (Int, Int)

Maximal value of DiceXY.

infDiceXY :: DiceXY -> (Int, Int)

Minimal value of DiceXY.