tracer/src/Floorplan.hs

456 lines
16 KiB
Haskell

module Floorplan where
import Data.Matrix (Matrix(..))
import qualified Data.Matrix as M
import qualified Data.Vector as V
import Data.Maybe
import Control.Monad (foldM)
import System.Random
import Types.Map
import Debug.Trace
buildHallFloorIO :: FloorConfig -> IO (Matrix TileState)
buildHallFloorIO fc = do
rand <- newStdGen
let empty = emptyFloor fc
(g1, withElv) = buildElevator fc (placeHalls rand fc empty)
(g2, withIW) = buildInnerWalls g1 withElv
withOW = buildOuterWalls withIW
closed = closeOffices withOW
doorgraph = buildDoorsGraph closed
traceIO "built graph"
doors <- buildDoors closed doorgraph
traceIO "built doors"
let (g4, facils) = buildFacilities g2 fc doors
return facils
emptyFloor :: FloorConfig -> Matrix TileState
emptyFloor fc =
let (rows, cols) = size fc
in M.matrix rows cols (const Unde)
buildElevator
:: FloorConfig
-> (StdGen, Matrix TileState)
-> (StdGen, Matrix TileState)
buildElevator fc (gen, empty) =
let (row, col) = elevator fc
boxCoord x = (,) <$> [row - x .. row + x] <*> [col - x .. col + x]
buildShaft = foldl
(\acc coord -> M.setElem (replaceTile (acc M.! coord) Hall) coord acc)
(foldl (\acc coord -> M.setElem Wall coord acc) empty (boxCoord 2))
(boxCoord 5)
elvDoor = M.setElem Door (row + 2, col) buildShaft
in (gen, foldl (\acc coord -> M.setElem Elev coord acc) elvDoor (boxCoord 1))
placeHalls
:: StdGen
-> FloorConfig
-> Matrix TileState
-> (StdGen, Matrix TileState)
placeHalls rng fc input =
doHalls rng
[(Boundaries (1,1) (nrows input, ncols input))]
(elevator fc) 5 input
where
doHalls rand bounds cross wmax mat =
foldl (\(agen, amat) b ->
let (row, g1) = randomR (fst (matmin b), fst (matmax b)) agen
(col, g2) = randomR (snd (matmin b), snd (matmax b)) g1
(nw, g3) = randomR (2, wmax) g2
(nbs, nmat) = buildHall cross nw b amat
in
if hallRatio nmat < 0.2 && wmax - 1 > 2
then doHalls g3 nbs (row, col) (wmax -1) nmat
else (g3, nmat)
) (rand, mat) bounds
boundSize :: Boundaries -> Int
boundSize (Boundaries mi ma) =
(fst ma - fst mi) * (snd ma - snd mi)
buildHall
:: (Int, Int)
-> Int
-> Boundaries
-> Matrix TileState
-> ([Boundaries], Matrix TileState)
buildHall coord@(row, col) width bounds mat =
let vertHalls = foldl (\acc c -> M.mapCol
(\r cur -> if r >= fst (matmin bounds) && r <= fst (matmax bounds)
then replaceTile cur Hall
else cur
) c acc)
mat
[col - (width `div` 2) .. col + (width `div` 2)]
horzHalls = foldl (\acc r -> M.mapRow
(\c cur -> if c >= snd (matmin bounds) && c <= snd (matmax bounds)
then replaceTile cur Hall
else cur
) r acc)
vertHalls
[row - (width `div` 2) .. row + (width `div` 2)]
in ( [ Boundaries (matmin bounds) coord
, Boundaries (fst (matmin bounds), col) (row, snd (matmax bounds))
, Boundaries (row, snd (matmin bounds)) (fst (matmax bounds), col)
, Boundaries coord (matmax bounds)
]
, horzHalls
)
replaceTile :: TileState -> TileState -> TileState
replaceTile cur new
| cur == Unde = new
| otherwise = cur
hallRatio :: Matrix TileState -> Double
hallRatio mat =
let hs = foldl (\acc a -> if a == Hall then acc + 1 else acc) 0 mat :: Int
in fromIntegral hs / fromIntegral (nrows mat * ncols mat)
buildInnerWalls :: StdGen -> Matrix TileState -> (StdGen, Matrix TileState)
buildInnerWalls rng input =
let floodSearchReplace
:: StdGen
-> (Int, Int)
-> Matrix TileState
-> (StdGen, Matrix TileState)
floodSearchReplace gn coord@(row, col) mat
| mat M.! coord == Unde =
let maxRow = doRow row
doRow r
| M.safeGet (r + 1) col mat == Just Unde = doRow (r + 1)
| otherwise = r
maxCol = doCol col
doCol c
| M.safeGet row (c + 1) mat == Just Unde = doCol (c + 1)
| otherwise = c
(cr, g1) = randomR
( if maxRow - 3 < row + 3
then (row + 2, row + 2)
else (row + 3, maxRow - 3)
) gn
(cc, g2) = randomR
( if maxCol - 3 < col + 3
then (col + 2, col + 2)
else (col + 3,maxCol - 3)
) g1
(nngen, nnmat) =
if (cr - 2 > row && cr + 2 < maxRow)
&& (cc - 2 > col && cc + 2 < maxCol)
then
doCross
g2
(cr, cc)
(Boundaries coord (maxRow, maxCol))
mat
else
let btups = (,)
<$> [fst (coord) .. maxRow]
<*> [snd (coord) .. maxCol]
in
( g2
, foldl
(\acc coords ->
M.setElem (replaceTile (acc M.! coords) Offi) coords acc
) mat btups
)
doCross
:: StdGen
-> (Int, Int)
-> Boundaries
-> Matrix TileState
-> (StdGen, Matrix TileState)
doCross gen cd@(xr, xc) b imat =
let nbs = map (\(mi, ma) -> Boundaries mi ma) bounds
bounds =
[ (matmin b, cd)
, ((fst (matmin b), col), (row, snd (matmax b)))
, ((row, snd (matmin b)), (fst (matmax b), col))
, (cd, matmax b)
]
(ngen, crosses) = foldl
(\(agen, acc) (minb, maxb) ->
let (fc, gg1) = randomR (fst minb, fst maxb) agen
(fr, gg2) = randomR (snd minb, snd maxb) gg1
in (gg2, acc ++ [(fc, fr)])
) (gen, []) bounds
horz = M.mapRow (\icol cur ->
if icol >= snd (matmin b) && icol <= snd (matmax b)
then replaceTile cur Wall
else cur
) xr imat
vert = M.mapCol (\irow cur ->
if irow >= fst (matmin b) && irow <= fst (matmax b)
then replaceTile cur Wall
else cur
) xc horz
omat = foldl
(\acc coords ->
M.setElem (replaceTile (acc M.! coords) Offi) coords acc
) vert btups
btups = (,)
<$> [fst (matmin b) .. fst (matmax b)]
<*> [snd (matmin b) .. snd (matmax b)]
in if boundSize b >= 16
then foldl
(\(agen, amat) (acr, nb) -> doCross agen acr nb amat)
(ngen, omat)
(zip crosses nbs)
else
(gen, omat)
in (nngen, nnmat)
| otherwise = (gn, mat)
tups mat = (,) <$> [1 .. nrows mat] <*> [1 .. ncols mat]
in foldl (\(agen, amat) cds -> floodSearchReplace agen cds amat)
(rng, input) (tups input)
closeOffices :: Matrix TileState -> Matrix TileState
closeOffices input =
let tups mat = (,) <$> [2 .. nrows mat - 1] <*> [2 .. ncols mat - 1]
isNeighbor (row, col) =
let subm = M.submatrix (row -1) (row + 1) (col - 1) (col + 1) input
in any (== Hall) (M.toList subm)
in foldl (\acc coord ->
if input M.! coord == Offi && isNeighbor coord
then M.setElem Wall coord acc
else acc
) input (tups input)
buildOuterWalls :: Matrix TileState -> Matrix TileState
buildOuterWalls input =
let horz :: Matrix TileState
horz =
foldl
(\amat r -> M.mapRow (\_ _ -> Wall) r amat)
input
[ 1
, nrows input
]
vert =
foldl
(\amat c -> M.mapCol (\_ _ -> Wall) c amat)
horz
[ 1
, ncols horz
]
in vert
buildFacilities
:: StdGen
-> FloorConfig
-> Matrix TileState
-> (StdGen, Matrix TileState)
buildFacilities gen fc input =
let flood ts mat coords@(cr, cc) =
let cur = mat M.! coords
altered = M.setElem ts coords mat
in
if cur == ts || cur /= Offi
then mat
else foldl (\acc cs -> flood ts acc cs)
altered
[ (cr + 1, cc)
, (cr - 1, cc)
, (cr, cc + 1)
, (cr, cc - 1)
]
nearests = map (findNearestOffice input) (facilities fc)
in (foldl (\(agen, acc) x ->
let (numfac, ngen) = randomR (0 :: Int, 1 :: Int) agen
facil = if numfac == 1 then Kitc else Toil
in (ngen, flood facil acc x)
) (gen, input) nearests)
findNearestOffice
:: Matrix TileState
-> (Int, Int)
-> (Int, Int)
findNearestOffice mat (rrr, ccc) =
let matcoord = (,) <$> [1 .. nrows mat] <*> [1 .. ncols mat]
distance :: (Int, Int) -> Int
distance (ar, ac) = (ar - rrr) ^ (2 :: Int) + (ac - ccc) ^ (2 :: Int)
inlist = zip matcoord (M.toList mat)
in foldl (\acc (xc, ts) ->
if ts == Offi && distance acc > distance xc
then xc
else acc
) (fst $ head inlist) inlist
buildDoorsGraph :: Matrix TileState -> [Graph]
buildDoorsGraph mat =
let maxRow r c
| M.safeGet (r + 1) c mat == Just Offi = maxRow (r + 1) c
| otherwise = r
maxCol r c
| M.safeGet r (c + 1) mat == Just Offi = maxCol r (c + 1)
| otherwise = c
minRow r c
| M.safeGet (r + 1) c mat == Just Offi = minRow (r + 1) c
| otherwise = r
minCol r c
| M.safeGet r (c + 1) mat == Just Offi = minCol r (c + 1)
| otherwise = c
matcoord = (,) <$> [2 .. nrows mat - 1] <*> [2 .. ncols mat - 1]
inbounds (qr, qc) fg
| fg == Hall =
Nothing
| otherwise =
Just fg
buildGraph :: Matrix TileState -> [Graph] -> (Int, Int) -> [Graph]
buildGraph amat root coord@(br, bc)
| bc > ncols amat - 1 =
buildGraph amat root (br + 1, 1)
| br > nrows amat - 1 =
root
| M.safeGet br bc amat == Just Offi =
let flood acc fcoord@(fr, fc) =
let ncoords = [] ++
(if (fr + 1, fc) `notElem` acc &&
M.safeGet (fr + 1) fc amat == Just Offi
then [(fr + 1, fc)]
else []) ++
(if (fr - 1, fc) `notElem` acc &&
M.safeGet (fr - 1) fc amat == Just Offi
then [(fr - 1, fc)]
else []) ++
(if (fr, fc - 1) `notElem` acc &&
M.safeGet fr (fc - 1) amat == Just Offi
then [(fr, fc - 1)]
else []) ++
(if (fr, fc + 1) `notElem` acc &&
M.safeGet fr (fc + 1) amat == Just Offi
then [(fr, fc + 1)]
else [])
in foldl flood (acc ++ ncoords) ncoords
roomcoords = flood [] coord
b = Boundaries
(minimum (map fst roomcoords), minimum (map snd roomcoords))
(maximum (map fst roomcoords), maximum (map snd roomcoords))
neighs = map (\(a, b) -> (a, fromJust b)) (filter ((/=Nothing) . snd)
[ (North, M.safeGet (fst (matmin b) - 2) (snd (matmin b)) amat)
, (South, M.safeGet (fst (matmax b) + 2) (snd (matmin b)) amat)
, (East, M.safeGet (fst (matmin b)) (snd (matmin b) - 2) amat)
, (West, M.safeGet (fst (matmin b)) (snd (matmax b) + 2) amat)
])
in
if Hall `elem` map snd neighs
then
let nroot =
if GRoom neighs b `notElem` connects (head root)
then
GHall
{ connects = connects (head root) ++ [GRoom neighs b]
} : tail root
else root
in buildGraph amat nroot (br, 1 + snd (matmax b))
else
let nroot = root ++
if GRoom neighs b `elem` root
then []
else [GRoom neighs b]
in buildGraph amat nroot (br, 1 + snd (matmax b))
| otherwise =
buildGraph amat root (br, maxCol br (bc + 1))
in buildGraph mat [GHall []] (2, 2)
buildDoors :: Matrix TileState -> [Graph] -> IO (Matrix TileState)
buildDoors input graph = do
traceIO ("graph: " ++ show (tail graph))
foldM placeDoors input graph
where
placeDoors :: Matrix TileState -> Graph -> IO (Matrix TileState)
placeDoors amat (GHall conns) =
foldM placeDoors amat conns
placeDoors amat (GRoom neighs bounds) =
if Hall `elem` map snd neighs
then do
traceIO "door in Hall"
let halls = filter ((== Hall) . snd) neighs
idx <- randomRIO (0, length halls - 1)
let (dir, _) = halls !! idx
case dir of
North ->
inRow
amat
(fst (matmin bounds) - 1)
(snd (matmin bounds), snd (matmax bounds))
South ->
inRow
amat
(fst (matmax bounds) + 1)
(snd (matmin bounds), snd (matmax bounds))
East ->
inCol
amat
(fst (matmin bounds), fst (matmax bounds))
(snd (matmin bounds) - 1)
West ->
inCol
amat
(fst (matmin bounds), fst (matmax bounds))
(snd (matmax bounds) + 1)
else do
traceIO "door in Office"
idx <- randomRIO (0, length neighs - 1)
let (dir, _) = neighs !! idx
case dir of
North ->
inRow
amat
(fst (matmin bounds) - 1)
(snd (matmin bounds), snd (matmax bounds))
South ->
inRow
amat
(fst (matmax bounds) + 1)
(snd (matmin bounds), snd (matmax bounds))
East ->
inCol
amat
(fst (matmin bounds), fst (matmax bounds))
(snd (matmin bounds) - 1)
West ->
inCol
amat
(fst (matmin bounds), fst (matmax bounds))
(snd (matmax bounds) + 1)
inRow :: Matrix TileState -> Int -> (Int, Int) -> IO (Matrix TileState)
inRow mat row cols = do
col <- randomRIO cols
let tile = mat M.! (row, col)
if tile == Wall
&& length (filter
(== Wall)
(M.toList (M.submatrix (row - 1) (row + 1) col col mat)))
== 1
then
if Door `elem` M.toList (M.submatrix row row (fst cols) (snd cols) mat)
then return mat
else do
traceIO ("placing door: " ++ show (row, col))
return $ M.setElem Door (row, col) mat
else
inRow mat row cols
inCol :: Matrix TileState -> (Int, Int) -> Int -> IO (Matrix TileState)
inCol mat rows col = do
row <- randomRIO rows
let tile = mat M.! (row, col)
if tile == Wall
&& length (filter
(== Wall)
(M.toList (M.submatrix row row (col - 1) (col + 1) mat)))
== 1
then
if Door `elem` M.toList (M.submatrix (fst rows) (snd rows) col col mat)
then return mat
else do
traceIO ("placing door: " ++ show (row, col))
return $ M.setElem Door (row, col) mat
else
inCol mat rows col