Remove GenWorld datatype

src/Dodge/Layout.hs

@@ -36,10 +36,10 @@ import Data.Maybe
 import Data.Function
 import Control.Monad.State
 
-generateLevelFromRoomList :: IM.IntMap Room -> World -> GenWorld
-generateLevelFromRoomList gr' w = over gWorld initWallZoning 
-    . over gWorld randomCompass
-    . over gWorld setupWorldBounds
+generateLevelFromRoomList :: IM.IntMap Room -> World -> World
+generateLevelFromRoomList gr' w = initWallZoning 
+    . randomCompass
+    . setupWorldBounds
     . placeWires
     . doAfterPlacements
     . doInPlacements
@@ -61,26 +61,26 @@ generateLevelFromRoomList gr' w = over gWorld initWallZoning
 randomCompass :: World -> World
 randomCompass w = w & cameraRot .~ (takeOne [0,0.5*pi,pi,1.5*pi] & evalState $ _randGen w)
 
-putFloorTiles :: GenWorld -> GenWorld
-putFloorTiles gw = gw & gWorld . floorTiles .~ floorsFromGenWorld gw
+putFloorTiles :: World -> World
+putFloorTiles gw = gw & floorTiles .~ floorsFromGenWorld gw
 
-setFloors :: GenWorld -> GenWorld
+setFloors :: World -> World
 setFloors = putFloorTiles . setTiles
 
 -- note the order of traversal of the rooms is important
 -- hence the reverse
 -- this is not ideal: should do this in some more sensible way
-setTiles :: GenWorld -> GenWorld
-setTiles gw = foldr setTile gw . reverse . IM.elems $ _genRooms $ _gWorld gw
+setTiles :: World -> World
+setTiles gw = foldr setTile gw . reverse . IM.elems $ _genRooms $ gw
 
-setTile :: Room -> GenWorld -> GenWorld
+setTile :: Room -> World -> World
 setTile r gw = case _rmFloor r of
     Tiled {} -> gw
-    InheritFloor -> gw & gWorld . genRooms . ix (fromJust (_rmMID r)) . rmFloor .~ Tiled [t & tilePoly .~ poly]
+    InheritFloor -> gw & genRooms . ix (fromJust (_rmMID r)) . rmFloor .~ Tiled [t & tilePoly .~ poly]
   where
     t = case _rmMParent r of
         Nothing -> Tile poly (V2 0 0) (V2 1 0) 16
-        Just pid -> head $ _tiles $ _rmFloor $ _genRooms (_gWorld gw) IM.! pid
+        Just pid -> head $ _tiles $ _rmFloor $ _genRooms gw IM.! pid
     poly = orderPolygon . convexHullSafe . nubBy ((==) `on` roundPoint2) $ concat $ _rmPolys r
 
 shuffleRoomPos :: RandomGen g => Room -> State g Room
@@ -88,9 +88,8 @@ shuffleRoomPos rm = do
     newPos <- shuffle $ _rmPos rm
     return $ rm & rmPos .~ newPos
 
-placeWires :: GenWorld -> GenWorld
-placeWires w = w
-    & gWorld .~ foldr placeRoomWires (_gWorld w) (_genRooms $ _gWorld w)
+placeWires :: World -> World
+placeWires w = foldr placeRoomWires ( w) (_genRooms w)
 
 placeRoomWires :: Room -> World -> World
 placeRoomWires rm w = IM.foldr ($) w 
@@ -118,43 +117,43 @@ placeWire rm (WallWire p _ h1) (WallWire q _ h2) = foregroundShape
     rightpleftq x = isRHS rmcen p x && isLHS rmcen q x
     rs = _rmShift rm
 
-doAfterPlacements :: GenWorld -> GenWorld
-doAfterPlacements gw = foldr doAfterPlacement gw (_genPlacements $ _gWorld gw)
+doAfterPlacements :: World -> World
+doAfterPlacements gw = foldr doAfterPlacement gw (_genPlacements gw)
 
-doAfterPlacement :: [(Placement,Int)] -> GenWorld -> GenWorld
+doAfterPlacement :: [(Placement,Int)] -> World -> World
 doAfterPlacement pmntis gw = gRandify gw $ do
     (pmnt,i) <- takeOne pmntis
-    let (newgw,rm) = fst $ placeSpot (gw,_genRooms (_gWorld gw) IM.! i) pmnt
-    return $ newgw & gWorld . genRooms . ix i .~ rm
+    let (newgw,rm) = fst $ placeSpot (gw,_genRooms ( gw) IM.! i) pmnt
+    return $ newgw & genRooms . ix i .~ rm
 
-doInPlacements :: ( IM.IntMap [Placement],GenWorld) -> GenWorld
+doInPlacements :: ( IM.IntMap [Placement],World) -> World
 doInPlacements (im,w) = 
-    let (gw,rms) = mapAccumR (doRoomInPlacements im) w (_genRooms $ _gWorld w)
-    in gw & gWorld . genRooms .~ rms
+    let (gw,rms) = mapAccumR (doRoomInPlacements im) w (_genRooms w)
+    in gw & genRooms .~ rms
 
-doRoomInPlacements :: IM.IntMap [Placement] -> GenWorld -> Room -> (GenWorld, Room)
+doRoomInPlacements :: IM.IntMap [Placement] -> World -> Room -> (World, Room)
 doRoomInPlacements im w rm = foldr f (w,rm) $ _rmInPmnt rm
   where
     f (InPlacement plf i) (w',r') = fst $ placeSpot (w',r') (plf $ im IM.! i)
 
-doOutPlacements :: GenWorld -> ( IM.IntMap [Placement], GenWorld)
-doOutPlacements w = let ((pmnts,gw),rms) = mapAccumR doRoomOutPlacements (IM.empty,w) (_genRooms $ _gWorld w)
-    in (pmnts,gw & gWorld . genRooms .~ rms)
+doOutPlacements :: World -> ( IM.IntMap [Placement], World)
+doOutPlacements w = let ((pmnts,gw),rms) = mapAccumR doRoomOutPlacements (IM.empty,w) (_genRooms w)
+    in (pmnts,gw & genRooms .~ rms)
 
-doRoomOutPlacements :: (IM.IntMap [Placement], GenWorld) 
+doRoomOutPlacements :: (IM.IntMap [Placement], World) 
     -> Room 
-    -> ( (IM.IntMap [Placement], GenWorld) , Room )
+    -> ( (IM.IntMap [Placement], World) , Room )
 doRoomOutPlacements imw r = foldr f ( imw, r ) $ _rmOutPmnt r
   where
     f (OutPlacement pl i) ( (im,w) , rm ) = 
         let ((neww,newrm),plmnts) = placeSpot (w,rm) pl
         in ((IM.insert i plmnts im, neww) , newrm )
 
-doIndividualPlacements :: GenWorld -> GenWorld
-doIndividualPlacements gw = let (gw', rms) = mapAccumR doRoomPlacements gw (_genRooms $ _gWorld gw)
-    in gw' & gWorld . genRooms .~ rms
+doIndividualPlacements :: World -> World
+doIndividualPlacements gw = let (gw', rms) = mapAccumR doRoomPlacements gw (_genRooms gw)
+    in gw' & genRooms .~ rms
 
-doRoomPlacements :: GenWorld -> Room -> (GenWorld, Room)
+doRoomPlacements :: World -> Room -> (World, Room)
 doRoomPlacements w rm = foldl' (\wr -> fst . placeSpot wr) (w,rm) $ _rmPmnts rm
 
 setupWorldBounds :: World -> World
@@ -236,8 +235,8 @@ gameRoomFromRoom rm = GameRoom
 floorsFromRooms :: [Room] -> [(Point3,Point3)]
 floorsFromRooms = concatMap (concatMap tileToRenderList . getTiles . _rmFloor . doRoomShift)
 
-floorsFromGenWorld :: GenWorld -> [(Point3,Point3)]
-floorsFromGenWorld = floorsFromRooms . IM.elems . _genRooms . _gWorld
+floorsFromGenWorld :: World -> [(Point3,Point3)]
+floorsFromGenWorld = floorsFromRooms . IM.elems . _genRooms
 
 getTiles :: Floor -> [Tile]
 getTiles fl = case fl of