Safe Haskell | None |
---|

Game time and speed.

- data Time
- timeZero :: Time
- timeClip :: Time
- timeTurn :: Time
- timeEpsilon :: Time
- absoluteTimeAdd :: Time -> Time -> Time
- absoluteTimeNegate :: Time -> Time
- timeFit :: Time -> Time -> Int
- timeFitUp :: Time -> Time -> Int
- newtype Delta a = Delta a
- timeShift :: Time -> Delta Time -> Time
- timeDeltaToFrom :: Time -> Time -> Delta Time
- timeDeltaReverse :: Delta Time -> Delta Time
- timeDeltaScale :: Delta Time -> Int -> Delta Time
- timeDeltaToDigit :: Delta Time -> Delta Time -> Char
- ticksPerMeter :: Speed -> Delta Time
- data Speed
- toSpeed :: Int -> Speed
- fromSpeed :: Speed -> Int
- speedZero :: Speed
- speedNormal :: Speed
- speedScale :: Rational -> Speed -> Speed
- speedAdd :: Speed -> Speed -> Speed
- speedNegate :: Speed -> Speed
- speedFromWeight :: Int -> Int -> Speed
- rangeFromSpeed :: Speed -> Int
- rangeFromSpeedAndLinger :: Speed -> Int -> Int

# Documentation

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

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

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).

An infinitesimal time period.

absoluteTimeAdd :: Time -> Time -> TimeSource

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

absoluteTimeNegate :: Time -> TimeSource

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

timeFit :: Time -> Time -> IntSource

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

timeFitUp :: Time -> Time -> IntSource

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

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

Delta a |

timeDeltaToFrom :: Time -> Time -> Delta TimeSource

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

timeDeltaScale :: Delta Time -> Int -> Delta TimeSource

Scale the time vector by an `Int`

scalar value.

timeDeltaToDigit :: Delta Time -> Delta Time -> CharSource

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

ticksPerMeter :: Speed -> Delta TimeSource

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

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

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

speedScale :: Rational -> Speed -> SpeedSource

Scale speed by an `Int`

scalar value.

speedNegate :: Speed -> SpeedSource

Speed negation.

speedFromWeight :: Int -> Int -> SpeedSource

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

rangeFromSpeed :: Speed -> IntSource

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 turns, and then drops to the ground.

rangeFromSpeedAndLinger :: Speed -> Int -> IntSource

Calculate maximum range taking into account the linger percentage.