Game.LambdaHack.Server.Fov

Field Of View scanning with a variety of algorithms. See https://github.com/LambdaHack/LambdaHack/wiki/Fov-and-los for discussion.

Perception cache

data FovValid a

Constructors

FovValid !a

FovInvalid

Instances

Eq a => Eq (FovValid a)

Methods

(==) :: FovValid a -> FovValid a -> Bool

(/=) :: FovValid a -> FovValid a -> Bool

Show a => Show (FovValid a)

Methods

showsPrec :: Int -> FovValid a -> ShowS

show :: FovValid a -> String

showList :: [FovValid a] -> ShowS

type PerValidFid = EnumMap FactionId (EnumMap LevelId Bool)

Main perception validity map, for all factions.

newtype PerReachable

Visually reachable positions (light passes through them to the actor). They need to be intersected with lucid positions to obtain visible positions.

Constructors

PerReachable

Fields

• preachable :: EnumSet Point

Instances

Eq PerReachable

Methods

(==) :: PerReachable -> PerReachable -> Bool

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

Show PerReachable

Methods

showsPrec :: Int -> PerReachable -> ShowS

show :: PerReachable -> String

showList :: [PerReachable] -> ShowS

data CacheBeforeLucid

Constructors

CacheBeforeLucid

Fields

• creachable :: !PerReachable
• cnocto :: !PerVisible
• csmell :: !PerSmelled

Instances

Eq CacheBeforeLucid

Methods

(==) :: CacheBeforeLucid -> CacheBeforeLucid -> Bool

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

Show CacheBeforeLucid

Methods

showsPrec :: Int -> CacheBeforeLucid -> ShowS

show :: CacheBeforeLucid -> String

showList :: [CacheBeforeLucid] -> ShowS

type PerActor = EnumMap ActorId (FovValid CacheBeforeLucid)

data PerceptionCache

Constructors

PerceptionCache

Fields

• ptotal :: !(FovValid CacheBeforeLucid)
• perActor :: !PerActor

Instances

Eq PerceptionCache

Methods

(==) :: PerceptionCache -> PerceptionCache -> Bool

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

Show PerceptionCache

Methods

showsPrec :: Int -> PerceptionCache -> ShowS

show :: PerceptionCache -> String

showList :: [PerceptionCache] -> ShowS

type PerCacheLid = EnumMap LevelId PerceptionCache

Server cache of perceptions of a single faction, indexed by level identifier.

type PerCacheFid = EnumMap FactionId PerCacheLid

Server cache of perceptions, indexed by faction identifier.

Data used in FOV computation and cached to speed it up

newtype FovShine

Map from level positions that currently hold item or actor(s) with shine to the maximum of radiuses of the shining lights.

Note: ActorAspect and FovShine shoudn't be in State, because on client they need to be updated every time an item discovery is made, unlike on the server, where it's much simpler and cheaper. BTW, floor and (many projectile) actors light on a single tile should be additive for FovShine to be incrementally updated.

FovShine should not even be kept in StateServer, because it's cheap to compute, compared to FovLucid and invalidated almost as often (not invalidated only by UpdAlterTile).

Constructors

FovShine

Fields

• fovShine :: EnumMap Point Int

Instances

Eq FovShine

Methods

(==) :: FovShine -> FovShine -> Bool

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

Show FovShine

Methods

showsPrec :: Int -> FovShine -> ShowS

show :: FovShine -> String

showList :: [FovShine] -> ShowS

newtype FovLucid

Level positions with either ambient light or shining items or actors.

Constructors

FovLucid

Fields

• fovLucid :: EnumSet Point

Instances

Eq FovLucid

Methods

(==) :: FovLucid -> FovLucid -> Bool

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

Show FovLucid

Methods

showsPrec :: Int -> FovLucid -> ShowS

show :: FovLucid -> String

showList :: [FovLucid] -> ShowS

type FovLucidLid = EnumMap LevelId (FovValid FovLucid)

newtype FovClear

Level positions that pass through light and vision.

Constructors

FovClear

Fields

• fovClear :: Array Bool

Instances

Eq FovClear

Methods

(==) :: FovClear -> FovClear -> Bool

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

Show FovClear

Methods

showsPrec :: Int -> FovClear -> ShowS

show :: FovClear -> String

showList :: [FovClear] -> ShowS

type FovClearLid = EnumMap LevelId FovClear

newtype FovLit

Level positions with tiles that have ambient light.

Constructors

FovLit

Fields

• fovLit :: EnumSet Point

Instances

Eq FovLit

Methods

(==) :: FovLit -> FovLit -> Bool

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

Show FovLit

Methods

showsPrec :: Int -> FovLit -> ShowS

show :: FovLit -> String

showList :: [FovLit] -> ShowS

type FovLitLid = EnumMap LevelId FovLit

Update of invalidated Fov data

perceptionFromPTotal :: FovLucid -> CacheBeforeLucid -> Perception

Compute positions visible (reachable and seen) by the party. A position is lucid, if it's lit by an ambient light or by a weak, portable light source, e.g,, carried by an actor. A reachable and lucid position is visible. Additionally, positions directly adjacent to an actor are assumed to be visible to him (through sound, touch, noctovision, whatever).

perActorFromLevel :: PerActor -> (ActorId -> Actor) -> ActorAspect -> FovClear -> PerActor

totalFromPerActor :: PerActor -> CacheBeforeLucid

lucidFromLevel :: DiscoveryAspect -> ActorAspect -> FovClearLid -> FovLitLid -> State -> LevelId -> Level -> FovLucid

Update lights on the level. This is needed every (even enemy) actor move to show thrown torches. We need to update lights even if cmd doesn't change any perception, so that for next cmd that does, but doesn't change lights, and operates on the same level, the lights are up to date. We could make lights lazy to ensure no computation is wasted, but it's rare that cmd changed them, but not the perception (e.g., earthquake in an uninhabited corner of the active arena, but the we'd probably want some feedback, at least sound).

Computation of initial perception and caches

perFidInDungeon :: DiscoveryAspect -> State -> (ActorAspect, FovLitLid, FovClearLid, FovLucidLid, PerValidFid, PerCacheFid, PerFid)

Calculate the perception and its caches for the whole dungeon.

aspectRecordFromActorServer :: DiscoveryAspect -> Actor -> AspectRecord

boundSightByCalm :: Int -> Int64 -> Int

Internal operations

cacheBeforeLucidFromActor :: FovClear -> Actor -> AspectRecord -> CacheBeforeLucid

Compute positions reachable by the actor. Reachable are all fields on a visually unblocked path from the actor position. Also compute positions seen by noctovision and perceived by smell.

perceptionCacheFromLevel :: ActorAspect -> FovClearLid -> FactionId -> LevelId -> State -> PerceptionCache

perLidFromFaction :: ActorAspect -> FovLucidLid -> FovClearLid -> FactionId -> State -> (PerLid, PerCacheLid)

Calculate perception of a faction.

clearFromLevel :: COps -> Level -> FovClear

clearInDungeon :: State -> FovClearLid

litFromLevel :: COps -> Level -> FovLit

litInDungeon :: State -> FovLitLid

shineFromLevel :: DiscoveryAspect -> ActorAspect -> State -> LevelId -> Level -> FovShine

floorLightSources :: DiscoveryAspect -> Level -> [(Point, Int)]

lucidFromItems :: FovClear -> [(Point, Int)] -> [FovLucid]

Compute all dynamically lit positions on a level, whether lit by actors or shining floor items. Note that an actor can be blind, in which case he doesn't see his own light (but others, from his or other factions, possibly do).

lucidInDungeon :: DiscoveryAspect -> ActorAspect -> FovClearLid -> FovLitLid -> State -> FovLucidLid

The actual Fov algorithm

fullscan

Arguments

:: FovClear

the array with clear points

-> Int

scanning radius

-> Point

position of the spectator

-> EnumSet Point

Perform a full scan for a given position. Returns the positions that are currently in the field of view. The Field of View algorithm to use is passed in the second argument. The actor's own position is considred reachable by him.