LambdaHack-0.11.0.1: A game engine library for tactical squad ASCII roguelike dungeon crawlers

Safe Haskell | None
Language | Haskell2010

Game.LambdaHack.Common.Time

Contents

- Internal operations

Description

Game time and speed.

Synopsis

- data Time
- timeTicks :: Time -> Int64
- timeZero :: Time
- timeEpsilon :: Time
- timeClip :: Time
- timeTurn :: Time
- timeSecond :: Time
- clipsInTurn :: Int
- absoluteTimeAdd :: Time -> Time -> Time
- absoluteTimeSubtract :: Time -> Time -> Time
- absoluteTimeNegate :: Time -> Time
- timeFit :: Time -> Time -> Int
- timeFitUp :: Time -> Time -> Int
- timeRecent5 :: Time -> Time -> Bool
- newtype Delta a = Delta a
- timeShift :: Time -> Delta Time -> Time
- timeDeltaToFrom :: Time -> Time -> Delta Time
- timeDeltaAdd :: Delta Time -> Delta Time -> Delta Time
- timeDeltaSubtract :: Delta Time -> Delta Time -> Delta Time
- timeDeltaReverse :: Delta Time -> Delta Time
- timeDeltaScale :: Delta Time -> Int -> Delta Time
- timeDeltaPercent :: Delta Time -> Int -> Delta Time
- timeDeltaDiv :: Delta Time -> Int -> Delta Time
- timeDeltaToDigit :: Delta Time -> Delta Time -> Char
- timeDeltaInSecondsText :: Delta Time -> Text
- data Speed
- toSpeed :: Int -> Speed
- fromSpeed :: Speed -> Int
- minSpeed :: Int
- displaySpeed :: Int -> String
- speedWalk :: Speed
- speedLimp :: Speed
- speedThrust :: Speed
- modifyDamageBySpeed :: Int64 -> Speed -> Int64
- speedScale :: Rational -> Speed -> Speed
- speedAdd :: Speed -> Speed -> Speed
- ticksPerMeter :: Speed -> Delta Time
- speedFromWeight :: Int -> Int -> Speed
- rangeFromSpeedAndLinger :: Speed -> Int -> Int
- _timeTick :: Time
- turnsInSecond :: Int64
- sInMs :: Int64
- minimalSpeed :: Int64
- rangeFromSpeed :: Speed -> Int

# Documentation

data Time Source #

Game time in ticks. The time dimension. One tick is 1 microsecond (one millionth of a second), one turn is 0.5 s.

#### Instances

Instances details

Binary Time Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods put :: Time -> Put Source # get :: Get Time Source # putList :: [Time] -> Put Source #
Show Time Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods showsPrec :: Int -> Time -> ShowS Source # show :: Time -> String Source # showList :: [Time] -> ShowS Source #
Eq Time Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods (==) :: Time -> Time -> Bool Source # (/=) :: Time -> Time -> Bool Source #
Ord Time Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods compare :: Time -> Time -> Ordering Source # (<) :: Time -> Time -> Bool Source # (<=) :: Time -> Time -> Bool Source # (>) :: Time -> Time -> Bool Source # (>=) :: Time -> Time -> Bool Source # max :: Time -> Time -> Time Source # min :: Time -> Time -> Time Source #

timeTicks :: Time -> Int64 Source #

timeZero :: Time Source #

Start of the game time, or zero lenght time interval.

timeEpsilon :: Time Source #

An infinitesimal time period.

timeClip :: Time Source #

At least once per clip all moves are resolved and a frame or a frame delay is generated. Currently one clip is 0.05 s, but it may change, and the code should not depend on this fixed value.

timeTurn :: Time Source #

One turn is 0.5 s. The code may depend on that. Actors at normal speed (2 m/s) take one turn to move one tile (1 m by 1 m).

timeSecond :: Time Source #

This many ticks fits in a single second.

clipsInTurn :: Int Source #

This many clips fit in one turn. Determines the resolution of actor move sampling and display updates.

absoluteTimeAdd :: Time -> Time -> Time Source #

Absolute time addition, e.g., for summing the total game session time from the times of individual games.

absoluteTimeSubtract :: Time -> Time -> Time Source #

absoluteTimeNegate :: Time -> Time Source #

Absolute time negation. To be used for reversing time flow, e.g., for comparing absolute times in the reverse order.

timeFit :: Time -> Time -> Int Source #

How many time intervals of the latter kind fits in an interval of the former kind.

timeFitUp :: Time -> Time -> Int Source #

How many time intervals of the latter kind cover an interval of the former kind (rounded up).

timeRecent5 :: Time -> Time -> Bool Source #

newtype Delta a Source #

One-dimentional vectors. Introduced to tell apart the 2 uses of Time: as an absolute game time and as an increment.

Constructors

Delta a |

#### Instances

Instances details

Functor Delta Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods fmap :: (a -> b) -> Delta a -> Delta b Source # (<$) :: a -> Delta b -> Delta a Source #
Binary a => Binary (Delta a) Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods put :: Delta a -> Put Source # get :: Get (Delta a) Source # putList :: [Delta a] -> Put Source #
Show a => Show (Delta a) Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods showsPrec :: Int -> Delta a -> ShowS Source # show :: Delta a -> String Source # showList :: [Delta a] -> ShowS Source #
Eq a => Eq (Delta a) Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods (==) :: Delta a -> Delta a -> Bool Source # (/=) :: Delta a -> Delta a -> Bool Source #
Ord a => Ord (Delta a) Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods compare :: Delta a -> Delta a -> Ordering Source # (<) :: Delta a -> Delta a -> Bool Source # (<=) :: Delta a -> Delta a -> Bool Source # (>) :: Delta a -> Delta a -> Bool Source # (>=) :: Delta a -> Delta a -> Bool Source # max :: Delta a -> Delta a -> Delta a Source # min :: Delta a -> Delta a -> Delta a Source #

timeShift :: Time -> Delta Time -> Time Source #

Shifting an absolute time by a time vector.

timeDeltaToFrom :: Time -> Time -> Delta Time Source #

Time time vector between the second and the first absolute times. The arguments are in the same order as in the underlying scalar subtraction.

timeDeltaAdd :: Delta Time -> Delta Time -> Delta Time Source #

Addition of time deltas.

timeDeltaSubtract :: Delta Time -> Delta Time -> Delta Time Source #

Subtraction of time deltas. The arguments are in the same order as in the underlying scalar subtraction.

timeDeltaReverse :: Delta Time -> Delta Time Source #

Reverse a time vector.

timeDeltaScale :: Delta Time -> Int -> Delta Time Source #

Scale the time vector by an `Int` scalar value.

timeDeltaPercent :: Delta Time -> Int -> Delta Time Source #

Take the given percent of the time vector.

timeDeltaDiv :: Delta Time -> Int -> Delta Time Source #

Divide a time vector.

timeDeltaToDigit :: Delta Time -> Delta Time -> Char Source #

Represent the main 10 thresholds of a time range by digits, given the total length of the time range.

timeDeltaInSecondsText :: Delta Time -> Text Source #

data Speed Source #

Speed in meters per 1 million seconds (m/Ms). Actors at normal speed (2 m/s) take one time turn (0.5 s) to make one step (move one tile, which is 1 m by 1 m).

#### Instances

Instances details

Binary Speed Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods put :: Speed -> Put Source # get :: Get Speed Source # putList :: [Speed] -> Put Source #
Show Speed Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods showsPrec :: Int -> Speed -> ShowS Source # show :: Speed -> String Source # showList :: [Speed] -> ShowS Source #
Eq Speed Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods (==) :: Speed -> Speed -> Bool Source # (/=) :: Speed -> Speed -> Bool Source #
Ord Speed Source # |
Instance details Defined in Game.LambdaHack.Common.Time Methods compare :: Speed -> Speed -> Ordering Source # (<) :: Speed -> Speed -> Bool Source # (<=) :: Speed -> Speed -> Bool Source # (>) :: Speed -> Speed -> Bool Source # (>=) :: Speed -> Speed -> Bool Source # max :: Speed -> Speed -> Speed Source # min :: Speed -> Speed -> Speed Source #

toSpeed :: Int -> Speed Source #

Constructor for content definitions.

fromSpeed :: Speed -> Int Source #

Readable representation of speed in the format used in content definitions.

minSpeed :: Int Source #

displaySpeed :: Int -> String Source #

Pretty-print speed given in the format used in content definitions.

speedWalk :: Speed Source #

Fast walk speed (2 m/s) that suffices to move one tile in one turn.

speedLimp :: Speed Source #

Limp speed (1 m/s) that suffices to move one tile in two turns. This is the minimal speed for projectiles to fly just one space and drop.

speedThrust :: Speed Source #

Sword thrust speed (10 m/s). Base weapon damages, both melee and ranged, are given assuming this speed and ranged damage is modified accordingly when projectile speeds differ. Differences in melee weapon swing speeds are captured in damage bonuses instead, since many other factors influence total damage.

Billiard ball is 25 ms, sword swing at the tip is 35 ms, medieval bow is 70 ms, AK47 is 700 ms.

modifyDamageBySpeed :: Int64 -> Speed -> Int64 Source #

Modify damage when projectiles is at a non-standard speed. Energy and so damage is proportional to the square of speed, hence the formula.

speedScale :: Rational -> Speed -> Speed Source #

Scale speed by a scalar value.

speedAdd :: Speed -> Speed -> Speed Source #

Speed addition.

ticksPerMeter :: Speed -> Delta Time Source #

The number of time ticks it takes to walk 1 meter at the given speed.

speedFromWeight :: Int -> Int -> Speed Source #

Calculate projectile speed from item weight in grams and velocity percent modifier. See https://github.com/LambdaHack/LambdaHack/wiki/Item-statistics.

rangeFromSpeedAndLinger :: Speed -> Int -> Int Source #

Calculate maximum range taking into account the linger percentage.

# Internal operations

_timeTick :: Time Source #

The smallest unit of time. Should not be exported and used elsewhere, because the proportion of turn to tick is an implementation detail. The significance of this detail is only that it determines resolution of the time dimension.

turnsInSecond :: Int64 Source #

This many turns fit in a single second.

sInMs :: Int64 Source #

Number of seconds in a mega-second.

minimalSpeed :: Int64 Source #

The minimal speed is half a meter (half a step across a tile) per second (two standard turns, which the time span during which projectile moves, unless it has modified linger value). This is four times slower than standard human movement speed.

It needen't be lower, because `rangeFromSpeed` gives 0 steps with such speed, so the actor's trajectory is empty, so it drops down at once. Twice that speed already moves a normal projectile one step before it stops. It shouldn't be lower or a slow actor would incur such a time debt for performing a single action that he'd be paralyzed for many turns, e.g., leaving his dead body on the screen for very long.

rangeFromSpeed :: Speed -> Int Source #

Calculate maximum range in meters of a projectile from its speed. See https://github.com/LambdaHack/LambdaHack/wiki/Item-statistics. With this formula, each projectile flies for at most 1 second, that is 2 standard turns, and then drops to the ground.