-- | Room, hall and passage definitions.
module Content.PlaceKind
  ( content
  ) where

import Prelude ()

import Game.LambdaHack.Core.Prelude

import qualified Data.Text as T

import Game.LambdaHack.Content.PlaceKind
import Game.LambdaHack.Content.TileKind (TileKind)
import Game.LambdaHack.Definition.Defs

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
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]
++ [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, 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 :: [PlaceKind]
generatedStairs :: [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
  in [PlaceKind]
gatedStairs [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ [PlaceKind]
outdoorStairs
     [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToUp [PlaceKind]
stairsAll
     [PlaceKind] -> [PlaceKind] -> [PlaceKind]
forall a. [a] -> [a] -> [a]
++ (PlaceKind -> PlaceKind) -> [PlaceKind] -> [PlaceKind]
forall a b. (a -> b) -> [a] -> [b]
map PlaceKind -> PlaceKind
switchStaircaseToDown [PlaceKind]
stairsAll

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 @Char.chr 183@, as defined in @TileKind.floorSymbol@.
deadEnd :: PlaceKind
deadEnd = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> 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 :: Freqs PlaceKind
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
-> Freqs PlaceKind
-> 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 :: Freqs PlaceKind
pfreq    = [("rogue", 30), ("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 :: Freqs PlaceKind
pfreq    = [("zoo", 3)]
  }
rect3 :: PlaceKind
rect3 = PlaceKind
rect
  { pname :: Text
pname    = "a shed"
  , pfreq :: Freqs PlaceKind
pfreq    = [("brawl", 10), ("shootout", 1)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('|', "wall Lit")  -- visible from afar
                    , ('-', "wallH Lit") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', "wall Lit")
                   , ('-', "wallH Lit") ]
  }
rect4 :: PlaceKind
rect4 = PlaceKind
rect3
  { pname :: Text
pname    = "cabinet"
  , pfreq :: Freqs PlaceKind
pfreq    = [("arena", 10)]
  }
rectWindows :: PlaceKind
rectWindows = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'w'
  , pname :: Text
pname    = "a hut"
  , pfreq :: Freqs PlaceKind
pfreq    = [("escape", 10), ("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 = [ ('=', "rectWindowsOver_=_Dark")
                    , ('!', "rectWindowsOver_!_Dark") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', "rectWindowsOver_=_Lit")
                   , ('!', "rectWindowsOver_!_Lit") ]
  }
glasshouse :: PlaceKind
glasshouse = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'g'
  , pname :: Text
pname    = "a glasshouse"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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 = [ ('=', "glasshouseOver_=_Lit")  -- visible from afar
                    , ('!', "glasshouseOver_!_Lit") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', "glasshouseOver_=_Lit")
                   , ('!', "glasshouseOver_!_Lit") ]
  }
glasshouse2 :: PlaceKind
glasshouse2 = PlaceKind
glasshouse
  { pname :: Text
pname    = "a glass cage"
  , pfreq :: Freqs PlaceKind
pfreq    = [("zoo", 10)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('=', "glasshouseOver_=_Dark")
                    , ('!', "glasshouseOver_!_Dark") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', "glasshouseOver_=_Lit")
                   , ('!', "glasshouseOver_!_Lit") ]
  }
glasshouse3 :: PlaceKind
glasshouse3 = PlaceKind
glasshouse
  { pname :: Text
pname    = "a reading room"
  , pfreq :: Freqs PlaceKind
pfreq    = [("arena", 40)]
  }
pulpit :: PlaceKind
pulpit = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'p'
  , pname :: Text
pname    = "a stand dais"
  , pfreq :: Freqs PlaceKind
pfreq    = [("arena", 200), ("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 = [ ('=', "glasshouseOver_=_Lit")
                    , ('!', "glasshouseOver_!_Lit")
                    , ('0', "pulpit") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('=', "glasshouseOver_=_Lit")
                   , ('!', "glasshouseOver_!_Lit")
                   , ('0', "pulpit") ]
      -- except for floor, this will all be lit, regardless of night/dark; OK
  }
ruin :: PlaceKind
ruin = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'R'
  , pname :: Text
pname    = "ruins"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("ambush", 50)]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [ ('|', "wall Lit")  -- visible from afar
                    , ('-', "wallH Lit") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', "wall Lit")
                   , ('-', "wallH Lit") ]
  }
collapsed :: PlaceKind
collapsed = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'c'
  , pname :: Text
pname    = "a collapsed cavern"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("noise", 1000), ("battle", 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "X0"
               , "00"
               ]
  }
collapsed3 :: PlaceKind
collapsed3 = PlaceKind
collapsed
  { pfreq :: Freqs PlaceKind
pfreq    = [("noise", 2000), ("battle", 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "XX0"
               , "000"
               ]
  }
collapsed4 :: PlaceKind
collapsed4 = PlaceKind
collapsed
  { pfreq :: Freqs PlaceKind
pfreq    = [("noise", 2000), ("battle", 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "0000"
               ]
  }
collapsed5 :: PlaceKind
collapsed5 = PlaceKind
collapsed
  { pfreq :: Freqs PlaceKind
pfreq    = [("noise", 3000), ("battle", 500)]
  , ptopLeft :: [Text]
ptopLeft = [ "XX0"
               , "X00"
               , "000"
               ]
  }
collapsed6 :: PlaceKind
collapsed6 = PlaceKind
collapsed
  { pfreq :: Freqs PlaceKind
pfreq    = [("noise", 4000), ("battle", 1000)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "X000"
               , "0000"
               ]
  }
collapsed7 :: PlaceKind
collapsed7 = PlaceKind
collapsed
  { pfreq :: Freqs PlaceKind
pfreq    = [("noise", 4000), ("battle", 1000)]
  , ptopLeft :: [Text]
ptopLeft = [ "XXX0"
               , "XX00"
               , "0000"
               ]
  }
pillar :: PlaceKind
pillar = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'p'
  , pname :: Text
pname    = "a hall"
  , pfreq :: Freqs PlaceKind
pfreq    = [("rogue", 600), ("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 :: Freqs PlaceKind
pfreq    = [("rogue", 60), ("laboratory", 200)]
  , ptopLeft :: [Text]
ptopLeft = [ "----"
               , "|0··"
               , "|···"
               , "|···"
               ]
  }
pillar3 :: PlaceKind
pillar3 = PlaceKind
pillar
  { pfreq :: Freqs PlaceKind
pfreq    = [("rogue", 8000), ("laboratory", 25000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|0···"
               , "|····"
               , "|··0·"
               , "|····"
               ]
  }
pillar4 :: PlaceKind
pillar4 = PlaceKind
pillar
  { pname :: Text
pname    = "an exquisite hall"
  , pfreq :: Freqs PlaceKind
pfreq    = [("rogue", 30000), ("laboratory", 100000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|&·0·"
               , "|····"
               , "|0·0·"
               , "|····"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('&', "cache")]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('&', "cache")]
  }
pillar5 :: PlaceKind
pillar5 = PlaceKind
pillar
  { pname :: Text
pname    = "a decorated hall"
  , pfreq :: Freqs PlaceKind
pfreq    = [("rogue", 30000), ("laboratory", 100000)]
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|&·0·"
               , "|····"
               , "|0···"
               , "|····"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('&', "cache")]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('&', "cache")]
  }
colonnade :: PlaceKind
colonnade = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'c'
  , pname :: Text
pname    = "a colonnade"
  , pfreq :: Freqs PlaceKind
pfreq    = [ ("rogue", 3), ("arena", 20), ("laboratory", 2)
               , ("empty", 10000), ("mine", 1000), ("brawl", 4)
               , ("escape", 40), ("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
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'l'
  , pname :: Text
pname    = "a lamp-lit area"
  , pfreq :: Freqs PlaceKind
pfreq    = [("escape", 200), ("ambush", 200), ("zoo", 100), ("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', "lampPostOver_0"), ('·', "floorActorLit")]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('0', "lampPostOver_0"), ('·', "floorActorLit")]
  }
lampPost2 :: PlaceKind
lampPost2 = PlaceKind
lampPost
  { ptopLeft :: [Text]
ptopLeft = [ "···"
               , "·0·"
               , "···"
               ]
  }
lampPost3 :: PlaceKind
lampPost3 = PlaceKind
lampPost
  { pfreq :: Freqs PlaceKind
pfreq    = [ ("escape", 3000), ("ambush", 3000), ("zoo", 50)
               , ("battle", 110) ]
  , ptopLeft :: [Text]
ptopLeft = [ "XX·XX"
               , "X···X"
               , "··0··"
               , "X···X"
               , "XX·XX"
               ]
  }
lampPost4 :: PlaceKind
lampPost4 = PlaceKind
lampPost
  { pfreq :: Freqs PlaceKind
pfreq    = [("escape", 3000), ("ambush", 3000), ("zoo", 50), ("battle", 60)]
  , ptopLeft :: [Text]
ptopLeft = [ "X···X"
               , "·····"
               , "··0··"
               , "·····"
               , "X···X"
               ]
  }
treeShade :: PlaceKind
treeShade = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 't'
  , pname :: Text
pname    = "a tree shade"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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', "treeShadeOver_0_Dark")
                    , ('s', "treeShadeOver_s_Dark")
                    , ('·', "shaded ground") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('0', "treeShadeOver_0_Lit")
                   , ('s', "treeShadeOver_s_Lit")
                   , ('·', "shaded ground") ]
  }
fogClump :: PlaceKind
fogClump = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'f'
  , pname :: Text
pname    = "a foggy patch"
  , pfreq :: Freqs PlaceKind
pfreq    = [("shootout", 150), ("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', "fogClumpOver_f_Dark"), (';', "fog Lit")]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('f', "fogClumpOver_f_Lit"), (';', "fog Lit")]
  }
fogClump2 :: PlaceKind
fogClump2 = PlaceKind
fogClump
  { pfreq :: Freqs PlaceKind
pfreq    = [("shootout", 500), ("empty", 50)]
  , ptopLeft :: [Text]
ptopLeft = [ "X;f"
               , "f;f"
               , ";;f"
               , "Xff"
               ]
  }
smokeClump :: PlaceKind
smokeClump = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 's'
  , pname :: Text
pname    = "a smoky patch"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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', "smokeClumpOver_f_Dark"), (';', "smoke Lit")
                    , ('·', "floorActorDark") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('f', "smokeClumpOver_f_Lit"), (';', "smoke Lit")
                   , ('·', "floorActorLit") ]
  }
smokeClump2 :: PlaceKind
smokeClump2 = PlaceKind
smokeClump
  { pfreq :: Freqs PlaceKind
pfreq    = [("zoo", 500)]
  , ptopLeft :: [Text]
ptopLeft = [ "X;f"
               , "f;f"
               , ";;f"
               , "Xff"
               ]
  }
smokeClump3FGround :: PlaceKind
smokeClump3FGround = PlaceKind
smokeClump
  { pname :: Text
pname    = "a burned out area"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = 'b'
  , pname :: Text
pname    = "a bushy patch"
  , pfreq :: Freqs PlaceKind
pfreq    = [("shootout", 80)]
  , prarity :: Rarity
prarity  = [(1, 1)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "f;"
               , ";X"  -- one sure exit needed not to block a corner
               , ";f"
               ]
  , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = [('f', "bushClumpOver_f_Dark"), (';', "bush Lit")]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [('f', "bushClumpOver_f_Lit"), (';', "bush Lit")]
      -- should not be used in caves with trails, because bushes can't
      -- grow over such artificial trails
  }
escapeDown :: PlaceKind
escapeDown = $WPlaceKind :: Char
-> Text
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = '>'
  , pname :: Text
pname    = "an escape down"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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 = [ ('|', "wall Lit")  -- visible from afar
                    , ('-', "wallH Lit") ]
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('|', "wall Lit")
                   , ('-', "wallH Lit") ]
  }
escapeDown2 :: PlaceKind
escapeDown2 = PlaceKind
escapeDown
  { pfreq :: Freqs PlaceKind
pfreq    = [("escape down", 1000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0·0"
               , "·>·"
               , "0·0"
               ]
  }
escapeDown3 :: PlaceKind
escapeDown3 = PlaceKind
escapeDown
  { pfreq :: Freqs PlaceKind
pfreq    = [("escape down", 2000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----"
               , "|0·0|"
               , "|·>·|"
               , "|0·0|"
               , "-----"
               ]
  }
escapeDown4 :: PlaceKind
escapeDown4 = PlaceKind
escapeDown
  { pfreq :: Freqs PlaceKind
pfreq    = [("escape down", 1000)]
  , pcover :: Cover
pcover   = Cover
CMirror
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "0··"
               , "·>·"
               , "··0"
               ]
  }
escapeDown5 :: PlaceKind
escapeDown5 = PlaceKind
escapeDown
  { pfreq :: Freqs PlaceKind
pfreq    = [("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
-> Freqs PlaceKind
-> Rarity
-> Cover
-> Fence
-> [Text]
-> [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)]
-> PlaceKind
PlaceKind
  { psymbol :: Char
psymbol  = '/'
  , pname :: Text
pname    = "a staircase"
  , pfreq :: Freqs PlaceKind
pfreq    = [("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 = [ ('<', "staircase up"), ('>', "staircase down")
                    , ('I', "signboard")
                    , ('|', "wall Lit"), ('-', "wallH Lit") ]  -- seen from afar
  , poverrideLit :: [(Char, GroupName TileKind)]
poverrideLit = [ ('<', "staircase up"), ('>', "staircase down")
                   , ('I', "signboard")
                   , ('|', "wall Lit"), ('-', "wallH 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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("open staircase", 200)]  -- no cover, open
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·0"
               , "···"
               , "<·>"
               , "···"
               , "0·0"
               ]
  }
staircase6 :: PlaceKind
staircase6 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("open staircase", 300)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·0·0"
               , "·····"
               , "·<·>·"
               , "·····"
               , "0·0·0"
               ]
  }
staircase7 :: PlaceKind
staircase7 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("open staircase", 500)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·······0"
               , "···<·>···"
               , "0·······0"
               ]
  }
staircase10 :: PlaceKind
staircase10 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("open staircase", 500)]
  , pfence :: Fence
pfence   = Fence
FGround
  , ptopLeft :: [Text]
ptopLeft = [ "0·····0"
               , "··<·>··"
               , "0·····0"
               ]
  }
staircase11 :: PlaceKind
staircase11 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("closed staircase", 1000)]
  , pfence :: Fence
pfence   = Fence
FFloor
  , ptopLeft :: [Text]
ptopLeft = [ "·0·····0·"
               , "0··<·>··0"
               , "·0·····0·"
               ]
  }
staircase25 :: PlaceKind
staircase25 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 10)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "-------"
               ]
  }
staircase26 :: PlaceKind
staircase26 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 50)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "---------"
               ]
  }
staircase27 :: PlaceKind
staircase27 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 100)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|0·····0|"
               , "|··<·>··|"
               , "|0·····0|"
               , "---------"
               ]
  }
staircase28 :: PlaceKind
staircase28 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|·····|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|·····|"
               , "-------"
               ]
  }
staircase29 :: PlaceKind
staircase29 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|0···0|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|0···0|"
               , "-------"
               ]
  }
staircase30 :: PlaceKind
staircase30 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 1000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-------"
               , "|0·0·0|"
               , "|·····|"
               , "|·<·>·|"
               , "|·····|"
               , "|0·0·0|"
               , "-------"
               ]
  }
staircase31 :: PlaceKind
staircase31 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 2000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|·······|"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "|·······|"
               , "---------"
               ]
  }
staircase32 :: PlaceKind
staircase32 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 5000)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "---------"
               , "|0·····0|"
               , "|·······|"
               , "|··<·>··|"
               , "|·······|"
               , "|0·····0|"
               , "---------"
               ]
  }
staircase33 :: PlaceKind
staircase33 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq    = [("walled staircase", 200)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----------"
               , "|·········|"
               , "|···<·>···|"
               , "|·········|"
               , "-----------"
               ]
  }
staircase36 :: PlaceKind
staircase36 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("walled staircase", 500)]
  , pfence :: Fence
pfence   = Fence
FNone
  , ptopLeft :: [Text]
ptopLeft = [ "-----------"
               , "|·0·····0·|"
               , "|0··<·>··0|"
               , "|·0·····0·|"
               , "-----------"
               ]
  }
staircase37 :: PlaceKind
staircase37 = PlaceKind
staircase
  { pfreq :: Freqs PlaceKind
pfreq    = [("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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> [a] -> [b]
map (\(t :: GroupName PlaceKind
t, k :: Int
k) -> (Text -> GroupName PlaceKind
forall a. Text -> GroupName a
toGroupName (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))
               (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', "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 = ('>', "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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> [a] -> [b]
map (\(t :: GroupName PlaceKind
t, k :: Int
k) -> (Text -> GroupName PlaceKind
forall a. Text -> GroupName a
toGroupName (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))
               (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('<', "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 = ('<', "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 =
  [ ('<', "gated staircase up"), ('>', "gated staircase down")
  , ('I', "signboard")
  , ('|', "wall Lit"), ('-', "wallH 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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
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
toGroupName (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))
               (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
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 =
  [ ('<', "staircase outdoor up"), ('>', "staircase outdoor down")
  , ('I', "signboard")
  , ('|', "wall Lit"), ('-', "wallH 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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
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
toGroupName (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))
               (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> [a] -> [b]
map (\(_, n :: Int
n) -> ("escape up", Int
n)) (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', "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 = ('>', "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 :: Freqs PlaceKind
pfreq     = ((GroupName PlaceKind, Int) -> (GroupName PlaceKind, Int))
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> [a] -> [b]
map (\(_, n :: Int
n) -> ("escape outdoor down", Int
n)) (Freqs PlaceKind -> Freqs PlaceKind)
-> Freqs PlaceKind -> Freqs PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind -> Freqs PlaceKind
pfreq PlaceKind
s
 , poverrideDark :: [(Char, GroupName TileKind)]
poverrideDark = ('>', "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 = ('>', "escape outdoor down") (Char, GroupName TileKind)
-> [(Char, GroupName TileKind)] -> [(Char, GroupName TileKind)]
forall a. a -> [a] -> [a]
: PlaceKind -> [(Char, GroupName TileKind)]
poverrideLit PlaceKind
s
 }