-- | Definitions of place kinds. Every room in the game is an instantiated
-- place kind.
module Content.PlaceKind
  ( -- * Group name patterns
    pattern ROGUE, pattern LABORATORY, pattern ZOO, pattern BRAWL, pattern SHOOTOUT, pattern ARENA, pattern ESCAPE, pattern AMBUSH, pattern BATTLE, pattern NOISE, pattern MINE, pattern EMPTY
  , pattern INDOOR_ESCAPE_DOWN, pattern INDOOR_ESCAPE_UP, pattern OUTDOOR_ESCAPE_DOWN, pattern TINY_STAIRCASE, pattern OPEN_STAIRCASE, pattern CLOSED_STAIRCASE, pattern WALLED_STAIRCASE, pattern GATED_TINY_STAIRCASE, pattern GATED_OPEN_STAIRCASE, pattern GATED_CLOSED_STAIRCASE, pattern OUTDOOR_TINY_STAIRCASE, pattern OUTDOOR_CLOSED_STAIRCASE, pattern OUTDOOR_WALLED_STAIRCASE
  , groupNamesSingleton, groupNames
  , -- * Content
    content
  ) where

import Prelude ()

import Game.LambdaHack.Core.Prelude

import qualified Data.Text as T

import Content.TileKind hiding (content, groupNames, groupNamesSingleton)
import Game.LambdaHack.Content.PlaceKind
import Game.LambdaHack.Content.TileKind (TileKind)
import Game.LambdaHack.Definition.Defs

-- * Group name patterns

groupNamesSingleton :: [GroupName PlaceKind]
groupNamesSingleton :: [GroupName PlaceKind]
groupNamesSingleton = []

-- TODO: if we stick to the current system of generating extra kinds and their
-- group names, let's also add the generated group names to @groupNames@.
groupNames :: [GroupName PlaceKind]
groupNames :: [GroupName PlaceKind]
groupNames =
       [GroupName PlaceKind
ROGUE, GroupName PlaceKind
LABORATORY, GroupName PlaceKind
ZOO, GroupName PlaceKind
BRAWL, GroupName PlaceKind
SHOOTOUT, GroupName PlaceKind
ARENA, GroupName PlaceKind
ESCAPE, GroupName PlaceKind
AMBUSH, GroupName PlaceKind
BATTLE, GroupName PlaceKind
NOISE, GroupName PlaceKind
MINE, GroupName PlaceKind
EMPTY]
    [GroupName PlaceKind]
-> [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a. [a] -> [a] -> [a]
++ [GroupName PlaceKind
INDOOR_ESCAPE_DOWN, GroupName PlaceKind
INDOOR_ESCAPE_UP, GroupName PlaceKind
OUTDOOR_ESCAPE_DOWN, GroupName PlaceKind
TINY_STAIRCASE, GroupName PlaceKind
OPEN_STAIRCASE, GroupName PlaceKind
CLOSED_STAIRCASE, GroupName PlaceKind
WALLED_STAIRCASE]
    [GroupName PlaceKind]
-> [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a. [a] -> [a] -> [a]
++ ([GroupName PlaceKind], [PlaceKind]) -> [GroupName PlaceKind]
forall a b. (a, b) -> a
fst ([GroupName PlaceKind], [PlaceKind])
generatedStairs

pattern ROGUE, LABORATORY, ZOO, BRAWL, SHOOTOUT, ARENA, ESCAPE, AMBUSH, BATTLE, NOISE, MINE, EMPTY :: GroupName PlaceKind

pattern INDOOR_ESCAPE_DOWN, INDOOR_ESCAPE_UP, OUTDOOR_ESCAPE_DOWN, TINY_STAIRCASE, OPEN_STAIRCASE, CLOSED_STAIRCASE, WALLED_STAIRCASE, GATED_TINY_STAIRCASE, GATED_OPEN_STAIRCASE, GATED_CLOSED_STAIRCASE, OUTDOOR_TINY_STAIRCASE, OUTDOOR_CLOSED_STAIRCASE, OUTDOOR_WALLED_STAIRCASE :: GroupName PlaceKind

pattern $bROGUE :: GroupName PlaceKind
$mROGUE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
ROGUE = GroupName "rogue"
pattern $bLABORATORY :: GroupName PlaceKind
$mLABORATORY :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
LABORATORY = GroupName "laboratory"
pattern $bZOO :: GroupName PlaceKind
$mZOO :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
ZOO = GroupName "zoo"
pattern $bBRAWL :: GroupName PlaceKind
$mBRAWL :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
BRAWL = GroupName "brawl"
pattern $bSHOOTOUT :: GroupName PlaceKind
$mSHOOTOUT :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
SHOOTOUT = GroupName "shootout"
pattern $bARENA :: GroupName PlaceKind
$mARENA :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
ARENA = GroupName "arena"
pattern $bESCAPE :: GroupName PlaceKind
$mESCAPE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
ESCAPE = GroupName "escape"
pattern $bAMBUSH :: GroupName PlaceKind
$mAMBUSH :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
AMBUSH = GroupName "ambush"
pattern $bBATTLE :: GroupName PlaceKind
$mBATTLE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
BATTLE = GroupName "battle"
pattern $bNOISE :: GroupName PlaceKind
$mNOISE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
NOISE = GroupName "noise"
pattern $bMINE :: GroupName PlaceKind
$mMINE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
MINE = GroupName "mine"
pattern $bEMPTY :: GroupName PlaceKind
$mEMPTY :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
EMPTY = GroupName "empty"

pattern $bINDOOR_ESCAPE_DOWN :: GroupName PlaceKind
$mINDOOR_ESCAPE_DOWN :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
INDOOR_ESCAPE_DOWN = GroupName "escape down"
pattern $bINDOOR_ESCAPE_UP :: GroupName PlaceKind
$mINDOOR_ESCAPE_UP :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
INDOOR_ESCAPE_UP = GroupName "escape up"
pattern $bOUTDOOR_ESCAPE_DOWN :: GroupName PlaceKind
$mOUTDOOR_ESCAPE_DOWN :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
OUTDOOR_ESCAPE_DOWN = GroupName "outdoor escape route"
pattern $bTINY_STAIRCASE :: GroupName PlaceKind
$mTINY_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
TINY_STAIRCASE = GroupName "tiny staircase"
pattern $bOPEN_STAIRCASE :: GroupName PlaceKind
$mOPEN_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
OPEN_STAIRCASE = GroupName "open staircase"
pattern $bCLOSED_STAIRCASE :: GroupName PlaceKind
$mCLOSED_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
CLOSED_STAIRCASE = GroupName "closed staircase"
pattern $bWALLED_STAIRCASE :: GroupName PlaceKind
$mWALLED_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
WALLED_STAIRCASE = GroupName "walled staircase"

-- This is a rotten compromise, because these are synthesized below,
-- so typos can happen.
pattern $bGATED_TINY_STAIRCASE :: GroupName PlaceKind
$mGATED_TINY_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
GATED_TINY_STAIRCASE = GroupName "gated tiny staircase"
pattern $bGATED_OPEN_STAIRCASE :: GroupName PlaceKind
$mGATED_OPEN_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
GATED_OPEN_STAIRCASE = GroupName "gated open staircase"
pattern $bGATED_CLOSED_STAIRCASE :: GroupName PlaceKind
$mGATED_CLOSED_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
GATED_CLOSED_STAIRCASE = GroupName "gated closed staircase"
pattern $bOUTDOOR_TINY_STAIRCASE :: GroupName PlaceKind
$mOUTDOOR_TINY_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
OUTDOOR_TINY_STAIRCASE = GroupName "outdoor tiny staircase"
pattern $bOUTDOOR_CLOSED_STAIRCASE :: GroupName PlaceKind
$mOUTDOOR_CLOSED_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
OUTDOOR_CLOSED_STAIRCASE = GroupName "outdoor closed staircase"
pattern $bOUTDOOR_WALLED_STAIRCASE :: GroupName PlaceKind
$mOUTDOOR_WALLED_STAIRCASE :: forall r. GroupName PlaceKind -> (Void# -> r) -> (Void# -> r) -> r
OUTDOOR_WALLED_STAIRCASE = GroupName "outdoor walled staircase"

-- * Content

content :: [PlaceKind]
content :: [PlaceKind]
content =
  [PlaceKind
deadEnd, PlaceKind
rect, PlaceKind
rect2, PlaceKind
rect3, PlaceKind
rect4, PlaceKind
rectWindows, PlaceKind
glasshouse, PlaceKind
glasshouse2, PlaceKind
glasshouse3, PlaceKind
pulpit, PlaceKind
ruin, PlaceKind
ruin2, PlaceKind
collapsed, PlaceKind
collapsed2, PlaceKind
collapsed3, PlaceKind
collapsed4, PlaceKind
collapsed5, PlaceKind
collapsed6, PlaceKind
collapsed7, PlaceKind
pillar, PlaceKind
pillar2, PlaceKind
pillar3, PlaceKind
pillar4, PlaceKind
pillar5, PlaceKind
colonnade, PlaceKind
colonnade2, PlaceKind
colonnade3, PlaceKind
colonnade4, PlaceKind
colonnade5, PlaceKind
colonnade6, PlaceKind
lampPost, PlaceKind
lampPost2, PlaceKind
lampPost3, PlaceKind
lampPost4, PlaceKind
treeShade, PlaceKind
fogClump, PlaceKind
fogClump2, PlaceKind
smokeClump, PlaceKind
smokeClump2, PlaceKind
smokeClump3FGround, PlaceKind
bushClump, PlaceKind
bushClump2, PlaceKind
escapeDown, PlaceKind
escapeDown2, PlaceKind
escapeDown3, PlaceKind
escapeDown4, PlaceKind
escapeDown5, PlaceKind
staircase1, PlaceKind
staircase2, PlaceKind
staircase3, PlaceKind
staircase4, PlaceKind
staircase5, PlaceKind
staircase6, PlaceKind
staircase7, PlaceKind
staircase8, PlaceKind
staircase9, PlaceKind
staircase10, PlaceKind
staircase11, PlaceKind
staircase12, PlaceKind
staircase13, PlaceKind
staircase14, PlaceKind
staircase15, PlaceKind
staircase16, PlaceKind
staircase17, PlaceKind
staircase18, PlaceKind
staircase19, PlaceKind
staircase20, PlaceKind
staircase21, PlaceKind
staircase22, PlaceKind
staircase23, PlaceKind
staircase24, PlaceKind
staircase25, PlaceKind
staircase26, PlaceKind
staircase27, PlaceKind
staircase28, PlaceKind
staircase29, PlaceKind
staircase30, PlaceKind
staircase31, PlaceKind
staircase32, PlaceKind
staircase33, PlaceKind
staircase34, PlaceKind
staircase35, PlaceKind
staircase36, PlaceKind
staircase37]
  -- automatically generated
  [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ ([GroupName PlaceKind], [PlaceKind]) -> [PlaceKind]
forall a b. (a, b) -> b
snd ([GroupName PlaceKind], [PlaceKind])
generatedStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
generatedEscapes

deadEnd,    rect, rect2, rect3, rect4, rectWindows, glasshouse, glasshouse2, glasshouse3, pulpit, ruin, ruin2, collapsed, collapsed2, collapsed3, collapsed4, collapsed5, collapsed6, collapsed7, pillar, pillar2, pillar3, pillar4, pillar5, colonnade, colonnade2, colonnade3, colonnade4, colonnade5, colonnade6, lampPost, lampPost2, lampPost3, lampPost4, treeShade, fogClump, fogClump2, smokeClump, smokeClump2, smokeClump3FGround, bushClump, bushClump2, escapeDown, escapeDown2, escapeDown3, escapeDown4, escapeDown5, staircase1, staircase2, staircase3, staircase4, staircase5, staircase6, staircase7, staircase8, staircase9, staircase10, staircase11, staircase12, staircase13, staircase14, staircase15, staircase16, staircase17, staircase18, staircase19, staircase20, staircase21, staircase22, staircase23, staircase24, staircase25, staircase26, staircase27, staircase28, staircase29, staircase30, staircase31, staircase32, staircase33, staircase34, staircase35, staircase36, staircase37 :: PlaceKind

staircase :: PlaceKind  -- template

staircaseBasic :: [PlaceKind]
staircaseBasic :: [PlaceKind]
staircaseBasic = [PlaceKind
staircase1, PlaceKind
staircase2, PlaceKind
staircase3, PlaceKind
staircase4, PlaceKind
staircase5, PlaceKind
staircase6, PlaceKind
staircase7, PlaceKind
staircase8, PlaceKind
staircase9, PlaceKind
staircase10, PlaceKind
staircase11, PlaceKind
staircase12, PlaceKind
staircase13, PlaceKind
staircase14, PlaceKind
staircase15, PlaceKind
staircase16, PlaceKind
staircase17, PlaceKind
staircase18, PlaceKind
staircase19, PlaceKind
staircase20, PlaceKind
staircase21, PlaceKind
staircase22, PlaceKind
staircase23, PlaceKind
staircase24, PlaceKind
staircase25, PlaceKind
staircase26, PlaceKind
staircase27, PlaceKind
staircase28, PlaceKind
staircase29, PlaceKind
staircase30, PlaceKind
staircase31, PlaceKind
staircase32, PlaceKind
staircase33, PlaceKind
staircase34, PlaceKind
staircase35, PlaceKind
staircase36, PlaceKind
staircase37]

generatedStairs :: ([GroupName PlaceKind], [PlaceKind])
generatedStairs :: ([GroupName PlaceKind], [PlaceKind])
generatedStairs =
  let gatedStairs :: [PlaceKind]
gatedStairs = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToGated [PlaceKind]
staircaseBasic
      outdoorStairs :: [PlaceKind]
outdoorStairs = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToOutdoor [PlaceKind]
staircaseBasic
      stairsAll :: [PlaceKind]
stairsAll = [PlaceKind]
staircaseBasic [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
gatedStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
outdoorStairs
      upStairs :: [PlaceKind]
upStairs = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToUp [PlaceKind]
stairsAll
      downStairs :: [PlaceKind]
downStairs = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToDown [PlaceKind]
stairsAll
      genStairs :: [PlaceKind]
genStairs = [PlaceKind]
gatedStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
outdoorStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
upStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
downStairs
  in ( [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a. Eq a => [a] -> [a]
nub ([GroupName PlaceKind] -> [GroupName PlaceKind])
-> [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a b. (a -> b) -> a -> b
$ [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a. Ord a => [a] -> [a]
sort ([GroupName PlaceKind] -> [GroupName PlaceKind])
-> [GroupName PlaceKind] -> [GroupName PlaceKind]
forall a b. (a -> b) -> a -> b
$ (PlaceKind -> [GroupName PlaceKind])
-> [PlaceKind] -> [GroupName PlaceKind]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (((GroupName PlaceKind, Int) -> GroupName PlaceKind)
-> [(GroupName PlaceKind, Int)] -> [GroupName PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map (GroupName PlaceKind, Int) -> GroupName PlaceKind
forall a b. (a, b) -> a
fst ([(GroupName PlaceKind, Int)] -> [GroupName PlaceKind])
-> (PlaceKind -> [(GroupName PlaceKind, Int)])
-> PlaceKind
-> [GroupName PlaceKind]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq) [PlaceKind]
genStairs
     , [PlaceKind]
genStairs )

escapeDownBasic :: [PlaceKind]
escapeDownBasic :: [PlaceKind]
escapeDownBasic =
  [PlaceKind
escapeDown, PlaceKind
escapeDown2, PlaceKind
escapeDown3, PlaceKind
escapeDown4, PlaceKind
escapeDown5]

generatedEscapes :: [PlaceKind]
generatedEscapes :: [PlaceKind]
generatedEscapes =
  let upEscapes :: [PlaceKind]
upEscapes = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchEscapeToUp [PlaceKind]
escapeDownBasic
      outdoorEscapes :: [PlaceKind]
outdoorEscapes = (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchEscapeToOutdoorDown [PlaceKind]
escapeDownBasic
  in [PlaceKind]
upEscapes [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
outdoorEscapes

-- The dots below are @'\x00B7'@, as defined in @TileKind.floorSymbol@.
deadEnd :: PlaceKind
deadEnd = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind  -- needs to have index 0
  { psymbol :: Char
psymbol  = 'd'
  , pname :: Text
pname    = "a dead end"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = []
  , prarity :: Rarity
prarity  = []
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = ["·"]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
rect :: PlaceKind
rect = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind  -- Valid for any nonempty area, hence low frequency.
  { psymbol :: Char
psymbol  = 'r'
  , pname :: Text
pname    = "a chamber"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 30), (GroupName PlaceKind
LABORATORY, 10)]
  , prarity :: Rarity
prarity  = [(1, 10), (10, 6)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "--"
               , "|·"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
rect2 :: PlaceKind
rect2 = PlaceKind
rect
  { pname :: Text
pname    = "a pen"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ZOO, 3)]
  }
rect3 :: PlaceKind
rect3 = PlaceKind
rect
  { pname :: Text
pname    = "a shed"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
BRAWL, 10), (GroupName PlaceKind
SHOOTOUT, 1)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('|', GroupName TileKind
S_WALL_LIT)  -- visible from afar
                    , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', GroupName TileKind
S_WALL_LIT)
                   , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  }
rect4 :: PlaceKind
rect4 = PlaceKind
rect3
  { pname :: Text
pname    = "cabinet"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ARENA, 10)]
  }
rectWindows :: PlaceKind
rectWindows = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'w'
  , pname :: Text
pname    = "a hut"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ESCAPE, 10), (GroupName PlaceKind
AMBUSH, 7)]
  , prarity :: Rarity
prarity  = [(1, 10), (10, 10)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-="
               , "!·"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('=', GroupName TileKind
RECT_WINDOWS_HORIZONTAL_DARK)
                    , ('!', GroupName TileKind
RECT_WINDOWS_VERTICAL_DARK) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', GroupName TileKind
RECT_WINDOWS_HORIZONTAL_LIT)
                   , ('!', GroupName TileKind
RECT_WINDOWS_VERTICAL_LIT) ]
  }
glasshouse :: PlaceKind
glasshouse = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'g'
  , pname :: Text
pname    = "a glasshouse"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
SHOOTOUT, 4)]
  , prarity :: Rarity
prarity  = [(1, 10), (10, 7)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "=="
               , "!·"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)  -- visible from afar
                    , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
                   , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT) ]
  }
glasshouse2 :: PlaceKind
glasshouse2 = PlaceKind
glasshouse
  { pname :: Text
pname    = "a glass cage"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ZOO, 10)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_DARK)
                    , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_DARK) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
                   , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT) ]
  }
glasshouse3 :: PlaceKind
glasshouse3 = PlaceKind
glasshouse
  { pname :: Text
pname    = "a reading room"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ARENA, 40)]
  }
pulpit :: PlaceKind
pulpit = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'p'
  , pname :: Text
pname    = "a stand dais"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ARENA, 200), (GroupName PlaceKind
ZOO, 200)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "==·"
               , "!··"
               , "··0"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
                    , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT)
                    , ('0', GroupName TileKind
S_PULPIT) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
                   , ('!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT)
                   , ('0', GroupName TileKind
S_PULPIT) ]
      -- except for floor, this will all be lit, regardless of night/dark; OK
  }
ruin :: PlaceKind
ruin = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'R'
  , pname :: Text
pname    = "ruins"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
BATTLE, 330)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "--"
               , "|X"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
ruin2 :: PlaceKind
ruin2 = PlaceKind
ruin
  { pname :: Text
pname    = "blasted walls"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
AMBUSH, 50)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('|', GroupName TileKind
S_WALL_LIT)  -- visible from afar
                    , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', GroupName TileKind
S_WALL_LIT)
                   , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  }
collapsed :: PlaceKind
collapsed = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'c'
  , pname :: Text
pname    = "a collapsed cavern"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 1)]
      -- no point taking up space if very little space taken,
      -- but if no other place can be generated, a failsafe is useful
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "0"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
collapsed2 :: PlaceKind
collapsed2 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 1000), (GroupName PlaceKind
BATTLE, 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "X0"
               , "00"
               ]
  }
collapsed3 :: PlaceKind
collapsed3 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 2000), (GroupName PlaceKind
BATTLE, 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "XX0"
               , "000"
               ]
  }
collapsed4 :: PlaceKind
collapsed4 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 2000), (GroupName PlaceKind
BATTLE, 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "0000"
               ]
  }
collapsed5 :: PlaceKind
collapsed5 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 3000), (GroupName PlaceKind
BATTLE, 500)]
  , ptopLeft :: [Text]
ptopLeft = [ "XX0"
               , "X00"
               , "000"
               ]
  }
collapsed6 :: PlaceKind
collapsed6 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 4000), (GroupName PlaceKind
BATTLE, 1000)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "X000"
               , "0000"
               ]
  }
collapsed7 :: PlaceKind
collapsed7 = PlaceKind
collapsed
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
NOISE, 4000), (GroupName PlaceKind
BATTLE, 1000)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "XX00"
               , "0000"
               ]
  }
pillar :: PlaceKind
pillar = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'p'
  , pname :: Text
pname    = "a hall"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 600), (GroupName PlaceKind
LABORATORY, 2000)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CStretch
  , pfence :: Fence
pfence   = Fence
FNone
  -- Larger rooms require support pillars.
  , ptopLeft :: [Text]
ptopLeft = [ "----"
               , "|···"
               , "|·0·"
               , "|···"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
pillar2 :: PlaceKind
pillar2 = PlaceKind
pillar
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 60), (GroupName PlaceKind
LABORATORY, 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "----"
               , "|0··"
               , "|···"
               , "|···"
               ]
  }
pillar3 :: PlaceKind
pillar3 = PlaceKind
pillar
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 8000), (GroupName PlaceKind
LABORATORY, 25000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|0···"
               , "|····"
               , "|··0·"
               , "|····"
               ]
  }
pillar4 :: PlaceKind
pillar4 = PlaceKind
pillar
  { pname :: Text
pname    = "an exquisite hall"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 30000), (GroupName PlaceKind
LABORATORY, 100000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|&·0·"
               , "|····"
               , "|0·0·"
               , "|····"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('&', GroupName TileKind
CACHE)]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('&', GroupName TileKind
CACHE)]
  }
pillar5 :: PlaceKind
pillar5 = PlaceKind
pillar
  { pname :: Text
pname    = "a decorated hall"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ROGUE, 30000), (GroupName PlaceKind
LABORATORY, 100000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|&·0·"
               , "|····"
               , "|0···"
               , "|····"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('&', GroupName TileKind
CACHE)]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('&', GroupName TileKind
CACHE)]
  }
colonnade :: PlaceKind
colonnade = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'c'
  , pname :: Text
pname    = "a colonnade"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [ (GroupName PlaceKind
ROGUE, 3), (GroupName PlaceKind
ARENA, 20), (GroupName PlaceKind
LABORATORY, 2)
               , (GroupName PlaceKind
EMPTY, 10000), (GroupName PlaceKind
MINE, 1000), (GroupName PlaceKind
BRAWL, 4)
               , (GroupName PlaceKind
ESCAPE, 40), (GroupName PlaceKind
AMBUSH, 40) ]
  , prarity :: Rarity
prarity  = [(1, 10), (10, 10)]
  , pcover :: Cover
pcover   = Cover
CAlternate
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·"
               , "··"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = []
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = []
  }
colonnade2 :: PlaceKind
colonnade2 = PlaceKind
colonnade
  { prarity :: Rarity
prarity  = [(1, 15), (10, 15)]
  , ptopLeft :: [Text]
ptopLeft = [ "0·"
               , "·0"
               ]
  }
colonnade3 :: PlaceKind
colonnade3 = PlaceKind
colonnade
  { prarity :: Rarity
prarity  = [(1, 800), (10, 800)]
  , ptopLeft :: [Text]
ptopLeft = [ "··0"
               , "·0·"
               , "0··"
               ]
  }
colonnade4 :: PlaceKind
colonnade4 = PlaceKind
colonnade
  { prarity :: Rarity
prarity  = [(1, 200), (10, 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "0··"
               , "·0·"
               , "··0"
               ]
  }
colonnade5 :: PlaceKind
colonnade5 = PlaceKind
colonnade
  { prarity :: Rarity
prarity  = [(1, 10), (10, 10)]
  , ptopLeft :: [Text]
ptopLeft = [ "0··"
               , "··0"
               ]
  }
colonnade6 :: PlaceKind
colonnade6 = PlaceKind
colonnade
  { prarity :: Rarity
prarity  = [(1, 100), (10, 100)]
  , ptopLeft :: [Text]
ptopLeft = [ "0·"
               , "··"
               , "·0"
               ]
  }
lampPost :: PlaceKind
lampPost = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'l'
  , pname :: Text
pname    = "a lamp-lit area"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ESCAPE, 200), (GroupName PlaceKind
AMBUSH, 200), (GroupName PlaceKind
ZOO, 100), (GroupName PlaceKind
BATTLE, 100)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CVerbatim
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "X·X"
               , "·0·"
               , "X·X"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('0', GroupName TileKind
S_LAMP_POST), ('·', GroupName TileKind
S_FLOOR_ACTOR_LIT)]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('0', GroupName TileKind
S_LAMP_POST), ('·', GroupName TileKind
S_FLOOR_ACTOR_LIT)]
  }
lampPost2 :: PlaceKind
lampPost2 = PlaceKind
lampPost
  { ptopLeft :: [Text]
ptopLeft = [ "···"
               , "·0·"
               , "···"
               ]
  }
lampPost3 :: PlaceKind
lampPost3 = PlaceKind
lampPost
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [ (GroupName PlaceKind
ESCAPE, 3000), (GroupName PlaceKind
AMBUSH, 3000), (GroupName PlaceKind
ZOO, 50)
               , (GroupName PlaceKind
BATTLE, 110) ]
  , ptopLeft :: [Text]
ptopLeft = [ "XX·XX"
               , "X···X"
               , "··0··"
               , "X···X"
               , "XX·XX"
               ]
  }
lampPost4 :: PlaceKind
lampPost4 = PlaceKind
lampPost
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ESCAPE, 3000), (GroupName PlaceKind
AMBUSH, 3000), (GroupName PlaceKind
ZOO, 50), (GroupName PlaceKind
BATTLE, 60)]
  , ptopLeft :: [Text]
ptopLeft = [ "X···X"
               , "·····"
               , "··0··"
               , "·····"
               , "X···X"
               ]
  }
treeShade :: PlaceKind
treeShade = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 't'
  , pname :: Text
pname    = "a tree shade"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
BRAWL, 1000)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "··s"
               , "s0·"
               , "Xs·"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('0', GroupName TileKind
S_TREE_DARK)
                    , ('s', GroupName TileKind
TREE_SHADE_WALKABLE_DARK)
                    , ('·', GroupName TileKind
S_SHADED_GROUND) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('0', GroupName TileKind
S_TREE_LIT)
                   , ('s', GroupName TileKind
TREE_SHADE_WALKABLE_LIT)
                   , ('·', GroupName TileKind
S_SHADED_GROUND) ]
  }
fogClump :: PlaceKind
fogClump = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'f'
  , pname :: Text
pname    = "a foggy patch"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
SHOOTOUT, 150), (GroupName PlaceKind
EMPTY, 15)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "f;"
               , ";f"
               , ";X"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('f', GroupName TileKind
FOG_CLUMP_DARK), (';', GroupName TileKind
S_FOG_LIT)]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('f', GroupName TileKind
FOG_CLUMP_LIT), (';', GroupName TileKind
S_FOG_LIT)]
  }
fogClump2 :: PlaceKind
fogClump2 = PlaceKind
fogClump
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
SHOOTOUT, 500), (GroupName PlaceKind
EMPTY, 50)]
  , ptopLeft :: [Text]
ptopLeft = [ "X;f"
               , "f;f"
               , ";;f"
               , "Xff"
               ]
  }
smokeClump :: PlaceKind
smokeClump = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 's'
  , pname :: Text
pname    = "a smoky patch"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ZOO, 50)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "f;"
               , ";f"
               , ";X"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('f', GroupName TileKind
SMOKE_CLUMP_DARK), (';', GroupName TileKind
S_SMOKE_LIT)
                    , ('·', GroupName TileKind
S_FLOOR_ACTOR_DARK) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('f', GroupName TileKind
SMOKE_CLUMP_LIT), (';', GroupName TileKind
S_SMOKE_LIT)
                   , ('·', GroupName TileKind
S_FLOOR_ACTOR_LIT) ]
  }
smokeClump2 :: PlaceKind
smokeClump2 = PlaceKind
smokeClump
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
ZOO, 500)]
  , ptopLeft :: [Text]
ptopLeft = [ "X;f"
               , "f;f"
               , ";;f"
               , "Xff"
               ]
  }
smokeClump3FGround :: PlaceKind
smokeClump3FGround = PlaceKind
smokeClump
  { pname :: Text
pname    = "a burned out area"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
LABORATORY, 150)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CVerbatim
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ ";f;"
               , "f·f"
               , "f·f"
               , ";f;"
               ]
      -- should not be used in caves with trails, because bushes should
      -- not grow over such artificial trails
  }
bushClump :: PlaceKind
bushClump = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'b'
  , pname :: Text
pname    = "a bushy patch"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
SHOOTOUT, 40)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "Xf"  -- one sure exit needed not to block a corner
               , ";X"
               , ";;"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('f', GroupName TileKind
BUSH_CLUMP_DARK), (';', GroupName TileKind
S_BUSH_LIT)]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('f', GroupName TileKind
BUSH_CLUMP_LIT), (';', GroupName TileKind
S_BUSH_LIT)]
      -- should not be used in caves with trails, because bushes can't
      -- grow over such artificial trails
  }
bushClump2 :: PlaceKind
bushClump2 = PlaceKind
bushClump
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
SHOOTOUT, 80)]
  , ptopLeft :: [Text]
ptopLeft = [ "Xf"  -- one sure exit needed not to block a corner
               , ";X"
               , ";X"
               , ";;"
               ]
  }
escapeDown :: PlaceKind
escapeDown = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = '>'
  , pname :: Text
pname    = "an escape down"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, 1)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CVerbatim
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ ">"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('|', GroupName TileKind
S_WALL_LIT)  -- visible from afar
                    , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', GroupName TileKind
S_WALL_LIT)
                   , ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
  }
escapeDown2 :: PlaceKind
escapeDown2 = PlaceKind
escapeDown
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, 1000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0"
               , "·>·"
               , "0·0"
               ]
  }
escapeDown3 :: PlaceKind
escapeDown3 = PlaceKind
escapeDown
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, 2000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|0·0|"
               , "|·>·|"
               , "|0·0|"
               , "-----"
               ]
  }
escapeDown4 :: PlaceKind
escapeDown4 = PlaceKind
escapeDown
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, 1000)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0··"
               , "·>·"
               , "··0"
               ]
  }
escapeDown5 :: PlaceKind
escapeDown5 = PlaceKind
escapeDown
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, 2000)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|0··|"
               , "|·>·|"
               , "|0·0|"
               , "-----"
               ]
  }
staircase :: PlaceKind
staircase = $WPlaceKind :: Char
-> Text
-> [(GroupName PlaceKind, Int)]
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = '/'
  , pname :: Text
pname    = "a staircase"
  , pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
TINY_STAIRCASE, 1)]  -- no cover when arriving; low freq
  , prarity :: Rarity
prarity  = [(1, 100), (10, 100)]
  , pcover :: Cover
pcover   = Cover
CVerbatim
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "<·>"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('<', GroupName TileKind
STAIRCASE_UP), ('>', GroupName TileKind
STAIRCASE_DOWN)
                    , ('I', GroupName TileKind
SIGNBOARD)
                    , ('|', GroupName TileKind
S_WALL_LIT), ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
                      -- seen from afar
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('<', GroupName TileKind
STAIRCASE_UP), ('>', GroupName TileKind
STAIRCASE_DOWN)
                   , ('I', GroupName TileKind
SIGNBOARD)
                   , ('|', GroupName TileKind
S_WALL_LIT), ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
                     -- seen from afar
  }
staircase1 :: PlaceKind
staircase1 = PlaceKind
staircase
  { prarity :: Rarity
prarity  = [(1, 1)]  -- no cover when arriving; so low rarity
  }
staircase2 :: PlaceKind
staircase2 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
TINY_STAIRCASE, 3)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "·<·>·"
               ]
  }
staircase3 :: PlaceKind
staircase3 = PlaceKind
staircase
  { prarity :: Rarity
prarity  = [(1, 1)]
  , pfence :: Fence
pfence   = Fence
FFloor
  }
staircase4 :: PlaceKind
staircase4 = PlaceKind
staircase2
  { pfence :: Fence
pfence   = Fence
FFloor
  , prarity :: Rarity
prarity  = [(1, 1)]
  }
staircase5 :: PlaceKind
staircase5 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 200)]  -- no cover, open
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·0"
               , "···"
               , "<·>"
               , "···"
               , "0·0"
               ]
  }
staircase6 :: PlaceKind
staircase6 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 300)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0"
               , "·····"
               , "·<·>·"
               , "·····"
               , "0·0·0"
               ]
  }
staircase7 :: PlaceKind
staircase7 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 500)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0·0"
               , "·······"
               , "0·<·>·0"
               , "·······"
               , "0·0·0·0"
               ]
  }
staircase8 :: PlaceKind
staircase8 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 2000)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "·0·I·0·"
               , "0·····0"
               , "··<·>··"
               , "0·····0"
               , "·0·0·0·"
               ]
  }
staircase9 :: PlaceKind
staircase9 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 500)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·······0"
               , "···<·>···"
               , "0·······0"
               ]
  }
staircase10 :: PlaceKind
staircase10 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
OPEN_STAIRCASE, 500)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·····0"
               , "··<·>··"
               , "0·····0"
               ]
  }
staircase11 :: PlaceKind
staircase11 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 2000)]  -- weak cover, low freq
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·"
               , "0·0"
               , "···"
               , "<·>"
               , "···"
               , "0·0"
               , "·0·"
               ]
  }
staircase12 :: PlaceKind
staircase12 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 4000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·0·"
               , "0·0·0"
               , "·····"
               , "·<·>·"
               , "·····"
               , "0·0·0"
               , "·0·0·"
               ]
  }
staircase13 :: PlaceKind
staircase13 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 6000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·0·0·"
               , "0·0·0·0"
               , "·······"
               , "0·<·>·0"
               , "·······"
               , "0·0·0·0"
               , "·0·0·0·"
               ]
  }
staircase14 :: PlaceKind
staircase14 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 10000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0·0"
               , "·0·0·0·"
               , "0·····0"
               , "··<·>··"
               , "0·····0"
               , "·0·0·0·"
               , "0·0·0·0"
               ]
  }
staircase15 :: PlaceKind
staircase15 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 20000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·0·0·0·"
               , "0·0·0·0·0"
               , "·0·····0·"
               , "0··<·>··0"
               , "·0·····0·"
               , "0·0·0·0·0"
               , "·0·0·0·0·"
               ]
  }
staircase16 :: PlaceKind
staircase16 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 20000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0·0·0"
               , "·0·0·0·0·"
               , "0·······0"
               , "·0·<·>·0·"
               , "0·······0"
               , "·0·0·0·0·"
               , "0·0·0·0·0"
               ]
  }
staircase17 :: PlaceKind
staircase17 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 20000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0·0·0·0"
               , "·0·0·0·0·0·"
               , "0·0·····0·0"
               , "·0··<·>··0·"
               , "0·0·····0·0"
               , "·0·0·0·0·0·"
               , "0·0·0·0·0·0"
               ]
  }
staircase18 :: PlaceKind
staircase18 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 80000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "··0·0·0·0··"
               , "·0·0·0·0·0·"
               , "0·0·····0·0"
               , "·0··<·>··0·"
               , "0·0·····0·0"
               , "·0·0·0·0·0·"
               , "··0·0·0·0··"
               ]
  }
staircase19 :: PlaceKind
staircase19 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 20000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·0·0·0·0·"
               , "0·0·0·0·0·0"
               , "·0·······0·"
               , "0·0·<·>·0·0"
               , "·0·······0·"
               , "0·0·0·0·0·0"
               , "·0·0·0·0·0·"
               ]
  }
staircase20 :: PlaceKind
staircase20 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 5000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·0·0·0·0·"
               , "0·0·····0·0"
               , "·0··<·>··0·"
               , "0·0·····0·0"
               , "·0·0·I·0·0·"
               ]
  }
staircase21 :: PlaceKind
staircase21 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 5000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·I·0·0"
               , "·0·····0·"
               , "0··<·>··0"
               , "·0·····0·"
               , "0·0·0·0·0"
               ]
  }
staircase22 :: PlaceKind
staircase22 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 2000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·····0·0"
               , "·0··<·>··0·"
               , "0·0·····0·0"
               ]
  }
staircase23 :: PlaceKind
staircase23 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 1000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·······0·"
               , "0·0·<·>·0·0"
               , "·0·······0·"
               ]
  }
staircase24 :: PlaceKind
staircase24 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
CLOSED_STAIRCASE, 1000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·····0·"
               , "0··<·>··0"
               , "·0·····0·"
               ]
  }
staircase25 :: PlaceKind
staircase25 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 10)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "-------"
               ]
  }
staircase26 :: PlaceKind
staircase26 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 50)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "---------"
               ]
  }
staircase27 :: PlaceKind
staircase27 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 100)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|0·····0|"
               , "|··<·>··|"
               , "|0·····0|"
               , "---------"
               ]
  }
staircase28 :: PlaceKind
staircase28 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|·····|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|·····|"
               , "-------"
               ]
  }
staircase29 :: PlaceKind
staircase29 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|0···0|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|0···0|"
               , "-------"
               ]
  }
staircase30 :: PlaceKind
staircase30 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|0·0·0|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|0·0·0|"
               , "-------"
               ]
  }
staircase31 :: PlaceKind
staircase31 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 2000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|·······|"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "|·······|"
               , "---------"
               ]
  }
staircase32 :: PlaceKind
staircase32 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 5000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|0·····0|"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "|0·····0|"
               , "---------"
               ]
  }
staircase33 :: PlaceKind
staircase33 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 5000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|0·0·0·0|"
               , "|·······|"
               , "|0·<·>·0|"
               , "|·······|"
               , "|0·0·0·0|"
               , "---------"
               ]
  }
staircase34 :: PlaceKind
staircase34 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 5000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|·0·0·0·|"
               , "|0·····0|"
               , "|··<·>··|"
               , "|0·····0|"
               , "|·0·I·0·|"
               , "---------"
               ]
  }
staircase35 :: PlaceKind
staircase35 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 200)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----------"
               , "|·········|"
               , "|···<·>···|"
               , "|·········|"
               , "-----------"
               ]
  }
staircase36 :: PlaceKind
staircase36 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 500)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----------"
               , "|·0·····0·|"
               , "|0··<·>··0|"
               , "|·0·····0·|"
               , "-----------"
               ]
  }
staircase37 :: PlaceKind
staircase37 = PlaceKind
staircase
  { pfreq :: [(GroupName PlaceKind, Int)]
pfreq    = [(GroupName PlaceKind
WALLED_STAIRCASE, 500)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----------"
               , "|0·······0|"
               , "|·0·<·>·0·|"
               , "|0·······0|"
               , "-----------"
               ]
  }

switchStaircaseToUp :: PlaceKind -> PlaceKind
switchStaircaseToUp :: PlaceKind -> PlaceKind
switchStaircaseToUp s :: PlaceKind
s = PlaceKind
s
 { psymbol :: Char
psymbol   = '<'
 , pname :: Text
pname     = PlaceKind -> Text
pname PlaceKind
s Text -> Text -> Text
<+> "up"
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(t :: GroupName PlaceKind
t, k :: Int
k) -> (Text -> GroupName PlaceKind
forall a. Text -> GroupName a
GroupName (Text -> GroupName PlaceKind) -> Text -> GroupName PlaceKind
forall a b. (a -> b) -> a -> b
$ GroupName PlaceKind -> Text
forall a. GroupName a -> Text
fromGroupName GroupName PlaceKind
t Text -> Text -> Text
<+> "up", Int
k))
               ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', GroupName TileKind
STAIR_TERMINAL_DARK)
                   (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: ((Char, GroupName TileKind) -> Bool)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '>') (Char -> Bool)
-> ((Char, GroupName TileKind) -> Char)
-> (Char, GroupName TileKind)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, GroupName TileKind) -> Char
forall a b. (a, b) -> a
fst) (PlaceKind -> [(Char, GroupName TileKind)]
poverrideDark PlaceKind
s)
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = ('>', GroupName TileKind
STAIR_TERMINAL_LIT)
                  (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: ((Char, GroupName TileKind) -> Bool)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '>') (Char -> Bool)
-> ((Char, GroupName TileKind) -> Char)
-> (Char, GroupName TileKind)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, GroupName TileKind) -> Char
forall a b. (a, b) -> a
fst) (PlaceKind -> [(Char, GroupName TileKind)]
poverrideLit PlaceKind
s)
 }

switchStaircaseToDown :: PlaceKind -> PlaceKind
switchStaircaseToDown :: PlaceKind -> PlaceKind
switchStaircaseToDown s :: PlaceKind
s = PlaceKind
s
 { psymbol :: Char
psymbol   = '>'
 , pname :: Text
pname     = PlaceKind -> Text
pname PlaceKind
s Text -> Text -> Text
<+> "down"
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(t :: GroupName PlaceKind
t, k :: Int
k) -> (Text -> GroupName PlaceKind
forall a. Text -> GroupName a
GroupName (Text -> GroupName PlaceKind) -> Text -> GroupName PlaceKind
forall a b. (a -> b) -> a -> b
$ GroupName PlaceKind -> Text
forall a. GroupName a -> Text
fromGroupName GroupName PlaceKind
t Text -> Text -> Text
<+> "down", Int
k))
               ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('<', GroupName TileKind
STAIR_TERMINAL_DARK)
                   (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: ((Char, GroupName TileKind) -> Bool)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '<') (Char -> Bool)
-> ((Char, GroupName TileKind) -> Char)
-> (Char, GroupName TileKind)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, GroupName TileKind) -> Char
forall a b. (a, b) -> a
fst) (PlaceKind -> [(Char, GroupName TileKind)]
poverrideDark PlaceKind
s)
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = ('<', GroupName TileKind
STAIR_TERMINAL_LIT)
                  (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: ((Char, GroupName TileKind) -> Bool)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '<') (Char -> Bool)
-> ((Char, GroupName TileKind) -> Char)
-> (Char, GroupName TileKind)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, GroupName TileKind) -> Char
forall a b. (a, b) -> a
fst) (PlaceKind -> [(Char, GroupName TileKind)]
poverrideLit PlaceKind
s)
 }

overrideGated :: [(Char, GroupName TileKind)]
overrideGated :: [(Char, GroupName TileKind)]
overrideGated =
  [ ('<', GroupName TileKind
GATED_STAIRCASE_UP), ('>', GroupName TileKind
GATED_STAIRCASE_DOWN)
  , ('I', GroupName TileKind
SIGNBOARD)
  , ('|', GroupName TileKind
S_WALL_LIT), ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]  -- visible from afar

switchStaircaseToGated :: PlaceKind -> PlaceKind
switchStaircaseToGated :: PlaceKind -> PlaceKind
switchStaircaseToGated s :: PlaceKind
s = PlaceKind
s
 { psymbol :: Char
psymbol   = 'g'
 , pname :: Text
pname     = [Text] -> Text
T.unwords ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ "a gated" Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text] -> [Text]
forall a. [a] -> [a]
tail (Text -> [Text]
T.words (PlaceKind -> Text
pname PlaceKind
s))
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map ((GroupName PlaceKind -> GroupName PlaceKind)
-> (GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (\t :: GroupName PlaceKind
t -> Text -> GroupName PlaceKind
forall a. Text -> GroupName a
GroupName (Text -> GroupName PlaceKind) -> Text -> GroupName PlaceKind
forall a b. (a -> b) -> a -> b
$ "gated" Text -> Text -> Text
<+> GroupName PlaceKind -> Text
forall a. GroupName a -> Text
fromGroupName GroupName PlaceKind
t))
               ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [(Char, GroupName TileKind)]
overrideGated
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [(Char, GroupName TileKind)]
overrideGated
 }

overrideOutdoor :: [(Char, GroupName TileKind)]
overrideOutdoor :: [(Char, GroupName TileKind)]
overrideOutdoor =
  [ ('<', GroupName TileKind
STAIRCASE_OUTDOOR_UP), ('>', GroupName TileKind
STAIRCASE_OUTDOOR_DOWN)
  , ('I', GroupName TileKind
SIGNBOARD)
  , ('|', GroupName TileKind
S_WALL_LIT), ('-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]  -- visible from afar

switchStaircaseToOutdoor :: PlaceKind -> PlaceKind
switchStaircaseToOutdoor :: PlaceKind -> PlaceKind
switchStaircaseToOutdoor s :: PlaceKind
s = PlaceKind
s
 { psymbol :: Char
psymbol   = 'o'
 , pname :: Text
pname     = "an outdoor area exit"
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map ((GroupName PlaceKind -> GroupName PlaceKind)
-> (GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (\t :: GroupName PlaceKind
t -> Text -> GroupName PlaceKind
forall a. Text -> GroupName a
GroupName (Text -> GroupName PlaceKind) -> Text -> GroupName PlaceKind
forall a b. (a -> b) -> a -> b
$ "outdoor" Text -> Text -> Text
<+> GroupName PlaceKind -> Text
forall a. GroupName a -> Text
fromGroupName GroupName PlaceKind
t))
               ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [(Char, GroupName TileKind)]
overrideOutdoor
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [(Char, GroupName TileKind)]
overrideOutdoor
 }

switchEscapeToUp :: PlaceKind -> PlaceKind
switchEscapeToUp :: PlaceKind -> PlaceKind
switchEscapeToUp s :: PlaceKind
s = PlaceKind
s
 { psymbol :: Char
psymbol   = '<'
 , pname :: Text
pname     = "an escape up"
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(_, n :: Int
n) -> (GroupName PlaceKind
INDOOR_ESCAPE_UP, Int
n)) ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', GroupName TileKind
ESCAPE_UP) (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: PlaceKind -> [(Char, GroupName TileKind)]
poverrideDark PlaceKind
s
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = ('>', GroupName TileKind
ESCAPE_UP) (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: PlaceKind -> [(Char, GroupName TileKind)]
poverrideLit PlaceKind
s
 }

switchEscapeToOutdoorDown :: PlaceKind -> PlaceKind
switchEscapeToOutdoorDown :: PlaceKind -> PlaceKind
switchEscapeToOutdoorDown s :: PlaceKind
s = PlaceKind
s
 { pname :: Text
pname     = "outdoor escape route"
 , pfreq :: [(GroupName PlaceKind, Int)]
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(_, n :: Int
n) -> (GroupName PlaceKind
OUTDOOR_ESCAPE_DOWN, Int
n)) ([(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)])
-> [(GroupName PlaceKind, Int)] -> [(GroupName PlaceKind, Int)]
forall a b. (a -> b) -> a -> b
$ PlaceKind -> [(GroupName PlaceKind, Int)]
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', GroupName TileKind
ESCAPE_OUTDOOR_DOWN) (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: PlaceKind -> [(Char, GroupName TileKind)]
poverrideDark PlaceKind
s
 , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = ('>', GroupName TileKind
ESCAPE_OUTDOOR_DOWN) (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: PlaceKind -> [(Char, GroupName TileKind)]
poverrideLit PlaceKind
s
 }