module Content.PlaceKind
(
pattern ROGUE, pattern LABORATORY, pattern ZOO, pattern BRAWL, pattern SHOOTOUT, pattern ARENA, pattern FLIGHT, 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
) where
import Prelude ()
import Game.LambdaHack.Core.Prelude
import qualified Data.EnumMap.Strict as EM
import qualified Data.Text as T
import Game.LambdaHack.Content.PlaceKind
import Game.LambdaHack.Content.TileKind (TileKind)
import Game.LambdaHack.Definition.Defs
import Game.LambdaHack.Definition.DefsInternal
import Content.TileKind hiding (content, groupNames, groupNamesSingleton)
groupNamesSingleton :: [GroupName PlaceKind]
groupNamesSingleton :: [GroupName PlaceKind]
groupNamesSingleton = []
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
FLIGHT, 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, FLIGHT, 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 $mROGUE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bROGUE :: GroupName PlaceKind
ROGUE = GroupName "rogue"
pattern $mLABORATORY :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bLABORATORY :: GroupName PlaceKind
LABORATORY = GroupName "laboratory"
pattern $mZOO :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bZOO :: GroupName PlaceKind
ZOO = GroupName "zoo"
pattern $mBRAWL :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bBRAWL :: GroupName PlaceKind
BRAWL = GroupName "brawl"
pattern $mSHOOTOUT :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bSHOOTOUT :: GroupName PlaceKind
SHOOTOUT = GroupName "shootout"
pattern $mARENA :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bARENA :: GroupName PlaceKind
ARENA = GroupName "arena"
pattern $mFLIGHT :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bFLIGHT :: GroupName PlaceKind
FLIGHT = GroupName "flight"
pattern $mAMBUSH :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bAMBUSH :: GroupName PlaceKind
AMBUSH = GroupName "ambush"
pattern $mBATTLE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bBATTLE :: GroupName PlaceKind
BATTLE = GroupName "battle"
pattern $mNOISE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bNOISE :: GroupName PlaceKind
NOISE = GroupName "noise"
pattern $mMINE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bMINE :: GroupName PlaceKind
MINE = GroupName "mine"
pattern $mEMPTY :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bEMPTY :: GroupName PlaceKind
EMPTY = GroupName "empty"
pattern $mINDOOR_ESCAPE_DOWN :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bINDOOR_ESCAPE_DOWN :: GroupName PlaceKind
INDOOR_ESCAPE_DOWN = GroupName "indoor escape down"
pattern $mINDOOR_ESCAPE_UP :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bINDOOR_ESCAPE_UP :: GroupName PlaceKind
INDOOR_ESCAPE_UP = GroupName "indoor escape up"
pattern $mOUTDOOR_ESCAPE_DOWN :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bOUTDOOR_ESCAPE_DOWN :: GroupName PlaceKind
OUTDOOR_ESCAPE_DOWN = GroupName "outdoor escape down"
pattern $mTINY_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bTINY_STAIRCASE :: GroupName PlaceKind
TINY_STAIRCASE = GroupName "tiny staircase"
pattern $mOPEN_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bOPEN_STAIRCASE :: GroupName PlaceKind
OPEN_STAIRCASE = GroupName "open staircase"
pattern $mCLOSED_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOSED_STAIRCASE :: GroupName PlaceKind
CLOSED_STAIRCASE = GroupName "closed staircase"
pattern $mWALLED_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bWALLED_STAIRCASE :: GroupName PlaceKind
WALLED_STAIRCASE = GroupName "walled staircase"
pattern $mGATED_TINY_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bGATED_TINY_STAIRCASE :: GroupName PlaceKind
GATED_TINY_STAIRCASE = GroupName "gated tiny staircase"
pattern $mGATED_OPEN_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bGATED_OPEN_STAIRCASE :: GroupName PlaceKind
GATED_OPEN_STAIRCASE = GroupName "gated open staircase"
pattern $mGATED_CLOSED_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bGATED_CLOSED_STAIRCASE :: GroupName PlaceKind
GATED_CLOSED_STAIRCASE = GroupName "gated closed staircase"
pattern $mOUTDOOR_TINY_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bOUTDOOR_TINY_STAIRCASE :: GroupName PlaceKind
OUTDOOR_TINY_STAIRCASE = GroupName "outdoor tiny staircase"
pattern $mOUTDOOR_CLOSED_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bOUTDOOR_CLOSED_STAIRCASE :: GroupName PlaceKind
OUTDOOR_CLOSED_STAIRCASE = GroupName "outdoor closed staircase"
pattern $mOUTDOOR_WALLED_STAIRCASE :: forall {r}.
GroupName PlaceKind -> ((# #) -> r) -> ((# #) -> r) -> r
$bOUTDOOR_WALLED_STAIRCASE :: GroupName PlaceKind
OUTDOOR_WALLED_STAIRCASE = GroupName "outdoor walled staircase"
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]
[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
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
defaultLegendLit :: EM.EnumMap Char (GroupName TileKind)
defaultLegendLit :: EnumMap Char (GroupName TileKind)
defaultLegendLit = [(Char, GroupName TileKind)] -> EnumMap Char (GroupName TileKind)
forall k a. Enum k => [(k, a)] -> EnumMap k a
EM.fromList
[ (Char
' ', GroupName TileKind
FILLER_WALL)
, (Char
'|', GroupName TileKind
S_WALL_LIT)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT)
, (Char
'0', GroupName TileKind
S_PILLAR)
, (Char
'&', GroupName TileKind
S_RUBBLE_PILE)
, (Char
'<', GroupName TileKind
TILE_INDOOR_ESCAPE_UP)
, (Char
'>', GroupName TileKind
TILE_INDOOR_ESCAPE_DOWN)
, (Char
'·', GroupName TileKind
FLOOR_ACTOR_ITEM_LIT)
, (Char
'~', GroupName TileKind
S_SHALLOW_WATER_LIT)
, (Char
'I', GroupName TileKind
SIGNBOARD) ]
defaultLegendDark :: EM.EnumMap Char (GroupName TileKind)
defaultLegendDark :: EnumMap Char (GroupName TileKind)
defaultLegendDark = [(Char, GroupName TileKind)] -> EnumMap Char (GroupName TileKind)
forall k a. Enum k => [(k, a)] -> EnumMap k a
EM.fromList
[ (Char
' ', GroupName TileKind
FILLER_WALL)
, (Char
'|', GroupName TileKind
S_WALL_DARK)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_DARK)
, (Char
'0', GroupName TileKind
S_PILLAR)
, (Char
'&', GroupName TileKind
S_RUBBLE_PILE)
, (Char
'<', GroupName TileKind
TILE_INDOOR_ESCAPE_UP)
, (Char
'>', GroupName TileKind
TILE_INDOOR_ESCAPE_DOWN)
, (Char
'·', GroupName TileKind
FLOOR_ACTOR_ITEM_DARK)
, (Char
'~', GroupName TileKind
S_SHALLOW_WATER_DARK)
, (Char
'I', GroupName TileKind
SIGNBOARD) ]
deadEnd :: PlaceKind
deadEnd = PlaceKind
{ pname :: Text
pname = Text
"a dead end"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = []
, prarity :: Rarity
prarity = []
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [Text
"·"]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
rect :: PlaceKind
rect = PlaceKind
{ pname :: Text
pname = Text
"a chamber"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
ROGUE, Int
30), (GroupName PlaceKind
LABORATORY, Int
10)]
, prarity :: Rarity
prarity = [(Double
1, Int
10), (Double
10, Int
6)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"--"
, Text
"|·"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
rect2 :: PlaceKind
rect2 = PlaceKind
rect
{ pname = "a pen"
, pfreq = [(ZOO, 3)]
}
rect3 :: PlaceKind
rect3 = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'|', GroupName TileKind
S_WALL_LIT)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
rect
{ pname = "a shed"
, pfreq = [(BRAWL, 10), (SHOOTOUT, 1)]
}
rect4 :: PlaceKind
rect4 = PlaceKind
rect3
{ pname = "cabinet"
, pfreq = [(ARENA, 10)]
}
rectWindows :: PlaceKind
rectWindows = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind
[ (Char
'=', GroupName TileKind
RECT_WINDOWS_HORIZONTAL_DARK)
, (Char
'!', GroupName TileKind
RECT_WINDOWS_VERTICAL_DARK) ]
[ (Char
'=', GroupName TileKind
RECT_WINDOWS_HORIZONTAL_LIT)
, (Char
'!', GroupName TileKind
RECT_WINDOWS_VERTICAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a hut"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
FLIGHT, Int
10), (GroupName PlaceKind
AMBUSH, Int
7)]
, prarity :: Rarity
prarity = [(Double
1, Int
10), (Double
10, Int
10)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"-="
, Text
"!·"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
glasshouse :: PlaceKind
glasshouse = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind
[ (Char
'=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
, (Char
'!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a glasshouse"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
SHOOTOUT, Int
4)]
, prarity :: Rarity
prarity = [(Double
1, Int
10), (Double
10, Int
7)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"=="
, Text
"!·"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
glasshouse2 :: PlaceKind
glasshouse2 = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [ (Char
'=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_DARK)
, (Char
'!', GroupName TileKind
GLASSHOUSE_VERTICAL_DARK) ]
[ (Char
'=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
, (Char
'!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
glasshouse
{ pname = "a glass cage"
, pfreq = [(ZOO, 10)]
}
glasshouse3 :: PlaceKind
glasshouse3 = PlaceKind
glasshouse
{ pname = "a reading room"
, pfreq = [(ARENA, 40)]
}
pulpit :: PlaceKind
pulpit = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'=', GroupName TileKind
GLASSHOUSE_HORIZONTAL_LIT)
, (Char
'!', GroupName TileKind
GLASSHOUSE_VERTICAL_LIT)
, (Char
'0', GroupName TileKind
S_PULPIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a stand dais"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
ARENA, Int
200), (GroupName PlaceKind
ZOO, Int
200)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CMirror
, pfence :: Fence
pfence = Fence
FGround
, ptopLeft :: [Text]
ptopLeft = [ Text
"==·"
, Text
"!··"
, Text
"··0"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
ruin :: PlaceKind
ruin = PlaceKind
{ pname :: Text
pname = Text
"ruins"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
BATTLE, Int
330)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"--"
, Text
"|X"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
ruin2 :: PlaceKind
ruin2 = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'|', GroupName TileKind
S_WALL_LIT)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
ruin
{ pname = "blasted walls"
, pfreq = [(AMBUSH, 50)]
}
collapsed :: PlaceKind
collapsed = PlaceKind
{ pname :: Text
pname = Text
"a collapsed cavern"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
NOISE, Int
1)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"0"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
collapsed2 :: PlaceKind
collapsed2 = PlaceKind
collapsed
{ pfreq = [(NOISE, 1000), (BATTLE, 200)]
, ptopLeft = [ "X0"
, "00"
]
}
collapsed3 :: PlaceKind
collapsed3 = PlaceKind
collapsed
{ pfreq = [(NOISE, 2000), (BATTLE, 200)]
, ptopLeft = [ "XX0"
, "000"
]
}
collapsed4 :: PlaceKind
collapsed4 = PlaceKind
collapsed
{ pfreq = [(NOISE, 2000), (BATTLE, 200)]
, ptopLeft = [ "XXX0"
, "0000"
]
}
collapsed5 :: PlaceKind
collapsed5 = PlaceKind
collapsed
{ pfreq = [(NOISE, 3000), (BATTLE, 500)]
, ptopLeft = [ "XX0"
, "X00"
, "000"
]
}
collapsed6 :: PlaceKind
collapsed6 = PlaceKind
collapsed
{ pfreq = [(NOISE, 4000), (BATTLE, 1000)]
, ptopLeft = [ "XXX0"
, "X000"
, "0000"
]
}
collapsed7 :: PlaceKind
collapsed7 = PlaceKind
collapsed
{ pfreq = [(NOISE, 4000), (BATTLE, 1000)]
, ptopLeft = [ "XXX0"
, "XX00"
, "0000"
]
}
pillar :: PlaceKind
pillar = PlaceKind
{ pname :: Text
pname = Text
"a hall"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
ROGUE, Int
600), (GroupName PlaceKind
LABORATORY, Int
2000)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CStretch
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"----"
, Text
"|···"
, Text
"|·0·"
, Text
"|···"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
pillar2 :: PlaceKind
pillar2 = PlaceKind
pillar
{ pfreq = [(ROGUE, 60), (LABORATORY, 200)]
, ptopLeft = [ "----"
, "|0··"
, "|···"
, "|···"
]
}
pillar3 :: PlaceKind
pillar3 = PlaceKind
pillar
{ pfreq = [(ROGUE, 8000), (LABORATORY, 25000)]
, ptopLeft = [ "-----"
, "|0···"
, "|····"
, "|··0·"
, "|····"
]
}
pillar4 :: PlaceKind
pillar4 = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
'&', GroupName TileKind
CACHE)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
pillar
{ pname = "an exquisite hall"
, pfreq = [(ROGUE, 30000), (LABORATORY, 100000)]
, ptopLeft = [ "-----"
, "|&·0·"
, "|····"
, "|0·0·"
, "|····"
]
}
pillar5 :: PlaceKind
pillar5 = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
'&', GroupName TileKind
CACHE)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
pillar
{ pname = "a decorated hall"
, pfreq = [(ROGUE, 30000), (LABORATORY, 100000)]
, ptopLeft = [ "-----"
, "|&·0·"
, "|····"
, "|0···"
, "|····"
]
}
colonnade :: PlaceKind
colonnade = PlaceKind
{ pname :: Text
pname = Text
"a colonnade"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [ (GroupName PlaceKind
ROGUE, Int
3), (GroupName PlaceKind
ARENA, Int
20), (GroupName PlaceKind
LABORATORY, Int
2)
, (GroupName PlaceKind
EMPTY, Int
10000), (GroupName PlaceKind
MINE, Int
1000), (GroupName PlaceKind
BRAWL, Int
4)
, (GroupName PlaceKind
FLIGHT, Int
40), (GroupName PlaceKind
AMBUSH, Int
40) ]
, prarity :: Rarity
prarity = [(Double
1, Int
10), (Double
10, Int
10)]
, pcover :: Cover
pcover = Cover
CAlternate
, pfence :: Fence
pfence = Fence
FFloor
, ptopLeft :: [Text]
ptopLeft = [ Text
"0·"
, Text
"··"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
colonnade2 :: PlaceKind
colonnade2 = PlaceKind
colonnade
{ prarity = [(1, 15), (10, 15)]
, ptopLeft = [ "0·"
, "·0"
]
}
colonnade3 :: PlaceKind
colonnade3 = PlaceKind
colonnade
{ prarity = [(1, 800), (10, 800)]
, ptopLeft = [ "··0"
, "·0·"
, "0··"
]
}
colonnade4 :: PlaceKind
colonnade4 = PlaceKind
colonnade
{ prarity = [(1, 200), (10, 200)]
, ptopLeft = [ "0··"
, "·0·"
, "··0"
]
}
colonnade5 :: PlaceKind
colonnade5 = PlaceKind
colonnade
{ prarity = [(1, 10), (10, 10)]
, ptopLeft = [ "0··"
, "··0"
]
}
colonnade6 :: PlaceKind
colonnade6 = PlaceKind
colonnade
{ prarity = [(1, 100), (10, 100)]
, ptopLeft = [ "0·"
, "··"
, "·0"
]
}
lampPost :: PlaceKind
lampPost = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'0', GroupName TileKind
S_LAMP_POST)
, (Char
'·', GroupName TileKind
S_FLOOR_ACTOR_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a lamp-lit area"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
FLIGHT, Int
200), (GroupName PlaceKind
AMBUSH, Int
200), (GroupName PlaceKind
ZOO, Int
100), (GroupName PlaceKind
BATTLE, Int
100)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CVerbatim
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"X·X"
, Text
"·0·"
, Text
"X·X"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
lampPost2 :: PlaceKind
lampPost2 = PlaceKind
lampPost
{ ptopLeft = [ "···"
, "·0·"
, "···"
]
}
lampPost3 :: PlaceKind
lampPost3 = PlaceKind
lampPost
{ pfreq = [ (FLIGHT, 3000), (AMBUSH, 3000), (ZOO, 50)
, (BATTLE, 110) ]
, ptopLeft = [ "XX·XX"
, "X···X"
, "··0··"
, "X···X"
, "XX·XX"
]
}
lampPost4 :: PlaceKind
lampPost4 = PlaceKind
lampPost
{ pfreq = [(FLIGHT, 3000), (AMBUSH, 3000), (ZOO, 50), (BATTLE, 60)]
, ptopLeft = [ "X···X"
, "·····"
, "··0··"
, "·····"
, "X···X"
]
}
treeShade :: PlaceKind
treeShade = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [ (Char
'0', GroupName TileKind
S_TREE_DARK)
, (Char
's', GroupName TileKind
TREE_SHADE_WALKABLE_DARK) ]
[ (Char
'0', GroupName TileKind
S_TREE_LIT)
, (Char
's', GroupName TileKind
TREE_SHADE_WALKABLE_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$
[(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
'·', GroupName TileKind
S_SHADED_GROUND)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a tree shade"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
BRAWL, Int
1000)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CMirror
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"··s"
, Text
"s0·"
, Text
"Xs·"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
fogClump :: PlaceKind
fogClump = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [(Char
'f', GroupName TileKind
FOG_CLUMP_DARK)]
[(Char
'f', GroupName TileKind
FOG_CLUMP_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$
[(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
';', GroupName TileKind
S_FOG_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a foggy patch"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
SHOOTOUT, Int
150), (GroupName PlaceKind
EMPTY, Int
15)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CMirror
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"f;"
, Text
";f"
, Text
";X"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
fogClump2 :: PlaceKind
fogClump2 = PlaceKind
fogClump
{ pfreq = [(SHOOTOUT, 500), (EMPTY, 50)]
, ptopLeft = [ "X;f"
, "f;f"
, ";;f"
, "Xff"
]
}
smokeClump :: PlaceKind
smokeClump = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [ (Char
'f', GroupName TileKind
SMOKE_CLUMP_DARK)
, (Char
'·', GroupName TileKind
S_FLOOR_ACTOR_DARK) ]
[ (Char
'f', GroupName TileKind
SMOKE_CLUMP_LIT)
, (Char
'·', GroupName TileKind
S_FLOOR_ACTOR_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$
[(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
';', GroupName TileKind
S_SMOKE_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a smoky patch"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
ZOO, Int
50)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CMirror
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"f;"
, Text
";f"
, Text
";X"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
smokeClump2 :: PlaceKind
smokeClump2 = PlaceKind
smokeClump
{ pfreq = [(ZOO, 500)]
, ptopLeft = [ "X;f"
, "f;f"
, ";;f"
, "Xff"
]
}
smokeClump3FGround :: PlaceKind
smokeClump3FGround = PlaceKind
smokeClump
{ pname = "a burned out area"
, pfreq = [(LABORATORY, 150)]
, prarity = [(1, 1)]
, pcover = CVerbatim
, pfence = FGround
, ptopLeft = [ ";f;"
, "f·f"
, "f·f"
, ";f;"
]
}
bushClump :: PlaceKind
bushClump = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [(Char
'f', GroupName TileKind
BUSH_CLUMP_DARK)]
[(Char
'f', GroupName TileKind
BUSH_CLUMP_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$
[(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
';', GroupName TileKind
S_BUSH_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a bushy patch"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
SHOOTOUT, Int
40)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CMirror
, pfence :: Fence
pfence = Fence
FNone
, ptopLeft :: [Text]
ptopLeft = [ Text
"Xf"
, Text
";X"
, Text
";;"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
bushClump2 :: PlaceKind
bushClump2 = PlaceKind
bushClump
{ pfreq = [(SHOOTOUT, 80)]
, ptopLeft = [ "Xf"
, ";X"
, ";X"
, ";;"
]
}
escapeDown :: PlaceKind
escapeDown = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'|', GroupName TileKind
S_WALL_LIT)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"an escape down"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
INDOOR_ESCAPE_DOWN, Int
1)]
, prarity :: Rarity
prarity = [(Double
1, Int
1)]
, pcover :: Cover
pcover = Cover
CVerbatim
, pfence :: Fence
pfence = Fence
FGround
, ptopLeft :: [Text]
ptopLeft = [ Text
">"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
escapeDown2 :: PlaceKind
escapeDown2 = PlaceKind
escapeDown
{ pfreq = [(INDOOR_ESCAPE_DOWN, 1000)]
, pfence = FFloor
, ptopLeft = [ "0·0"
, "·>·"
, "0·0"
]
}
escapeDown3 :: PlaceKind
escapeDown3 = PlaceKind
escapeDown
{ pfreq = [(INDOOR_ESCAPE_DOWN, 2000)]
, pfence = FNone
, ptopLeft = [ "-----"
, "|0·0|"
, "|·>·|"
, "|0·0|"
, "-----"
]
}
escapeDown4 :: PlaceKind
escapeDown4 = PlaceKind
escapeDown
{ pfreq = [(INDOOR_ESCAPE_DOWN, 1000)]
, pcover = CMirror
, pfence = FFloor
, ptopLeft = [ "0··"
, "·>·"
, "··0"
]
}
escapeDown5 :: PlaceKind
escapeDown5 = PlaceKind
escapeDown
{ pfreq = [(INDOOR_ESCAPE_DOWN, 2000)]
, pcover = CMirror
, pfence = FNone
, ptopLeft = [ "-----"
, "|0··|"
, "|·>·|"
, "|0·0|"
, "-----"
]
}
staircase :: PlaceKind
staircase = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [ (Char
'<', GroupName TileKind
STAIRCASE_UP)
, (Char
'>', GroupName TileKind
STAIRCASE_DOWN)
, (Char
'|', GroupName TileKind
S_WALL_LIT)
, (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
{ pname :: Text
pname = Text
"a staircase"
, pfreq :: [(GroupName PlaceKind, Int)]
pfreq = [(GroupName PlaceKind
TINY_STAIRCASE, Int
1)]
, prarity :: Rarity
prarity = [(Double
1, Int
100), (Double
10, Int
100)]
, pcover :: Cover
pcover = Cover
CVerbatim
, pfence :: Fence
pfence = Fence
FGround
, ptopLeft :: [Text]
ptopLeft = [ Text
"<·>"
]
, plegendDark :: EnumMap Char (GroupName TileKind)
plegendDark = EnumMap Char (GroupName TileKind)
defaultLegendDark
, plegendLit :: EnumMap Char (GroupName TileKind)
plegendLit = EnumMap Char (GroupName TileKind)
defaultLegendLit
}
staircase1 :: PlaceKind
staircase1 = PlaceKind
staircase
{ prarity = [(1, 1)]
}
staircase2 :: PlaceKind
staircase2 = PlaceKind
staircase
{ pfreq = [(TINY_STAIRCASE, 3)]
, prarity = [(1, 1)]
, pfence = FGround
, ptopLeft = [ "·<·>·"
]
}
staircase3 :: PlaceKind
staircase3 = PlaceKind
staircase
{ prarity = [(1, 1)]
, pfence = FFloor
}
staircase4 :: PlaceKind
staircase4 = PlaceKind
staircase2
{ pfence = FFloor
, prarity = [(1, 1)]
}
staircase5 :: PlaceKind
staircase5 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 200)]
, pfence = FGround
, ptopLeft = [ "0·0"
, "···"
, "<·>"
, "···"
, "0·0"
]
}
staircase6 :: PlaceKind
staircase6 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 300)]
, pfence = FGround
, ptopLeft = [ "0·0·0"
, "·····"
, "·<·>·"
, "·····"
, "0·0·0"
]
}
staircase7 :: PlaceKind
staircase7 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 500)]
, pfence = FGround
, ptopLeft = [ "0·0·0·0"
, "·······"
, "0·<·>·0"
, "·······"
, "0·0·0·0"
]
}
staircase8 :: PlaceKind
staircase8 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 2000)]
, pfence = FGround
, ptopLeft = [ "·0·I·0·"
, "0·····0"
, "··<·>··"
, "0·····0"
, "·0·0·0·"
]
}
staircase9 :: PlaceKind
staircase9 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 500)]
, pfence = FGround
, ptopLeft = [ "0·······0"
, "···<·>···"
, "0·······0"
]
}
staircase10 :: PlaceKind
staircase10 = PlaceKind
staircase
{ pfreq = [(OPEN_STAIRCASE, 500)]
, pfence = FGround
, ptopLeft = [ "0·····0"
, "··<·>··"
, "0·····0"
]
}
staircase11 :: PlaceKind
staircase11 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 2000)]
, pfence = FFloor
, ptopLeft = [ "·0·"
, "0·0"
, "···"
, "<·>"
, "···"
, "0·0"
, "·0·"
]
}
staircase12 :: PlaceKind
staircase12 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 4000)]
, pfence = FFloor
, ptopLeft = [ "·0·0·"
, "0·0·0"
, "·····"
, "·<·>·"
, "·····"
, "0·0·0"
, "·0·0·"
]
}
staircase13 :: PlaceKind
staircase13 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 6000)]
, pfence = FFloor
, ptopLeft = [ "·0·0·0·"
, "0·0·0·0"
, "·······"
, "0·<·>·0"
, "·······"
, "0·0·0·0"
, "·0·0·0·"
]
}
staircase14 :: PlaceKind
staircase14 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 10000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 20000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 20000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 20000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 80000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 20000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 5000)]
, pfence = FFloor
, 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 = [(CLOSED_STAIRCASE, 5000)]
, pfence = FFloor
, ptopLeft = [ "0·0·I·0·0"
, "·0·····0·"
, "0··<·>··0"
, "·0·····0·"
, "0·0·0·0·0"
]
}
staircase22 :: PlaceKind
staircase22 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 2000)]
, pfence = FFloor
, ptopLeft = [ "0·0·····0·0"
, "·0··<·>··0·"
, "0·0·····0·0"
]
}
staircase23 :: PlaceKind
staircase23 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 1000)]
, pfence = FFloor
, ptopLeft = [ "·0·······0·"
, "0·0·<·>·0·0"
, "·0·······0·"
]
}
staircase24 :: PlaceKind
staircase24 = PlaceKind
staircase
{ pfreq = [(CLOSED_STAIRCASE, 1000)]
, pfence = FFloor
, ptopLeft = [ "·0·····0·"
, "0··<·>··0"
, "·0·····0·"
]
}
staircase25 :: PlaceKind
staircase25 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 10)]
, pfence = FNone
, ptopLeft = [ "-------"
, "|·····|"
, "|·<·>·|"
, "|·····|"
, "-------"
]
}
staircase26 :: PlaceKind
staircase26 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 50)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|·······|"
, "|··<·>··|"
, "|·······|"
, "---------"
]
}
staircase27 :: PlaceKind
staircase27 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 100)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|0·····0|"
, "|··<·>··|"
, "|0·····0|"
, "---------"
]
}
staircase28 :: PlaceKind
staircase28 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 1000)]
, pfence = FNone
, ptopLeft = [ "-------"
, "|·····|"
, "|·····|"
, "|·<·>·|"
, "|·····|"
, "|·····|"
, "-------"
]
}
staircase29 :: PlaceKind
staircase29 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 1000)]
, pfence = FNone
, ptopLeft = [ "-------"
, "|0···0|"
, "|·····|"
, "|·<·>·|"
, "|·····|"
, "|0···0|"
, "-------"
]
}
staircase30 :: PlaceKind
staircase30 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 1000)]
, pfence = FNone
, ptopLeft = [ "-------"
, "|0·0·0|"
, "|·····|"
, "|·<·>·|"
, "|·····|"
, "|0·0·0|"
, "-------"
]
}
staircase31 :: PlaceKind
staircase31 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 2000)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|·······|"
, "|·······|"
, "|··<·>··|"
, "|·······|"
, "|·······|"
, "---------"
]
}
staircase32 :: PlaceKind
staircase32 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 5000)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|0·····0|"
, "|·······|"
, "|··<·>··|"
, "|·······|"
, "|0·····0|"
, "---------"
]
}
staircase33 :: PlaceKind
staircase33 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 5000)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|0·0·0·0|"
, "|·······|"
, "|0·<·>·0|"
, "|·······|"
, "|0·0·0·0|"
, "---------"
]
}
staircase34 :: PlaceKind
staircase34 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 5000)]
, pfence = FNone
, ptopLeft = [ "---------"
, "|·0·0·0·|"
, "|0·····0|"
, "|··<·>··|"
, "|0·····0|"
, "|·0·I·0·|"
, "---------"
]
}
staircase35 :: PlaceKind
staircase35 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 200)]
, pfence = FNone
, ptopLeft = [ "-----------"
, "|·········|"
, "|···<·>···|"
, "|·········|"
, "-----------"
]
}
staircase36 :: PlaceKind
staircase36 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 500)]
, pfence = FNone
, ptopLeft = [ "-----------"
, "|·0·····0·|"
, "|0··<·>··0|"
, "|·0·····0·|"
, "-----------"
]
}
staircase37 :: PlaceKind
staircase37 = PlaceKind
staircase
{ pfreq = [(WALLED_STAIRCASE, 500)]
, pfence = FNone
, ptopLeft = [ "-----------"
, "|0·······0|"
, "|·0·<·>·0·|"
, "|0·······0|"
, "-----------"
]
}
switchStaircaseToUp :: PlaceKind -> PlaceKind
switchStaircaseToUp :: PlaceKind -> PlaceKind
switchStaircaseToUp PlaceKind
s = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [(Char
'>', GroupName TileKind
STAIR_TERMINAL_DARK)]
[(Char
'>', GroupName TileKind
STAIR_TERMINAL_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = pname s <+> "up"
, pfreq = renameFreqs (<+> "up") $ pfreq s
}
switchStaircaseToDown :: PlaceKind -> PlaceKind
switchStaircaseToDown :: PlaceKind -> PlaceKind
switchStaircaseToDown PlaceKind
s = [(Char, GroupName TileKind)]
-> [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
override2PlaceKind [(Char
'<', GroupName TileKind
STAIR_TERMINAL_DARK)]
[(Char
'<', GroupName TileKind
STAIR_TERMINAL_LIT)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = pname s <+> "down"
, pfreq = renameFreqs (<+> "down") $ pfreq s
}
overrideGated :: [(Char, GroupName TileKind)]
overrideGated :: [(Char, GroupName TileKind)]
overrideGated =
[ (Char
'<', GroupName TileKind
GATED_STAIRCASE_UP), (Char
'>', GroupName TileKind
GATED_STAIRCASE_DOWN)
, (Char
'|', GroupName TileKind
S_WALL_LIT), (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
switchStaircaseToGated :: PlaceKind -> PlaceKind
switchStaircaseToGated :: PlaceKind -> PlaceKind
switchStaircaseToGated PlaceKind
s = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char, GroupName TileKind)]
overrideGated (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = T.unwords $ "a gated" : tail (T.words (pname s))
, pfreq = renameFreqs ("gated" <+>) $ pfreq s
}
overrideOutdoor :: [(Char, GroupName TileKind)]
overrideOutdoor :: [(Char, GroupName TileKind)]
overrideOutdoor =
[ (Char
'<', GroupName TileKind
STAIRCASE_OUTDOOR_UP), (Char
'>', GroupName TileKind
STAIRCASE_OUTDOOR_DOWN)
, (Char
'|', GroupName TileKind
S_WALL_LIT), (Char
'-', GroupName TileKind
S_WALL_HORIZONTAL_LIT) ]
switchStaircaseToOutdoor :: PlaceKind -> PlaceKind
switchStaircaseToOutdoor :: PlaceKind -> PlaceKind
switchStaircaseToOutdoor PlaceKind
s = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char, GroupName TileKind)]
overrideOutdoor (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = "an outdoor area exit"
, pfreq = renameFreqs ("outdoor" <+>) $ pfreq s
}
switchEscapeToUp :: PlaceKind -> PlaceKind
switchEscapeToUp :: PlaceKind -> PlaceKind
switchEscapeToUp PlaceKind
s = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind [(Char
'>', GroupName TileKind
TILE_INDOOR_ESCAPE_UP)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = "an escape up"
, pfreq = map (\(GroupName PlaceKind
_, Int
n) -> (GroupName PlaceKind
INDOOR_ESCAPE_UP, Int
n)) $ pfreq s
}
switchEscapeToOutdoorDown :: PlaceKind -> PlaceKind
switchEscapeToOutdoorDown :: PlaceKind -> PlaceKind
switchEscapeToOutdoorDown PlaceKind
s = [(Char, GroupName TileKind)] -> PlaceKind -> PlaceKind
overridePlaceKind
[(Char
'>', GroupName TileKind
TILE_OUTDOOR_ESCAPE_DOWN)] (PlaceKind -> PlaceKind) -> PlaceKind -> PlaceKind
forall a b. (a -> b) -> a -> b
$ PlaceKind
s
{ pname = "outdoor escape route"
, pfreq = map (\(GroupName PlaceKind
_, Int
n) -> (GroupName PlaceKind
OUTDOOR_ESCAPE_DOWN, Int
n)) $ pfreq s
}