Refactor, try to limit dependencies

src/Dodge/Data/ArcStep.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -6,8 +5,8 @@ module Dodge.Data.ArcStep where
 
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.CrWlID
-import GHC.Generics
 import Geometry.Data
 
 data ArcStep = ArcStep
@@ -15,21 +14,13 @@ data ArcStep = ArcStep
     , _asDir :: Float
     , _asObject :: CrWlID --Maybe (Either Creature Wall)
     }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON ArcStep where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON ArcStep
+    deriving (Eq, Ord, Show, Read)
 
 data NextArcStep
     = EndArc
     | DefaultArcStep
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON NextArcStep where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON NextArcStep
+    deriving (Eq, Ord, Show, Read)
 
 makeLenses ''ArcStep
+deriveJSON defaultOptions ''ArcStep
+deriveJSON defaultOptions ''NextArcStep

src/Dodge/Data/Beam.hs

@@ -1,56 +1,56 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Beam where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Color
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 {- | Linear beams. Last only one frame.
  - Can interact with one another in a limited manner
  - can probably be moved to a separate file
- -}
+-}
 data Beam = Beam
-    { _bmDraw   :: BeamDraw -- Beam -> Picture
-    , _bmPos    :: Point2
-    , _bmDir    :: Float
+    { _bmDraw :: BeamDraw -- Beam -> Picture
+    , _bmPos :: Point2
+    , _bmDir :: Float
     , _bmDamage :: Int
-    , _bmColor  :: Color
+    , _bmColor :: Color
     , _bmPoints :: [Point2]
     , _bmFirstPoints :: [Point2]
-    , _bmRange  :: Float
+    , _bmRange :: Float
     , _bmPhaseV :: Float
     , _bmOrigin :: Maybe Int
-    , _bmType   :: BeamType
+    , _bmType :: BeamType
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Beam  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Beam 
-data BeamDraw = BasicBeamDraw
+    deriving (Eq, Ord, Show, Read)
+
+data BeamDraw
+    = BasicBeamDraw
     | BeamDrawColor Color
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BeamDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BeamDraw 
-data BeamCombineType = FlameBeamCombine
+    deriving (Eq, Ord, Show, Read)
+
+data BeamCombineType
+    = FlameBeamCombine
     | LasBeamCombine
     | TeslaBeamCombine
     | SplitBeamCombine
     | NoBeamCombine
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BeamCombineType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BeamCombineType 
-data BeamType 
-    = BeamCombine 
+    deriving (Eq, Ord, Show, Read)
+
+data BeamType
+    = BeamCombine
         { _beamCombine :: BeamCombineType -- (Point2 , (Point2,Point2,Beam) , (Point2,Point2,Beam)) -> World -> World
         }
     | BeamSimple
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BeamType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BeamType 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''BeamType
 makeLenses ''Beam
+deriveJSON defaultOptions ''BeamType
+deriveJSON defaultOptions ''Beam
+deriveJSON defaultOptions ''BeamDraw
+deriveJSON defaultOptions ''BeamCombineType

src/Dodge/Data/Block.hs

@@ -1,45 +1,50 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Block where
-import GHC.Generics
-import Data.Aeson
-import Shape.Data
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Block (
+    module Dodge.Data.Block,
+    module Dodge.Data.Material,
+    module Dodge.Data.PathGraph,
+) where
+
 import Color
+import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import qualified Data.IntSet as IS
 import Dodge.Data.Material
 import Dodge.Data.PathGraph
 import Geometry
-import Control.Lens
-import qualified Data.IntSet as IS
+import Shape.Data
+
 data Block = Block
-    { _blID         :: Int
-    , _blWallIDs    :: IS.IntSet
-    , _blHP         :: Int
-    , _blShadows    :: [Int]   -- a list of blocks/walls? that are not shown when this block exists
-    , _blFootprint  :: [Point2]
-    , _blPos        :: Point2
-    , _blDir        :: Float
-    , _blHeight     :: Float
-    , _blMaterial   :: Material
-    , _blDraw       :: BlockDraw --Block -> SPic
-    , _blObstructs  :: [(Int,Int,PathEdge)]
+    { _blID :: Int
+    , _blWallIDs :: IS.IntSet
+    , _blHP :: Int
+    , _blShadows :: [Int] -- a list of blocks/walls? that are not shown when this block exists
+    , _blFootprint :: [Point2]
+    , _blPos :: Point2
+    , _blDir :: Float
+    , _blHeight :: Float
+    , _blMaterial :: Material
+    , _blDraw :: BlockDraw --Block -> SPic
+    , _blObstructs :: [(Int, Int, PathEdge)]
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Block  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Block 
-data BlockDraw = BlockDrawMempty
+    deriving (Eq, Ord, Show, Read)
+
+data BlockDraw
+    = BlockDrawMempty
     | BlockDrawBlSh BlSh
     | BlockDraws [BlockDraw]
-    | BlockDrawColHeightPoss Color Float [Point2] 
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BlockDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BlockDraw 
-data BlSh = BlShMempty
+    | BlockDrawColHeightPoss Color Float [Point2]
+    deriving (Eq, Ord, Show, Read)
+
+data BlSh
+    = BlShMempty
     | BlShConst Shape
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BlSh  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BlSh 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Block
+deriveJSON defaultOptions ''Block
+deriveJSON defaultOptions ''BlockDraw
+deriveJSON defaultOptions ''BlSh

src/Dodge/Data/Bounds.hs

@@ -1,23 +1,22 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Bounds
-    where
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Bounds where
+
 import Control.Lens
-import GHC.Generics
 import Data.Aeson
+import Data.Aeson.TH
 
 data Bounds = Bounds
-    { _bdMinX            :: Float
-    , _bdMaxX            :: Float
-    , _bdMinY            :: Float
-    , _bdMaxY            :: Float
+    { _bdMinX :: Float
+    , _bdMaxX :: Float
+    , _bdMinY :: Float
+    , _bdMaxY :: Float
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Bounds  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Bounds 
+    deriving (Eq, Ord, Show, Read)
+
 defaultBounds :: Bounds
 defaultBounds = Bounds 0 0 0 0
 
 makeLenses ''Bounds
+deriveJSON defaultOptions ''Bounds

src/Dodge/Data/Bullet.hs

@@ -1,8 +1,10 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
-module Dodge.Data.Bullet where
+module Dodge.Data.Bullet 
+    ( module Dodge.Data.Bullet 
+    , module Dodge.Data.Damage
+    )where
 
 import Control.Lens
 import Data.Aeson

src/Dodge/Data/Button.hs

@@ -1,67 +1,67 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Button where
-import GHC.Generics
-import Data.Aeson
-import Dodge.Data.WorldEffect
+
+import Color
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.WorldEffect
 import Geometry.Data
 import Sound.Data
-import Color
-data ButtonDraw = DefaultDrawButton Color
+
+data ButtonDraw
+    = DefaultDrawButton Color
     | DefaultDrawSwitch Color Color
     | DrawNoButton
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON ButtonDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON ButtonDraw 
-data ButtonEvent = ButtonDoNothing
+    deriving (Eq, Ord, Show, Read)
+
+data ButtonEvent
+    = ButtonDoNothing
     | ButtonPress
-        {_bpState :: ButtonState
-        ,_bpEvent :: ButtonEvent
-        ,_bpSound :: SoundID
-        ,_bpEff :: WdWd
+        { _bpState :: ButtonState
+        , _bpEvent :: ButtonEvent
+        , _bpSound :: SoundID
+        , _bpEff :: WdWd
         }
---    | ButtonSwitch
---        {_bonState :: ButtonState
---        ,_bonEvent :: ButtonEvent
---        ,_bonSound :: SoundID
---        ,_bonEff :: WorldEffect
---        ,_boffState :: ButtonState
---        ,_boffEvent :: ButtonEvent
---        ,_boffSound :: SoundID
---        ,_boffEff :: WorldEffect
---        }
-    | ButtonSimpleSwith
-        {_bonEff :: WdWd
-        ,_boffEff :: WdWd
+    | --    | ButtonSwitch
+      --        {_bonState :: ButtonState
+      --        ,_bonEvent :: ButtonEvent
+      --        ,_bonSound :: SoundID
+      --        ,_bonEff :: WorldEffect
+      --        ,_boffState :: ButtonState
+      --        ,_boffEvent :: ButtonEvent
+      --        ,_boffSound :: SoundID
+      --        ,_boffEff :: WorldEffect
+      --        }
+      ButtonSimpleSwith
+        { _bonEff :: WdWd
+        , _boffEff :: WdWd
         }
     | ButtonAccessTerminal
-  deriving (Eq,Show,Read,Generic)
-instance ToJSON ButtonEvent  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON ButtonEvent 
-data Button = Button 
-    { _btPict   :: ButtonDraw --Button -> SPic
-    , _btPos    :: Point2
-    , _btRot    :: Float
-    , _btEvent  :: ButtonEvent --Button -> World -> World
-    , _btID     :: Int
-    , _btText   :: String
-    , _btState  :: ButtonState
+    deriving (Eq, Show, Read)
+
+data Button = Button
+    { _btPict :: ButtonDraw --Button -> SPic
+    , _btPos :: Point2
+    , _btRot :: Float
+    , _btEvent :: ButtonEvent --Button -> World -> World
+    , _btID :: Int
+    , _btText :: String
+    , _btState :: ButtonState
     , _btTermMID :: Maybe Int
-    , _btName   :: String
-    , _btColor  :: Color
+    , _btName :: String
+    , _btColor :: Color
     }
-  deriving (Eq,Show,Read,Generic)
-instance ToJSON Button  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Button 
+    deriving (Eq, Show, Read)
+
 data ButtonState = BtOn | BtOff | BtNoLabel
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON ButtonState  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON ButtonState 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Button
 makeLenses ''ButtonEvent
+deriveJSON defaultOptions ''ButtonDraw
+deriveJSON defaultOptions ''ButtonEvent
+deriveJSON defaultOptions ''Button
+deriveJSON defaultOptions ''ButtonState

src/Dodge/Data/CamouflageStatus.hs

@@ -1,11 +1,14 @@
-{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.CamouflageStatus where
-import GHC.Generics
+
 import Data.Aeson
+import Data.Aeson.TH
+
 data CamouflageStatus
     = FullyVisible
     | Invisible
-  deriving (Eq,Ord,Enum,Read,Show,Bounded,Generic)
-instance ToJSON CamouflageStatus where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CamouflageStatus
+    deriving (Eq, Ord, Enum, Read, Show, Bounded)
+
+deriveJSON defaultOptions ''CamouflageStatus

src/Dodge/Data/Cloud.hs

@@ -1,18 +1,19 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Cloud where
-import GHC.Generics
-import Data.Aeson
-import Geometry
+
 import Color
 import Control.Lens
-data CloudDraw = CloudColor Float Float Color -- radius-multiply fade-time color
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry
+
+data CloudDraw
+    = CloudColor Float Float Color -- radius-multiply fade-time color
     | DrawGasCloud Color
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CloudDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CloudDraw 
+    deriving (Eq, Ord, Show, Read)
+
 data Cloud = Cloud
     { _clPos :: Point3
     , _clVel :: Point3
@@ -22,15 +23,14 @@ data Cloud = Cloud
     , _clTimer :: Int
     , _clType :: CloudType
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Cloud  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Cloud 
+    deriving (Eq, Ord, Show, Read)
+
 data CloudType
     = SmokeCloud
     | GasCloud
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CloudType where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CloudType
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Cloud
+deriveJSON defaultOptions ''CloudDraw
+deriveJSON defaultOptions ''Cloud
+deriveJSON defaultOptions ''CloudType

src/Dodge/Data/Config.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -6,8 +5,8 @@ module Dodge.Data.Config where
 
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import qualified Data.Set as S
-import GHC.Generics
 
 {-# ANN module "HLint: ignore Use camelCase" #-}
 
@@ -27,7 +26,7 @@ data Configuration = Configuration
     , _debug_view_clip_bounds :: RoomClipping
     , _debug_booleans :: S.Set DebugBool -- consider using Data.BitSet
     }
-    deriving (Generic, Show)
+    deriving (Show)
 
 data DebugBool
     = Show_ms_frame
@@ -52,23 +51,13 @@ data DebugBool
     | Inspect_wall
     | Show_nodes_near_select
     | Show_path_between
-    deriving (Generic, Eq, Ord, Bounded, Enum, Show)
+    deriving (Eq, Ord, Bounded, Enum, Show)
 
 data ResFactor = FullRes | HalfRes | QuarterRes
-    deriving (Generic, Show, Eq, Ord, Enum, Bounded)
-
-instance ToJSON ResFactor where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON ResFactor
+    deriving (Show, Eq, Ord, Enum, Bounded)
 
 data RoomClipping = NoRoomClipBoundaries | AllRoomClipBoundaries | IntersectingRoomClipBoundaries
-    deriving (Generic, Show, Eq, Ord, Enum, Bounded)
-
-instance ToJSON RoomClipping where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON RoomClipping
+    deriving (Show, Eq, Ord, Enum, Bounded)
 
 resFactorNum :: ResFactor -> Int
 resFactorNum rf = case rf of
@@ -76,18 +65,6 @@ resFactorNum rf = case rf of
     HalfRes -> 2
     QuarterRes -> 4
 
-makeLenses ''Configuration
-
-instance ToJSON DebugBool where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON DebugBool
-
-instance ToJSON Configuration where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON Configuration
-
 defaultConfig :: Configuration
 defaultConfig =
     Configuration
@@ -105,18 +82,13 @@ defaultConfig =
         , _gameplay_rotate_to_wall = True
         , _debug_booleans = S.singleton Show_ms_frame
         , _debug_view_clip_bounds = NoRoomClipBoundaries
-        --    , _debug_show_sound           = False
-        --    , _debug_seconds_frame  = True
-        --    , _debug_noclip         = False
-        --    , _debug_mouse_position = False
-        --    , _debug_cr_status      = False
-        --    , _debug_cr_awareness   = False
-        --    , _debug_view_boundaries = False
-        --    , _debug_pathing    = False
-        --    , _debug_walls    = False
-        --    , _debug_remove_LOS      = False
-        --    , _debug_cull_more_lights     = False
         }
 
 debugOn :: DebugBool -> Configuration -> Bool
 debugOn db = S.member db . _debug_booleans
+
+makeLenses ''Configuration
+deriveJSON defaultOptions ''ResFactor
+deriveJSON defaultOptions ''RoomClipping
+deriveJSON defaultOptions ''DebugBool
+deriveJSON defaultOptions ''Configuration

src/Dodge/Data/Corpse.hs

@@ -1,27 +1,26 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Corpse where
-import GHC.Generics
-import Data.Aeson
-import ShapePicture.Data
-import Geometry.Data
 
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+import ShapePicture.Data
+
 data CorpseResurrection = NoResurrection
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CorpseResurrection  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CorpseResurrection 
+    deriving (Eq, Ord, Show, Read)
+
 data Corpse = Corpse
-    { _cpID  :: Int
+    { _cpID :: Int
     , _cpPos :: Point2
     , _cpDir :: Float
     , _cpSPic :: SPic
     , _cpRes :: CorpseResurrection
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Corpse  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Corpse 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Corpse
+deriveJSON defaultOptions ''CorpseResurrection
+deriveJSON defaultOptions ''Corpse

src/Dodge/Data/CrGroupParams.hs

@@ -1,26 +1,25 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.CrGroupParams
-    where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
-import qualified Data.IntSet as IS
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.CrGroupParams where
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import qualified Data.IntSet as IS
+import Geometry.Data
+
 data CrGroupParams = CrGroupParams
-    { _crGroupParamID   :: Int
-    , _crGroupIDs       :: IS.IntSet
-    , _crGroupCenter    :: Point2
-    , _crGroupUpdate    :: CrGroupUpdate --World -> CrGroupParams -> Maybe CrGroupParams
+    { _crGroupParamID :: Int
+    , _crGroupIDs :: IS.IntSet
+    , _crGroupCenter :: Point2
+    , _crGroupUpdate :: CrGroupUpdate --World -> CrGroupParams -> Maybe CrGroupParams
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CrGroupParams  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CrGroupParams 
+    deriving (Eq, Ord, Show, Read)
+
 data CrGroupUpdate = DefaultCrGroupUpdate
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CrGroupUpdate  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CrGroupUpdate 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''CrGroupParams
+deriveJSON defaultOptions ''CrGroupParams
+deriveJSON defaultOptions ''CrGroupUpdate

src/Dodge/Data/Creature.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -9,11 +8,15 @@ module Dodge.Data.Creature (
     module Dodge.Data.Creature.Perception,
     module Dodge.Data.Creature.Memory,
     module Dodge.Data.Creature.Stance,
-    module Dodge.Data.ActionPlan
+    module Dodge.Data.ActionPlan,
+    module Dodge.Data.Item,
+    module Dodge.Data.Material,
+    module Dodge.Data.Hammer,
 ) where
 
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import qualified Data.Map.Strict as M
 import Dodge.Data.ActionPlan
 import Dodge.Data.Creature.Memory
@@ -24,7 +27,6 @@ import Dodge.Data.Creature.State
 import Dodge.Data.Hammer
 import Dodge.Data.Item
 import Dodge.Data.Material
-import GHC.Generics
 import Geometry.Data
 import qualified IntMapHelp as IM
 
@@ -68,32 +70,23 @@ data Creature = Creature
     , _crStatistics :: CreatureStatistics
     , _crCamouflage :: CamouflageStatus
     }
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON Creature where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON Creature
+    deriving (Eq, Show, Read)
 
 data CreatureCorpse = MakeDefaultCorpse
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON CreatureCorpse where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON CreatureCorpse
+    deriving (Eq, Ord, Show, Read)
 
 data Intention = Intention
     { _targetCr :: Maybe Creature
     , _mvToPoint :: Maybe Point2
     , _viewPoint :: Maybe Point2
     }
-    deriving (Eq, Show, Read, Generic)
+    deriving (Eq, Show, Read)
 
-instance ToJSON Intention where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON Intention
+crSel :: Creature -> Int
+crSel = _iselPos . _crInvSel
 
 makeLenses ''Creature
 makeLenses ''Intention
+deriveJSON defaultOptions ''Creature
+deriveJSON defaultOptions ''CreatureCorpse
+deriveJSON defaultOptions ''Intention

src/Dodge/Data/Creature/Memory.hs

@@ -1,18 +1,18 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Creature.Memory
-    where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Creature.Memory where
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data Memory = Memory
     { _soundsToInvestigate :: [Point2]
-    , _nodesSearched       :: [Int]
+    , _nodesSearched :: [Int]
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Memory  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Memory 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Memory
+deriveJSON defaultOptions ''Memory

src/Dodge/Data/Creature/Misc.hs

@@ -1,80 +1,87 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Creature.Misc
-    ( module Dodge.Data.Creature.Misc
-    , module Dodge.Data.CamouflageStatus
-    ) where
-import GHC.Generics
-import Data.Aeson
-import Dodge.Data.FloatFunction
-import Dodge.Data.CamouflageStatus
-import Sound.Data
-import Geometry.Data
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Creature.Misc (
+    module Dodge.Data.Creature.Misc,
+    module Dodge.Data.CamouflageStatus,
+) where
+
 import Color
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.CamouflageStatus
+import Dodge.Data.FloatFunction
+import Geometry.Data
+import Sound.Data
+
 data CreatureStatistics = CreatureStatistics
-    { _strength       :: Int
-    , _dexterity      :: Int
-    , _intelligence   :: Int
+    { _strength :: Int
+    , _dexterity :: Int
+    , _intelligence :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CreatureStatistics  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CreatureStatistics 
-data Vocalization 
+    deriving (Eq, Ord, Show, Read)
+
+data Vocalization
     = Mute
     | Vocalization
-        {_vcSound :: SoundID
-        ,_vcWarnings :: [SoundID]
-        ,_vcMaxCoolDown :: Int
-        ,_vcCoolDown    :: Int
+        { _vcSound :: SoundID
+        , _vcWarnings :: [SoundID]
+        , _vcMaxCoolDown :: Int
+        , _vcCoolDown :: Int
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Vocalization  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Vocalization 
-data CrMvType 
+    deriving (Eq, Ord, Show, Read)
+
+data CrMvType
     = NoMvType
-    | MvWalking { _mvSpeed :: Float }
+    | MvWalking {_mvSpeed :: Float}
     | CrMvType
-        { _mvSpeed      :: Float
-        , _mvTurnRad    :: FloatFloat
-        , _mvTurnJit    :: Float
-        , _mvAimSpeed   :: FloatFloat
+        { _mvSpeed :: Float
+        , _mvTurnRad :: FloatFloat
+        , _mvTurnJit :: Float
+        , _mvAimSpeed :: FloatFloat
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CrMvType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CrMvType 
-data HumanoidAI = YourAI | ChaseAI | InanimateAI | SpreadGunAI | PistolAI
-    | LtAutoAI | LauncherAI | SwarmAI | AutoAI | FlockArmourChaseAI | MiniGunAI
-    | LongAI | MultGunAI
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON HumanoidAI  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON HumanoidAI 
+    deriving (Eq, Ord, Show, Read)
+
+data HumanoidAI
+    = YourAI
+    | ChaseAI
+    | InanimateAI
+    | SpreadGunAI
+    | PistolAI
+    | LtAutoAI
+    | LauncherAI
+    | SwarmAI
+    | AutoAI
+    | FlockArmourChaseAI
+    | MiniGunAI
+    | LongAI
+    | MultGunAI
+    deriving (Eq, Ord, Show, Read)
+
 data CreatureType
     = Humanoid
-        { _skinHead     :: Color
-        , _skinUpper    :: Color
-        , _skinLower    :: Color
-        , _humanoidAI   :: HumanoidAI
+        { _skinHead :: Color
+        , _skinUpper :: Color
+        , _skinLower :: Color
+        , _humanoidAI :: HumanoidAI
         }
     | Barreloid {_barrelType :: BarrelType}
     | Lampoid {_lampHeight :: Float, _lampColor :: Point3, _lampLSID :: Maybe Int}
     | Turretoid
     | NonDrawnCreature
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CreatureType where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CreatureType
+    deriving (Eq, Ord, Show, Read)
+
 data BarrelType = PlainBarrel | ExplosiveBarrel
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON BarrelType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON BarrelType 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''CreatureStatistics
 makeLenses ''Vocalization
-makeLenses ''CrMvType 
+makeLenses ''CrMvType
 makeLenses ''CreatureType
+deriveJSON defaultOptions ''CreatureStatistics
+deriveJSON defaultOptions ''Vocalization
+deriveJSON defaultOptions ''CrMvType
+deriveJSON defaultOptions ''HumanoidAI
+deriveJSON defaultOptions ''CreatureType
+deriveJSON defaultOptions ''BarrelType

src/Dodge/Data/Creature/Perception.hs

@@ -1,82 +1,77 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Creature.Perception
-    ( Perception (..)
-    , Vigilance (..)
-    , Attention (..)
-    , Awareness (..)
-    , Vision (..)
-    , Audition (..)
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Creature.Perception (
+    Perception (..),
+    Vigilance (..),
+    Attention (..),
+    Awareness (..),
+    Vision (..),
+    Audition (..),
     -- lenses
-    , getAttentiveTo
-    , getFixated
-    , cpAttention
-    , cpVigilance
-    , cpAwareness
-    , cpVision
-    , cpAudition
-    , viFOV
-    , viDist
-    , auDist
-    )
-    where
-import GHC.Generics
-import Data.Aeson
+    getAttentiveTo,
+    getFixated,
+    cpAttention,
+    cpVigilance,
+    cpAwareness,
+    cpVision,
+    cpAudition,
+    viFOV,
+    viDist,
+    auDist,
+) where
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.FloatFunction
 import qualified IntMapHelp as IM
+
 data Perception = Perception
-    { _cpVigilance     :: Vigilance
-    , _cpAttention     :: Attention
-    , _cpAwareness     :: IM.IntMap Awareness
-    , _cpVision         :: Vision
-    , _cpAudition       :: Audition
+    { _cpVigilance :: Vigilance
+    , _cpAttention :: Attention
+    , _cpAwareness :: IM.IntMap Awareness
+    , _cpVision :: Vision
+    , _cpAudition :: Audition
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Perception  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Perception 
+    deriving (Eq, Ord, Show, Read)
+
 data Vision = Eyes
-    { _viFOV  :: FloatFloat
+    { _viFOV :: FloatFloat
     , _viDist :: FloatFloat
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Vision  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Vision 
+    deriving (Eq, Ord, Show, Read)
+
 newtype Audition = Ears
     { _auDist :: FloatFloat
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Audition  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Audition 
+    deriving (Eq, Ord, Show, Read)
+
 data Vigilance
     = Comatose
     | Asleep
     | Lethargic
     | Vigilant
     | Overstrung
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Vigilance where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Vigilance
+    deriving (Eq, Ord, Show, Read)
+
 data Attention
-    = AttentiveTo {_getAttentiveTo :: IM.IntMap Awareness }
-    | Fixated {_getFixated :: Int }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Attention where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Attention
+    = AttentiveTo {_getAttentiveTo :: IM.IntMap Awareness}
+    | Fixated {_getFixated :: Int}
+    deriving (Eq, Ord, Show, Read)
+
 data Awareness
     = Suspicious Float
     | Cognizant Float
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Awareness where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Awareness
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Perception
 makeLenses ''Vision
 makeLenses ''Audition
 makeLenses ''Attention
+deriveJSON defaultOptions ''Perception
+deriveJSON defaultOptions ''Vision
+deriveJSON defaultOptions ''Audition
+deriveJSON defaultOptions ''Vigilance
+deriveJSON defaultOptions ''Attention
+deriveJSON defaultOptions ''Awareness

src/Dodge/Data/Creature/Stance.hs

@@ -1,50 +1,47 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Creature.Stance
-  where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Creature.Stance where
 
 import Control.Lens
-data Stance = Stance 
-    {_carriage     :: Carriage
-    ,_posture      :: Posture
-    ,_strideLength :: Int
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
+data Stance = Stance
+    { _carriage :: Carriage
+    , _posture :: Posture
+    , _strideLength :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Stance  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Stance 
-data Carriage 
-    = Walking 
-        { _strideAmount :: Int 
+    deriving (Eq, Ord, Show, Read)
+
+data Carriage
+    = Walking
+        { _strideAmount :: Int
         , _currentFoot :: FootForward
         }
     | Standing
     | Floating
     | Flying
     | Boosting Point2
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Carriage  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Carriage 
+    deriving (Eq, Ord, Show, Read)
+
 data FootForward
     = LeftForward
     | RightForward
     | WasLeftForward
     | WasRightForward
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON FootForward where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON FootForward
-data Posture = Aiming 
+    deriving (Eq, Ord, Show, Read)
+
+data Posture
+    = Aiming
     | AtEase
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Posture  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Posture 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Stance
 makeLenses ''Carriage
 makeLenses ''Posture
+deriveJSON defaultOptions ''Stance
+deriveJSON defaultOptions ''Carriage
+deriveJSON defaultOptions ''FootForward
+deriveJSON defaultOptions ''Posture

src/Dodge/Data/Creature/State.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -7,9 +6,9 @@ module Dodge.Data.Creature.State where
 import Color
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import qualified Data.IntSet as IS
 import Dodge.Data.Damage
-import GHC.Generics
 import Geometry.Data
 
 data CreatureState = CrSt
@@ -17,33 +16,18 @@ data CreatureState = CrSt
     , _csSpState :: CrSpState
     , _csDropsOnDeath :: CreatureDropType
     }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON CreatureState where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON CreatureState
+    deriving (Eq, Ord, Show, Read)
 
 data CreatureDropType
     = DropAll
     | DropAmount Int
     | DropSpecific [Int]
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON CreatureDropType where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON CreatureDropType
+    deriving (Eq, Ord, Show, Read)
 
 data CrSpState
     = Barrel {_piercedPoints :: [Point2]}
     | GenCr
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON CrSpState where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON CrSpState
+    deriving (Eq, Ord, Show, Read)
 
 data Faction
     = GenericFaction Int
@@ -54,12 +38,7 @@ data Faction
     | NoFaction
     | ColorFaction Color
     | PlayerFaction
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON Faction where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON Faction
+    deriving (Eq, Ord, Show, Read)
 
 data CrGroup
     = LoneWolf
@@ -69,13 +48,13 @@ data CrGroup
         }
     | CrGroupID {_crGroupID :: Int}
     | ShieldGroup
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON CrGroup where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON CrGroup
+    deriving (Eq, Ord, Show, Read)
 
 makeLenses ''CreatureState
 makeLenses ''CrSpState
 makeLenses ''CrGroup
+deriveJSON defaultOptions ''CreatureState
+deriveJSON defaultOptions ''CreatureDropType
+deriveJSON defaultOptions ''CrSpState
+deriveJSON defaultOptions ''Faction
+deriveJSON defaultOptions ''CrGroup

src/Dodge/Data/Damage.hs

@@ -1,49 +1,54 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-{- 
+{-# LANGUAGE TemplateHaskell #-}
+
+{-
 Datatypes describing the type of damage effects that are to be applied to
 creatures.
 -}
-module Dodge.Data.Damage 
-    ( module Dodge.Data.Damage
-    , module Dodge.Data.Damage.Type
-    ) where
-import GHC.Generics
+module Dodge.Data.Damage (
+    module Dodge.Data.Damage,
+    module Dodge.Data.Damage.Type,
+) where
+
+import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.Damage.Type
 import Geometry.Data
-import Control.Lens
+
 data DamageEffect
-    = PushDamage 
-        { _dePush :: Float 
+    = PushDamage
+        { _dePush :: Float
         , _dePushExp :: Float
         , _dePushRadius :: Float
         }
-    | TorqueDamage { _deTorque :: Float }
-    | PushBackDamage {_dePushBack :: Float }
+    | TorqueDamage {_deTorque :: Float}
+    | PushBackDamage {_dePushBack :: Float}
     | NoDamageEffect
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON DamageEffect where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON DamageEffect
-data Damage = Damage 
+    deriving (Eq, Ord, Show, Read)
+
+data Damage = Damage
     { _dmType :: DamageType
-    , _dmAmount :: Int , _dmFrom :: Point2 , _dmAt :: Point2 , _dmTo :: Point2 
+    , _dmAmount :: Int
+    , _dmFrom :: Point2
+    , _dmAt :: Point2
+    , _dmTo :: Point2
     , _dmEffect :: DamageEffect
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Damage  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Damage 
+    deriving (Eq, Ord, Show, Read)
+
 isElectrical :: Damage -> Bool
 isElectrical dm = case _dmType dm of
     ELECTRICAL -> True
     _ -> False
+
 isMovementDam :: Damage -> Bool
 isMovementDam dm = case _dmType dm of
     TORQUEDAM -> True
     PUSHDAM -> True
     _ -> False
+
 makeLenses ''Damage
 makeLenses ''DamageEffect
+deriveJSON defaultOptions ''DamageEffect
+deriveJSON defaultOptions ''Damage

src/Dodge/Data/Damage/Type.hs

@@ -1,27 +1,31 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Damage.Type where
-import GHC.Generics
+
 import Data.Aeson
-data DamageType 
-    = PIERCING 
-    | BLUNT    
-    | CUTTING  
+import Data.Aeson.TH
+
+data DamageType
+    = PIERCING
+    | BLUNT
+    | CUTTING
     | SPARKING
     | CRUSHING
     | SHATTERING
-    | FLAMING  
-    | LASERING 
+    | FLAMING
+    | LASERING
     | ELECTRICAL
     | EXPLOSIVE
     | CONCUSSIVE
-    | TORQUEDAM 
-    | PUSHDAM   
-    | POISONDAM 
+    | TORQUEDAM
+    | PUSHDAM
+    | POISONDAM
     | ENTERREMENT
-  deriving (Eq,Ord,Show,Read,Enum,Bounded,Generic)
-instance ToJSON DamageType where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON DamageType 
+    deriving (Eq, Ord, Show, Read, Enum, Bounded)
+
 instance ToJSONKey DamageType
-instance FromJSONKey DamageType 
+
+instance FromJSONKey DamageType
+
+deriveJSON defaultOptions ''DamageType

src/Dodge/Data/Distortion.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
 module Dodge.Data.Distortion where

src/Dodge/Data/Door.hs

@@ -1,47 +1,52 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Door where
-import GHC.Generics
-import Data.Aeson
-import Dodge.Data.PathGraph
-import Dodge.Data.MountedObject
-import Geometry.Data
-import Dodge.Data.WorldEffect
-import qualified Data.IntSet as IS
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Door (
+    module Dodge.Data.Door,
+    module Dodge.Data.MountedObject,
+    module Dodge.Data.PathGraph,
+    module Dodge.Data.WorldEffect,
+) where
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import qualified Data.IntSet as IS
+import Dodge.Data.MountedObject
+import Dodge.Data.PathGraph
+import Dodge.Data.WorldEffect
+import Geometry.Data
+
 data DoorStatus = DoorOpen | DoorClosed | DoorHalfway | DoorInt Int
-  deriving (Eq, Ord, Show,Read,Generic)
-instance ToJSON DoorStatus  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON DoorStatus 
-data PushSource = PushesItself
+    deriving (Eq, Ord, Show, Read)
+
+data PushSource
+    = PushesItself
     | PushedBy Int
     | NotPushed
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON PushSource  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON PushSource 
+    deriving (Eq, Ord, Show, Read)
+
 data Door = Door
     { _drID :: Int
     , _drWallIDs :: IS.IntSet
-    , _drStatus  :: DoorStatus
+    , _drStatus :: DoorStatus
     , _drTrigger :: WdBl
-    , _drMech    :: DrWdWd
-    , _drPos :: (Point2,Point2)
-    , _drOpenPos :: (Point2,Point2)
-    , _drClosePos :: (Point2,Point2)
-    , _drHP     :: Int
-    , _drDeath  :: DrWdWd
-    , _drSpeed  :: Float
+    , _drMech :: DrWdWd
+    , _drPos :: (Point2, Point2)
+    , _drOpenPos :: (Point2, Point2)
+    , _drClosePos :: (Point2, Point2)
+    , _drHP :: Int
+    , _drDeath :: DrWdWd
+    , _drSpeed :: Float
     , _drPushedBy :: PushSource
     , _drPushes :: Maybe Int
     , _drMounts :: [MountedObject]
-    , _drObstructs  :: [(Int,Int,PathEdge)]
-    , _drObstacleType   :: EdgeObstacle
+    , _drObstructs :: [(Int, Int, PathEdge)]
+    , _drObstacleType :: EdgeObstacle
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Door  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Door 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Door
+deriveJSON defaultOptions ''DoorStatus
+deriveJSON defaultOptions ''PushSource
+deriveJSON defaultOptions ''Door

src/Dodge/Data/EnergyBall.hs

@@ -1,25 +1,26 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.EnergyBall where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Color
-import Dodge.Data.Damage.Type
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.Damage.Type
+import Geometry.Data
+
 data EnergyBall = EnergyBall
-    { _ebVel    :: Point2
-    , _ebColor  :: Color
+    { _ebVel :: Point2
+    , _ebColor :: Color
     , _ebPos :: Point2
-    , _ebWidth :: Float 
+    , _ebWidth :: Float
     , _ebTimer :: Int
-    , _ebEff :: (DamageType,Int)
+    , _ebEff :: (DamageType, Int)
     , _ebZ :: Float
     , _ebRot :: Float
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON EnergyBall  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON EnergyBall 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''EnergyBall
+deriveJSON defaultOptions ''EnergyBall

src/Dodge/Data/Equipment/Misc.hs

@@ -1,9 +1,11 @@
 {-# LANGUAGE StrictData #-}
-{-# LANGUAGE DeriveGeneric #-}
-module Dodge.Data.Equipment.Misc
-    where
-import GHC.Generics
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Equipment.Misc where
+
 import Data.Aeson
+import Data.Aeson.TH
+
 data EquipSite
     = GoesOnHead
     | GoesOnChest
@@ -11,10 +13,8 @@ data EquipSite
     | GoesOnWrist
     | GoesOnLegs
     | GoesOnSpecial
-    deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON EquipSite where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON EquipSite
+    deriving (Eq, Ord, Show, Read)
+
 data EquipPosition
     = OnHead
     | OnChest
@@ -23,9 +23,11 @@ data EquipPosition
     | OnRightWrist
     | OnLegs
     | OnSpecial
-    deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON EquipPosition where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON EquipPosition
+    deriving (Eq, Ord, Show, Read)
+
 instance ToJSONKey EquipPosition
+
 instance FromJSONKey EquipPosition
+
+deriveJSON defaultOptions ''EquipSite
+deriveJSON defaultOptions ''EquipPosition

src/Dodge/Data/Flame.hs

@@ -1,23 +1,24 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Flame where
-import GHC.Generics
-import Data.Aeson
-import Control.Lens
-import Geometry.Data
+
 import Color
+import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data Flame = Flame
-    { _flVel    :: Point2
-    , _flColor  :: Color
-    , _flPos    :: Point2
-    , _flWidth  :: Float 
-    , _flTimer  :: Int
-    , _flZ      :: Float
+    { _flVel :: Point2
+    , _flColor :: Color
+    , _flPos :: Point2
+    , _flWidth :: Float
+    , _flTimer :: Int
+    , _flZ :: Float
     , _flOriginalVel :: Point2
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Flame  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Flame 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Flame
+deriveJSON defaultOptions ''Flame

src/Dodge/Data/Flare.hs

@@ -1,27 +1,28 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Flare where
-import GHC.Generics
-import Data.Aeson
+
 import Color
-import Geometry
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry
+
 data Flare
-    = MuzFlare 
-        { _flarePoly   :: [Point2]
-        , _flareColor  :: Color
-        , _flareTran3  :: Point3
-        , _flareTime   :: Int
+    = MuzFlare
+        { _flarePoly :: [Point2]
+        , _flareColor :: Color
+        , _flareTran3 :: Point3
+        , _flareTime :: Int
         }
-    | CircFlare 
-        { _flareColor  :: Color
-        , _flareAlpha  :: Float
-        , _flareTran3  :: Point3
-        , _flareTime   :: Int
+    | CircFlare
+        { _flareColor :: Color
+        , _flareAlpha :: Float
+        , _flareTran3 :: Point3
+        , _flareTime :: Int
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Flare where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Flare
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Flare
+deriveJSON defaultOptions ''Flare

src/Dodge/Data/FloatFunction.hs

@@ -1,13 +1,17 @@
-{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.FloatFunction where
-import GHC.Generics
+
 import Data.Aeson
-data FloatFloat = FloatID
+import Data.Aeson.TH
+
+data FloatFloat
+    = FloatID
     | FloatFOV Float
     | FloatLessCheck Float
     | FloatAbsCheckGreaterLess Float Float Float
     | FloatConst Float
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON FloatFloat  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON FloatFloat 
+    deriving (Eq, Ord, Show, Read)
+
+deriveJSON defaultOptions ''FloatFloat

src/Dodge/Data/FloorItem.hs

@@ -1,16 +1,16 @@
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-{-# LANGUAGE DeriveGeneric #-}
-module Dodge.Data.FloorItem
-    where
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.FloorItem where
+
+import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.Item
 import Geometry.Data
-import GHC.Generics
-import Data.Aeson
-import Control.Lens
-data FloorItem = FlIt { _flIt :: Item , _flItPos :: Point2 , _flItRot :: Float, _flItID :: Int}
-  deriving (Eq,Show,Read,Generic)
-instance ToJSON FloorItem where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON FloorItem
+
+data FloorItem = FlIt {_flIt :: Item, _flItPos :: Point2, _flItRot :: Float, _flItID :: Int}
+    deriving (Eq, Show, Read)
+
 makeLenses ''FloorItem
+deriveJSON defaultOptions ''FloorItem

src/Dodge/Data/ForegroundShape.hs

@@ -1,21 +1,22 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.ForegroundShape where
-import GHC.Generics
+
+import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import Geometry
 import ShapePicture
-import Control.Lens
+
 data ForegroundShape = ForegroundShape
     { _fsID :: Int
     , _fsPos :: Point2
     , _fsDir :: Float
-    , _fsRad :: Float  -- This should probably be a bounding box
+    , _fsRad :: Float -- This should probably be a bounding box
     , _fsSPic :: SPic
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON ForegroundShape  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON ForegroundShape 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''ForegroundShape
+deriveJSON defaultOptions ''ForegroundShape

src/Dodge/Data/GenParams.hs

@@ -1,24 +1,23 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.GenParams
-    where
-import GHC.Generics
-import Data.Aeson
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.GenParams where
+
 import Color
-import Dodge.Data.Damage.Type
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
 import qualified Data.Map.Strict as M
+import Dodge.Data.Damage.Type
+
 newtype GenParams = GenParams
-    { _sensorCoding :: M.Map DamageType (PaletteColor,DecorationShape)
+    { _sensorCoding :: M.Map DamageType (PaletteColor, DecorationShape)
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON GenParams where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON GenParams 
+    deriving (Eq, Ord, Show, Read)
+
 data DecorationShape = PLUS | SQUARE | CIRCLE | THREELINES
-  deriving (Eq,Ord,Enum,Show,Read,Generic)
-instance ToJSON DecorationShape where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON DecorationShape 
+    deriving (Eq, Ord, Enum, Show, Read)
+
 makeLenses ''GenParams
+deriveJSON defaultOptions ''GenParams
+deriveJSON defaultOptions ''DecorationShape

src/Dodge/Data/GenWorld.hs

@@ -0,0 +1,143 @@
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.GenWorld (
+    module Dodge.Data.GenWorld,
+    module Dodge.Data.Room,
+    module Dodge.Data.RoomCluster,
+    module Dodge.Data.World,
+) where
+
+import Color
+import Control.Lens
+import Control.Monad.State
+import qualified Data.Set as S
+import Data.Tile
+import Dodge.Data.Room
+import Dodge.Data.RoomCluster
+import Dodge.Data.World
+import Geometry.Data
+import qualified IntMapHelp as IM
+import Picture.Data
+import System.Random
+
+data GenWorld = GenWorld
+    { _gwWorld :: World
+    , _genPlacements :: IM.IntMap [(Placement, Int)]
+    , _genRooms :: IM.IntMap Room
+    }
+
+---- ROOM DATATYPES
+data PSType
+    = PutCrit {_unPutCrit :: Creature}
+    | PutMachine {_putMachinePoly :: [Point2], _putMachineMachine :: Machine, _putMachineWall :: Wall}
+    | PutLS LightSource
+    | PutButton {_putButton :: Button}
+    | PutProp Prop
+    | PutTerminal {_unputTerminal :: Terminal}
+    | PutFlIt {_putItem :: Item}
+    | PutPPlate PressPlate
+    | PutBlock {_putBlock :: Block, _putWall :: Wall, _putPoly :: [Point2]}
+    | PutCoord Point2
+    | PutMod Modification
+    | PutTrigger Bool
+    | PutLineBlock
+        { _putWall :: Wall
+        , _putWidth :: Float
+        , _putStartPoint :: Point2
+        , _putEndPoint :: Point2
+        }
+    | PutWall {_pwPoly :: [Point2], _pwWall :: Wall}
+    | PutSlideDr Door Wall EdgeObstacle Float Point2 Point2
+    | PutDoor Color EdgeObstacle WdBl [(Point2, Point2)]
+    | RandPS (State StdGen PSType)
+    | PutForeground ForegroundShape
+    | PutDecoration Picture
+    | PutWorldUpdate (PlacementSpot -> World -> World)
+    | PutNothing
+    | PutUsingGenParams (World -> (World, PSType))
+    | PutID {_putID :: Int}
+
+-- maybe there is a monadic implementation of this?
+-- add room effect for any placement spot?
+data PlacementSpot
+    = PS {_psPos :: Point2, _psRot :: Float}
+    | PSNoShiftCont {_psPos :: Point2, _psRot :: Float}
+    | PSPos
+        { _psSelect :: RoomPos -> Room -> Maybe (PlacementSpot, RoomPos)
+        , _psRoomEff :: RoomPos -> Room -> Room
+        , _psFallback :: Maybe Placement
+        }
+    | PSRoomRand
+        { _psRoomRandPointNum :: Int
+        , _psRandShift :: (Point2, Float) -> PlacementSpot
+        }
+
+-- TODO attempt to unify/simplify this union type
+data Placement
+    = Placement
+        { _plOrder :: Int
+        , _plSpot :: PlacementSpot
+        , _plType :: PSType
+        , _plMID :: Maybe Int
+        , _plIDCont :: World -> Placement -> Maybe Placement
+        }
+    | PlacementUsingPos Point3 (Point3 -> Placement) -- allows a placement to use a shifted position
+    | RandomPlacement {_unRandomPlacement :: State StdGen Placement}
+    | PickOnePlacement Int Placement
+
+{- The '_rmPolys' lists which polygons should be cut out to form the indestructible walls of the room.
+Link pairs contain a position and rotation to attach to another room;
+0 is for links going to another room to the north, pi/2 for links going to a room to the west, etc.
+TODO : Explain path, does it need both directions?
+Placement spots allow things to be put in the room during level generation.
+Room bounds between a new room and previously placed rooms are checked during level generation,
+assigning no bounds will allow rooms to overlap.  -}
+data Room = Room
+    { _rmPolys :: [[Point2]]
+    , _rmLinks :: [RoomLink]
+    , --  the Int is the number of previous outlinks that have been assigned
+      _rmLinkEff ::
+        RoomLink -> -- child link
+        Room -> -- child room
+        Int -> -- child number
+        RoomLink -> -- parent link
+        Room -> -- parent room
+        Room
+    , _rmPos :: [RoomPos]
+    , _rmPath :: S.Set (Point2, Point2)
+    , _rmPmnts :: [Placement]
+    , _rmInPmnt :: [InPlacement]
+    , _rmOutPmnt :: [OutPlacement]
+    , _rmBound :: [[Point2]]
+    , _rmFloor :: Floor
+    , _rmName :: String
+    , _rmShift :: (Point2, Float)
+    , _rmViewpoints :: [Point2]
+    , _rmRandPSs :: [State StdGen (Point2, Float)]
+    , _rmStartWires :: IM.IntMap RoomWire
+    , _rmEndWires :: IM.IntMap RoomWire
+    , _rmConnectsTo :: S.Set RoomLinkType -> Bool
+    , _rmMID :: Maybe Int
+    , _rmMParent :: Maybe Int
+    , _rmChildren :: [Int]
+    , _rmType :: RoomType
+    , _rmClusterStatus :: ClusterStatus
+    }
+
+data OutPlacement = OutPlacement
+    { _opPlacement :: Placement
+    , _opPlacementID :: Int
+    }
+
+data InPlacement = InPlacement
+    { _ipPlacement :: [Placement] -> Placement
+    , _ipPlacementID :: Int
+    }
+
+makeLenses ''GenWorld
+makeLenses ''Room
+makeLenses ''RoomType
+makeLenses ''PSType
+makeLenses ''PlacementSpot
+makeLenses ''Placement

src/Dodge/Data/Gust.hs

@@ -1,20 +1,20 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Gust
-    where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Gust where
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data Gust = Gust
-    { _guID  :: Int
+    { _guID :: Int
     , _guPos :: Point2
     , _guVel :: Point2
     , _guTime :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Gust  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Gust 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Gust
+deriveJSON defaultOptions ''Gust

src/Dodge/Data/HUD.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -6,18 +5,13 @@ module Dodge.Data.HUD where
 
 import Control.Lens
 import Data.Aeson
-import GHC.Generics
+import Data.Aeson.TH
 import Geometry.Data
 
 data HUDElement
     = DisplayInventory {_subInventory :: SubInventory}
     | DisplayCarte
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON HUDElement where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON HUDElement
+    deriving (Eq, Ord, Show, Read)
 
 data SubInventory
     = NoSubInventory
@@ -26,12 +20,7 @@ data SubInventory
     | InspectInventory
     | LockedInventory
     | DisplayTerminal {_termID :: Int}
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON SubInventory where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON SubInventory
+    deriving (Eq, Ord, Show, Read)
 
 data HUD = HUD
     { _hudElement :: HUDElement
@@ -39,13 +28,11 @@ data HUD = HUD
     , _carteZoom :: Float
     , _carteRot :: Float
     }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON HUD where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON HUD
+    deriving (Eq, Ord, Show, Read)
 
 makeLenses ''HUD
 makeLenses ''HUDElement
 makeLenses ''SubInventory
+deriveJSON defaultOptions ''HUDElement
+deriveJSON defaultOptions ''SubInventory
+deriveJSON defaultOptions ''HUD

src/Dodge/Data/Hammer.hs

@@ -1,23 +1,23 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Hammer where
-import GHC.Generics
-import Data.Aeson
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+
 data HammerType
     = NoHammer
     | HasHammer {_hammerPosition :: HammerPosition}
-  deriving (Eq, Ord, Show,Read,Generic)
-instance ToJSON HammerType where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON HammerType
-data HammerPosition 
+    deriving (Eq, Ord, Show, Read)
+
+data HammerPosition
     = HammerDown
     | HammerReleased
     | HammerUp
-  deriving (Eq, Ord, Show,Read,Generic)
-instance ToJSON HammerPosition  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON HammerPosition 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''HammerType
+deriveJSON defaultOptions ''HammerType
+deriveJSON defaultOptions ''HammerPosition

src/Dodge/Data/Item.hs

@@ -47,5 +47,8 @@ data Item = Item
     }
     deriving (Eq, Show, Read)
 
+_itUseAimStance :: Item -> AimStance
+_itUseAimStance = _aimStance . _heldAim . _itUse
+
 makeLenses ''Item
 deriveJSON defaultOptions ''Item

src/Dodge/Data/Item/Combine.hs

@@ -70,7 +70,8 @@ data CraftType
     deriving (Eq, Ord, Show, Enum, Read)
 
 data ItemBaseType
-    = HELD {_ibtHeld :: HeldItemType}
+    = NoItemType
+    | HELD {_ibtHeld :: HeldItemType}
     | LEFT {_ibtLeft :: LeftItemType}
     | EQUIP {_ibtEquip :: EquipItemType}
     | Consumable {_ibtConsumable :: ConsumableItemType}

src/Dodge/Data/Item/CurseStatus.hs

@@ -1,15 +1,15 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
---{-# LANGUAGE TemplateHaskell #-}
-module Dodge.Data.Item.CurseStatus
-    where
-import GHC.Generics
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Item.CurseStatus where
+
 import Data.Aeson
-data CurseStatus 
-    = Uncursed 
-    | UndroppableIdentified 
+import Data.Aeson.TH
+
+data CurseStatus
+    = Uncursed
+    | UndroppableIdentified
     | UndroppableUnidentified
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON CurseStatus  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON CurseStatus 
+    deriving (Eq, Ord, Show, Read)
+
+deriveJSON defaultOptions ''CurseStatus

src/Dodge/Data/Item/HeldDelay.hs

@@ -0,0 +1,29 @@
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Item.HeldDelay where
+
+import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+
+data UseDelay -- should just be Delay
+    = NoDelay
+    | FixedRate
+        { _rateMax :: Int
+        , _rateTime :: Int
+        }
+    | VariableRate
+        { _rateMax :: Int
+        , _rateTime :: Int
+        , _rateMaxMax :: Int
+        , _rateMinMax :: Int
+        }
+    | WarmUpNoDelay
+        { _warmTime :: Int
+        , _warmMax :: Int
+        }
+    deriving (Eq, Ord, Show, Read)
+
+makeLenses ''UseDelay
+deriveJSON defaultOptions ''UseDelay

src/Dodge/Data/Item/Use.hs

@@ -6,8 +6,9 @@ module Dodge.Data.Item.Use (
     module Dodge.Data.Item.Use.Equipment,
     module Dodge.Data.Item.HeldUse,
     module Dodge.Data.Item.HeldScroll,
-    module Dodge.Data.Item.UseDelay,
+    module Dodge.Data.Item.HeldDelay,
     module Dodge.Data.Item.Use.Consumption,
+    module Dodge.Data.Hammer,
 ) where
 
 import Control.Lens
@@ -18,23 +19,23 @@ import Dodge.Data.Item.HeldScroll
 import Dodge.Data.Item.HeldUse
 import Dodge.Data.Item.Use.Consumption
 import Dodge.Data.Item.Use.Equipment
-import Dodge.Data.Item.UseDelay
+import Dodge.Data.Item.HeldDelay
 
 data ItemUse
-    = RightUse
-        { _rUse :: HeldUse
-        , _useDelay :: UseDelay
-        , _useMods :: HeldMod
-        , _useHammer :: HammerPosition
-        , _useAim :: AimParams
+    = HeldUse
+        { _heldUse :: HeldUse
+        , _heldDelay :: UseDelay
+        , _heldMods :: HeldMod
+        , _heldHammer :: HammerPosition
+        , _heldAim :: AimParams
         , _heldScroll :: HeldScroll
         , _heldConsumption :: HeldConsumption
         }
     | LeftUse
-        { _lUse :: Luse
-        , _useDelay :: UseDelay
-        , _useHammer :: HammerPosition
-        , _eqEq :: Equipment
+        { _leftUse :: Luse
+        , _leftDelay :: UseDelay
+        , _leftHammer :: HammerPosition
+        , _equipEffect :: EquipEffect
         , _leftConsumption :: LeftConsumption
         }
     | ConsumeUse
@@ -42,7 +43,7 @@ data ItemUse
         , _useAmount :: ItAmount
         }
     | EquipUse
-        { _eqEq :: Equipment
+        { _equipEffect :: EquipEffect
         }
     | CraftUse
         {_useAmount :: ItAmount}

src/Dodge/Data/Item/Use/Consumption/Ammo.hs

@@ -12,7 +12,6 @@ import Data.Aeson
 import Data.Aeson.TH
 import Dodge.Data.Bullet
 import Dodge.Data.Payload
-import Dodge.Data.Wall
 
 data ProjectileDraw = DrawShell | DrawRemoteShell | DrawDrone | DrawBlankProjectile
     deriving (Show, Read, Eq, Ord, Enum, Bounded)
@@ -48,11 +47,14 @@ data AmmoType
         , _amCreateGas :: GasCreate
         }
     | ForceFieldAmmo
-        { _amForceFieldType :: Wall
+        { _amForceFieldType :: ForceFieldType
         }
     | GenericAmmo
     deriving (Eq, Ord, Show, Read)
 
+data ForceFieldType = DefaultForceField
+    deriving (Eq, Ord, Show, Read)
+
 data GasCreate = CreatePoisonGas | CreateFlame
     deriving (Eq, Ord, Show, Enum, Bounded, Read)
 
@@ -63,3 +65,4 @@ deriveJSON defaultOptions ''ProjectileCreate
 deriveJSON defaultOptions ''ProjectileUpdate
 deriveJSON defaultOptions ''AmmoType
 deriveJSON defaultOptions ''GasCreate
+deriveJSON defaultOptions ''ForceFieldType

src/Dodge/Data/Item/Use/Equipment.hs

@@ -1,35 +1,34 @@
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-{-# LANGUAGE DeriveGeneric #-}
-module Dodge.Data.Item.Use.Equipment
-    ( module Dodge.Data.Equipment.Misc
-    , module Dodge.Data.Item.Use.Equipment
-    )
-    where
-import Dodge.Data.Item.HeldUse
-import Dodge.Data.Equipment.Misc
-import GHC.Generics
-import Data.Aeson
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Item.Use.Equipment (
+    module Dodge.Data.Equipment.Misc,
+    module Dodge.Data.Item.Use.Equipment,
+) where
+
 import Control.Lens
-data Equipment = Equipment
-    { _eqUse        :: Euse --Item -> Creature -> World -> World
-    , _eqOnEquip    :: Euse --Item -> Creature -> World -> World
-    , _eqOnRemove   :: Euse --Item -> Creature -> World -> World
-    , _eqSite       :: EquipSite
-    , _eqParams     :: EquipParams
-    , _eqViewDist   :: Maybe Float
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.Equipment.Misc
+import Dodge.Data.Item.HeldUse
+
+data EquipEffect = EquipEffect
+    { _eeUse :: Euse --Item -> Creature -> World -> World
+    , _eeOnEquip :: Euse --Item -> Creature -> World -> World
+    , _eeOnRemove :: Euse --Item -> Creature -> World -> World
+    , _eeSite :: EquipSite
+    , _eeParams :: EquipParams
+    , _eeViewDist :: Maybe Float
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Equipment  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Equipment 
+    deriving (Eq, Ord, Show, Read)
+
 data EquipParams
     = NoEquipParams
     | EquipID {_eparamID :: Int}
     | EquipCounter {_eparamInt :: Int}
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON EquipParams where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON EquipParams
-makeLenses ''Equipment
+    deriving (Eq, Ord, Show, Read)
+
+makeLenses ''EquipEffect
 makeLenses ''EquipParams
+deriveJSON defaultOptions ''EquipEffect
+deriveJSON defaultOptions ''EquipParams

src/Dodge/Data/Item/UseDelay.hs

@@ -1,28 +0,0 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE StrictData #-}
-{-# LANGUAGE TemplateHaskell #-}
-module Dodge.Data.Item.UseDelay where
-import GHC.Generics
-import Data.Aeson
-import Control.Lens
-data UseDelay -- should just be Delay
-    = NoDelay
-    | FixedRate
-        {_rateMax   :: Int
-        ,_rateTime  :: Int
-        }
-    | VariableRate
-        {_rateMax       :: Int
-        ,_rateTime      :: Int
-        ,_rateMaxMax    :: Int
-        ,_rateMinMax    :: Int
-        }
-    | WarmUpNoDelay
-        {_warmTime :: Int
-        ,_warmMax  :: Int
-        }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON UseDelay  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON UseDelay 
-makeLenses ''UseDelay

src/Dodge/Data/Laser.hs

@@ -1,39 +1,38 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Laser
-    where
-import GHC.Generics
-import Data.Aeson
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Laser where
+
 import Color
-import Geometry.Data
 import Control.Lens
-data LaserType = DamageLaser {_laserTypeDamage :: Int}
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
+data LaserType
+    = DamageLaser {_laserTypeDamage :: Int}
     | TargetLaser
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LaserType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LaserType 
+    deriving (Eq, Ord, Show, Read)
+
 data LaserStart = LaserStart
     { _lpPhaseV :: Float
     , _lpPos :: Point2
     , _lpDir :: Float
     , _lpColor :: Color
-    , _lpType   :: LaserType
+    , _lpType :: LaserType
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LaserStart  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LaserStart 
+    deriving (Eq, Ord, Show, Read)
+
 data Laser = Laser
-    { _laColor  :: Color
+    { _laColor :: Color
     , _laPoints :: [Point2]
-    , _laType   :: LaserType
+    , _laType :: LaserType
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Laser  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Laser 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Laser
 makeLenses ''LaserStart
 makeLenses ''LaserType
+deriveJSON defaultOptions ''LaserType
+deriveJSON defaultOptions ''LaserStart
+deriveJSON defaultOptions ''Laser

src/Dodge/Data/LightSource.hs

@@ -1,58 +1,55 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.LightSource where
-import GHC.Generics
-import Data.Aeson
-import Geometry
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry
 
 data LightSourceDraw = DefaultLightSourceDraw
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LightSourceDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LightSourceDraw 
-data TLSIntensity = ConstantIntensity
+    deriving (Eq, Ord, Show, Read)
+
+data TLSIntensity
+    = ConstantIntensity
     | TLSFade Point3 Int
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON TLSIntensity  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON TLSIntensity 
-data TLSUpdate = DestroyTLS
+    deriving (Eq, Ord, Show, Read)
+
+data TLSUpdate
+    = DestroyTLS
     | TimerTLS
     | IntensityTLS TLSIntensity
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON TLSUpdate  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON TLSUpdate 
+    deriving (Eq, Ord, Show, Read)
+
 data LSParam = LSParam
-    { _lsPos        :: !Point3
-    , _lsRad        :: !Float
-    , _lsCol        :: !Point3
+    { _lsPos :: !Point3
+    , _lsRad :: !Float
+    , _lsCol :: !Point3
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LSParam  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LSParam 
-data LightSource = LS  
-    { _lsID     :: Int
-    , _lsParam  :: LSParam
-    , _lsDir    :: Float
-    , _lsPict   :: LightSourceDraw --LightSource -> Picture
+    deriving (Eq, Ord, Show, Read)
+
+data LightSource = LS
+    { _lsID :: Int
+    , _lsParam :: LSParam
+    , _lsDir :: Float
+    , _lsPict :: LightSourceDraw --LightSource -> Picture
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LightSource  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LightSource 
-data TempLightSource = TLS 
-    { _tlsParam     :: LSParam
-    , _tlsUpdate    :: TLSUpdate --TempLightSource -> Maybe TempLightSource
-    , _tlsTime      :: Int
+    deriving (Eq, Ord, Show, Read)
+
+data TempLightSource = TLS
+    { _tlsParam :: LSParam
+    , _tlsUpdate :: TLSUpdate --TempLightSource -> Maybe TempLightSource
+    , _tlsTime :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON TempLightSource  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON TempLightSource 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''LSParam
 makeLenses ''LightSource
 makeLenses ''TempLightSource
+deriveJSON defaultOptions ''LightSourceDraw
+deriveJSON defaultOptions ''TLSIntensity
+deriveJSON defaultOptions ''TLSUpdate
+deriveJSON defaultOptions ''LSParam
+deriveJSON defaultOptions ''LightSource
+deriveJSON defaultOptions ''TempLightSource

src/Dodge/Data/LinearShockwave.hs

@@ -1,19 +1,20 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.LinearShockwave where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data LinearShockwave = LinearShockwave
     { _lwPos :: Point2
     , _lwID :: Int
-    , _lwPoints :: [(Point2,Point2)]
+    , _lwPoints :: [(Point2, Point2)]
     , _lwTimer :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON LinearShockwave  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON LinearShockwave 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''LinearShockwave
+deriveJSON defaultOptions ''LinearShockwave

src/Dodge/Data/Machine.hs

@@ -6,6 +6,9 @@ module Dodge.Data.Machine (
     module Dodge.Data.Machine.Sensor,
     module Dodge.Data.Material,
     module Dodge.Data.ObjectType,
+    module Dodge.Data.Item,
+    module Dodge.Data.Damage,
+    module Dodge.Data.GenParams,
 ) where
 
 import Color

src/Dodge/Data/Material.hs

@@ -1,12 +1,14 @@
---{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+--{-# LANGUAGE FlexibleInstances #-}
+--{-# LANGUAGE DeriveGeneric #-}
 module Dodge.Data.Material where
-import GHC.Generics
+
 import Data.Aeson
+import Data.Aeson.TH
+
 data Material = Wood | Dirt | Stone | Glass | Metal | Crystal | Flesh | Electronics
-  deriving (Eq,Ord,Show,Bounded,Enum,Read,Generic)
-instance ToJSON Material where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Material
+    deriving (Eq, Ord, Show, Bounded, Enum, Read)
+
+deriveJSON defaultOptions ''Material

src/Dodge/Data/Modification.hs

@@ -1,31 +1,30 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Modification
-    where
--- this naming is not good, parameterized world effect?
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Modification where
+
+import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.WorldEffect
 import Geometry.Data
-import Control.Lens
-import GHC.Generics
-import Data.Aeson
+
 data Modification
     = ModIDTimerPoint3Bool
-        { _mdID     :: Int
+        { _mdID :: Int
         , _mdExternalID :: Int
         , _mdUpdate :: MdWdWd
-        , _mdTimer  :: Int
+        , _mdTimer :: Int
         , _mdPoint3 :: Point3
-        , _mdBool   :: Bool
+        , _mdBool :: Bool
         }
     | ModIDID
-        { _mdID     :: Int
+        { _mdID :: Int
         , _mdExternalID1 :: Int
         , _mdExternalID2 :: Int
         , _mdUpdate :: MdWdWd
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Modification where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Modification
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Modification
+deriveJSON defaultOptions ''Modification

src/Dodge/Data/PosEvent.hs

@@ -1,23 +1,23 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.PosEvent where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data PosEventType = SparkSpawner
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON PosEventType  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON PosEventType 
+    deriving (Eq, Ord, Show, Read)
+
 data PosEvent = PosEvent
-    { _pvType   :: PosEventType
-    , _pvTimer  :: Int
-    , _pvPos    :: Point2
+    { _pvType :: PosEventType
+    , _pvTimer :: Int
+    , _pvPos :: Point2
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON PosEvent  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON PosEvent 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''PosEvent
+deriveJSON defaultOptions ''PosEventType
+deriveJSON defaultOptions ''PosEvent

src/Dodge/Data/PressPlate.hs

@@ -1,20 +1,20 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.PressPlate
-    where
-import GHC.Generics
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.PressPlate where
+
+import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import Geometry.Data
 import Picture
-import Control.Lens
-data PressPlateEvent = PressPlateId
+
+data PressPlateEvent
+    = PressPlateId
     | PPLevelReset
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON PressPlateEvent where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON PressPlateEvent
-data PressPlate = PressPlate 
+    deriving (Eq, Ord, Show, Read)
+
+data PressPlate = PressPlate
     { _ppPict :: Picture
     , _ppPos :: Point2
     , _ppRot :: Float
@@ -22,8 +22,8 @@ data PressPlate = PressPlate
     , _ppID :: Int
     , _ppText :: String
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON PressPlate  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON PressPlate 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''PressPlate
+deriveJSON defaultOptions ''PressPlateEvent
+deriveJSON defaultOptions ''PressPlate

src/Dodge/Data/Projectile.hs

@@ -1,16 +1,16 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Projectile where
-import GHC.Generics
+
+import Control.Lens
 import Data.Aeson
-import Dodge.Data.Payload
+import Data.Aeson.TH
 import Dodge.Data.Item.Use.Consumption.Ammo
 import Geometry.Data
-import Control.Lens
---data ProjectileType = ShellType
+
 data Proj
-    = RemoteShell    
+    = RemoteShell
         { _prjPos :: Point2
         , _prjStartPos :: Point2
         , _prjVel :: Point2
@@ -19,7 +19,7 @@ data Proj
         , _prjPayload :: Payload
         , _prjMITID :: Maybe Int
         }
-    | Shell 
+    | Shell
         { _prjPos :: Point2
         , _prjStartPos :: Point2
         , _prjVel :: Point2
@@ -34,8 +34,7 @@ data Proj
         , _prjUpdates :: [ProjectileUpdate]
         , _prjMITID :: Maybe Int
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Proj where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Proj
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Proj
+deriveJSON defaultOptions ''Proj

src/Dodge/Data/RadarBlip.hs

@@ -1,21 +1,22 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.RadarBlip where
-import GHC.Generics
-import Data.Aeson
+
 import Color
-import Geometry
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry
+
 data RadarBlip = RadarBlip
-    { _rbColor      :: Color
-    , _rbTime       :: Int
-    , _rbMaxTime    :: Int
-    , _rbRad        :: Float
-    , _rbPos        :: Point2
+    { _rbColor :: Color
+    , _rbTime :: Int
+    , _rbMaxTime :: Int
+    , _rbRad :: Float
+    , _rbPos :: Point2
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON RadarBlip  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON RadarBlip 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''RadarBlip
+deriveJSON defaultOptions ''RadarBlip

src/Dodge/Data/RightButtonOptions.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -6,8 +5,8 @@ module Dodge.Data.RightButtonOptions where
 
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.Equipment.Misc
-import GHC.Generics
 
 data RightButtonOptions
     = NoRightButtonOptions
@@ -18,24 +17,14 @@ data RightButtonOptions
         , _opAllocateEquipment :: AllocateEquipment
         , _opActivateEquipment :: ActivateEquipment
         }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON RightButtonOptions where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON RightButtonOptions
+    deriving (Eq, Ord, Show, Read)
 
 data ActivateEquipment
     = ActivateEquipment {_activateEquipment :: Int}
     | DeactivateEquipment {_deactivateEquipment :: Int}
     | ActivateDeactivateEquipment {_activateEquipment :: Int, _deactivateEquipment :: Int}
     | NoChangeActivateEquipment
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON ActivateEquipment where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON ActivateEquipment
+    deriving (Eq, Ord, Show, Read)
 
 data AllocateEquipment
     = DoNotMoveEquipment
@@ -58,13 +47,11 @@ data AllocateEquipment
     | RemoveEquipment
         { _allocOldPos :: EquipPosition
         }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON AllocateEquipment where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON AllocateEquipment
+    deriving (Eq, Ord, Show, Read)
 
 makeLenses ''RightButtonOptions
 makeLenses ''AllocateEquipment
 makeLenses ''ActivateEquipment
+deriveJSON defaultOptions ''RightButtonOptions
+deriveJSON defaultOptions ''ActivateEquipment
+deriveJSON defaultOptions ''AllocateEquipment

src/Dodge/Data/Room.hs

@@ -1,26 +1,30 @@
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Room where
+
+import Control.Lens
+import qualified Data.Set as S
 import Geometry
 
-import qualified Data.Set as S
-import Control.Lens
-
 data RoomPos = RoomPos
-    { _rpPos :: Point2 
+    { _rpPos :: Point2
     , _rpDir :: Float
     , _rpType :: S.Set RoomPosType
     , _rpLinkStatus :: RPLinkStatus
     , _rpPlacementUse :: Int
     }
-  deriving (Eq,Ord,Show)
+    deriving (Eq, Ord, Show)
 
 data RoomLink = RoomLink
-    { _rlType   :: S.Set RoomLinkType
-    , _rlPos    :: Point2
-    , _rlDir    :: Float
-    } deriving (Eq,Ord)
-data RoomType = DefaultRoomType
+    { _rlType :: S.Set RoomLinkType
+    , _rlPos :: Point2
+    , _rlDir :: Float
+    }
+    deriving (Eq, Ord)
+
+data RoomType
+    = DefaultRoomType
     | RectRoomType
         { _numLinkEW :: Int
         , _numLinkNS :: Int
@@ -29,7 +33,8 @@ data RoomType = DefaultRoomType
         , _rmWidth :: Float
         , _rmHeight :: Float
         }
-  deriving (Eq,Ord)
+    deriving (Eq, Ord)
+
 data RoomLinkType
     = OutLink
     | InLink
@@ -37,39 +42,42 @@ data RoomLinkType
     | OnEdge CardinalPoint
     | FromEdge CardinalPoint Int
     | BlockedLink
-    deriving (Eq,Ord,Show)
+    deriving (Eq, Ord, Show)
+
 data CardinalPoint
     = North
     | East
     | South
     | West
-    deriving (Eq,Ord,Show)
+    deriving (Eq, Ord, Show)
+
 data RoomWire
     = --RoomWire Point2 Float
-     WallWire Point2 Float Float
+      WallWire Point2 Float Float
 
 data RPLinkStatus
-    = UsedOutLink 
-        { _rplsType :: S.Set RoomLinkType 
+    = UsedOutLink
+        { _rplsType :: S.Set RoomLinkType
         , _rplsChildNum :: Int
         , _rplsOutRoomID :: Int
         }
-    | UsedInLink  
-        { _rplsType :: S.Set RoomLinkType 
+    | UsedInLink
+        { _rplsType :: S.Set RoomLinkType
         , _rplsInRoomID :: Int
         }
-    | UnusedLink  { _rplsType :: S.Set RoomLinkType }
+    | UnusedLink {_rplsType :: S.Set RoomLinkType}
     | NotLink
-  deriving (Eq,Ord,Show)
-data PathFromEdge = PathFromEdge CardinalPoint Int
-  deriving (Eq,Ord,Show)
+    deriving (Eq, Ord, Show)
 
-data RoomPosType 
+data PathFromEdge = PathFromEdge CardinalPoint Int
+    deriving (Eq, Ord, Show)
+
+data RoomPosType
     = RoomPosOnPath {_onPathFromEdges :: S.Set PathFromEdge}
     | RoomPosOffPath {_offPathFromEdges :: S.Set PathFromEdge}
     | RoomPosExLink
     | RoomPosLab Int
-  deriving (Eq,Ord,Show)
+    deriving (Eq, Ord, Show)
 
 makeLenses ''RoomLink
 makeLenses ''RoomPos

src/Dodge/Data/Shockwave.hs

@@ -1,31 +1,30 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-module Dodge.Data.Shockwave
-    where
-import GHC.Generics
-import Data.Aeson
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Shockwave where
+
 import Color
-import Geometry.Data
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data ShockwaveDirection = OutwardShockwave | InwardShockwave
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON ShockwaveDirection  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON ShockwaveDirection 
+    deriving (Eq, Ord, Show, Read)
+
 data Shockwave = Shockwave
-    { _swColor      :: Color
-    , _swDirection  :: ShockwaveDirection
+    { _swColor :: Color
+    , _swDirection :: ShockwaveDirection
     , _swInvulnerableCrs :: [Int]
-    , _swPos        :: Point2
-    , _swRad        :: Float
-    , _swDam        :: Int
-    , _swPush       :: Float
-    , _swMaxTime    :: Int
-    , _swTimer      :: Int
+    , _swPos :: Point2
+    , _swRad :: Float
+    , _swDam :: Int
+    , _swPush :: Float
+    , _swMaxTime :: Int
+    , _swTimer :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Shockwave  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Shockwave 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Shockwave
+deriveJSON defaultOptions ''ShockwaveDirection
+deriveJSON defaultOptions ''Shockwave

src/Dodge/Data/Spark.hs

@@ -1,23 +1,24 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Spark where
-import GHC.Generics
-import Data.Aeson
-import Dodge.Data.Damage.Type
-import Geometry.Data
+
 import Color
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.Damage.Type
+import Geometry.Data
+
 data Spark = Spark
-    { _skVel    :: Point2
-    , _skColor  :: Color
-    , _skPos    :: Point2
+    { _skVel :: Point2
+    , _skColor :: Color
+    , _skPos :: Point2
     , _skOldPos :: Point2
-    , _skWidth  :: Float 
+    , _skWidth :: Float
     , _skDamageType :: DamageType
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Spark  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Spark 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Spark
+deriveJSON defaultOptions ''Spark

src/Dodge/Data/Terminal.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE StrictData #-}
 {-# LANGUAGE TemplateHaskell #-}
 
@@ -7,40 +6,25 @@ module Dodge.Data.Terminal where
 import Color
 import Control.Lens
 import Data.Aeson
+import Data.Aeson.TH
 import qualified Data.Map.Strict as M
 import qualified Data.Text as T
 import Dodge.Data.WorldEffect
-import GHC.Generics
 
 data TerminalStatus = TerminalOff | TerminalBusy | TerminalReady
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON TerminalStatus where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalStatus
+    deriving (Eq, Ord, Show, Read)
 
 data TerminalInput = TerminalInput
     { _tiText :: T.Text
     , _tiFocus :: Bool
     , _tiSel :: (Int, Int)
     }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON TerminalInput where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalInput
+    deriving (Eq, Ord, Show, Read)
 
 data TerminalBootProgram
     = TerminalBootMempty
     | TerminalBootLines [TerminalLine]
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON TerminalBootProgram where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalBootProgram
+    deriving (Eq, Show, Read)
 
 data Terminal = Terminal
     { _tmID :: Int
@@ -60,31 +44,16 @@ data Terminal = Terminal
     , _tmCommandHistory :: [String]
     , _tmToggles :: M.Map String TerminalToggle
     }
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON Terminal where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON Terminal
+    deriving (Eq, Show, Read)
 
 data TerminalLineString = TerminalLineConst String Color
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON TerminalLineString where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalLineString
+    deriving (Eq, Ord, Show, Read)
 
 data TmTm
     = TmId
     | TmTmClearDisplayedLines
     | TmTmSetStatus TerminalStatus
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON TmTm where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TmTm
+    deriving (Eq, Ord, Show, Read)
 
 data TerminalLine
     = TerminalLineDisplay
@@ -99,34 +68,19 @@ data TerminalLine
         { _tlPause :: Int
         , _tlEffect :: TmWdWd --Terminal -> World -> World
         }
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON TerminalLine where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalLine
+    deriving (Eq, Show, Read)
 
 data TerminalToggle = TerminalToggle
     { _ttTriggerID :: Int
     , _ttDeathEffect :: BlBl
     }
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON TerminalToggle where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalToggle
+    deriving (Eq, Ord, Show, Read)
 
 data BlBl
     = BlNegate
     | BlConst Bool
     | BlId
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON BlBl where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON BlBl
+    deriving (Eq, Ord, Show, Read)
 
 data EffectArguments
     = NoArguments {_cmdEffect :: [TerminalLine]}
@@ -134,12 +88,7 @@ data EffectArguments
         { _argType :: String
         , _argList :: M.Map String [TerminalLine]
         }
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON EffectArguments where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON EffectArguments
+    deriving (Eq, Show, Read)
 
 data TerminalCommandEffect
     = TerminalCommandArguments EffectArguments
@@ -151,12 +100,7 @@ data TerminalCommandEffect
     | TerminalCommandEffectCommands
     | TerminalCommandEffectSingleCommand WdWd [String]
     | TerminalCommandEffectNone
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON TerminalCommandEffect where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalCommandEffect
+    deriving (Eq, Show, Read)
 
 data TerminalCommand = TerminalCommand
     { _tcString :: String
@@ -164,12 +108,7 @@ data TerminalCommand = TerminalCommand
     , _tcHelp :: String
     , _tcEffect :: TerminalCommandEffect -- Terminal -> World -> EffectArguments
     }
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON TerminalCommand where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TerminalCommand
+    deriving (Eq, Show, Read)
 
 makeLenses ''TerminalInput
 makeLenses ''Terminal
@@ -177,3 +116,15 @@ makeLenses ''TerminalLine
 makeLenses ''TerminalToggle
 makeLenses ''EffectArguments
 makeLenses ''TerminalCommand
+deriveJSON defaultOptions ''TerminalStatus
+deriveJSON defaultOptions ''TerminalInput
+deriveJSON defaultOptions ''TerminalBootProgram
+deriveJSON defaultOptions ''Terminal
+deriveJSON defaultOptions ''TerminalLineString
+deriveJSON defaultOptions ''TmTm
+deriveJSON defaultOptions ''TerminalLine
+deriveJSON defaultOptions ''TerminalToggle
+deriveJSON defaultOptions ''BlBl
+deriveJSON defaultOptions ''EffectArguments
+deriveJSON defaultOptions ''TerminalCommandEffect
+deriveJSON defaultOptions ''TerminalCommand

src/Dodge/Data/TeslaArc.hs

@@ -1,21 +1,22 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.TeslaArc where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Color
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.ArcStep
+import Geometry.Data
+
 data TeslaArc = TeslaArc
     { _taPoints :: [Point2]
     , _taTimer :: Int
     , _taArcSteps :: [ArcStep]
     , _taColor :: Color
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON TeslaArc  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON TeslaArc 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''TeslaArc
+deriveJSON defaultOptions ''TeslaArc

src/Dodge/Data/TractorBeam.hs

@@ -1,19 +1,20 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.TractorBeam where
-import GHC.Generics
-import Data.Aeson
-import Geometry.Data
+
 import Control.Lens
+import Data.Aeson
+import Data.Aeson.TH
+import Geometry.Data
+
 data TractorBeam = TractorBeam
     { _tbPos :: Point2
     , _tbStartPos :: Point2
     , _tbVel :: Point2
     , _tbTime :: Int
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON TractorBeam  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON TractorBeam 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''TractorBeam
+deriveJSON defaultOptions ''TractorBeam

src/Dodge/Data/Universe.hs

@@ -0,0 +1,85 @@
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Universe (
+    module Dodge.Data.Universe,
+    module Dodge.Data.Config,
+    module Dodge.Data.World,
+    module Data.Preload,
+    module Picture.Data,
+) where
+
+import Control.Lens
+import qualified Data.Map.Strict as M
+import Data.Preload
+import qualified Data.Text as T
+import Dodge.Data.Config
+import Dodge.Data.World
+import Picture.Data
+import SDL (Scancode)
+
+data Universe = Universe
+    { _uvWorld :: World
+    , _preloadData :: PreloadData
+    , _menuLayers :: [ScreenLayer]
+    , _savedWorlds :: M.Map SaveSlot World
+    , _uvIOEffects :: Universe -> IO Universe
+    , _uvConfig :: Configuration
+    , _uvTestString :: Universe -> [String]
+    }
+
+data SaveSlot
+    = QuicksaveSlot
+    | LevelStartSlot
+    | SaveSlotNum Int
+    deriving (Eq, Ord, Show, Read)
+
+data OptionScreenFlag = NormalOptions | GameOverOptions
+    deriving (Eq, Ord, Show, Read)
+
+data ScreenLayer
+    = OptionScreen
+        { _scTitle :: Universe -> String
+        , _scOptions :: [MenuOption]
+        , _scDefaultEff :: Universe -> IO (Maybe Universe)
+        , _scOptionFlag :: OptionScreenFlag
+        , _scOptionsOffset :: Int
+        }
+    | ColumnsScreen
+        { _scTitle :: Universe -> String
+        , _scColumns :: [(String, String)]
+        }
+    | InputScreen
+        { _scInput :: T.Text
+        , _scFooter :: String
+        }
+    | WaitScreen
+        { _scWaitMessage :: Universe -> String
+        , _scWaitTime :: Int
+        }
+    | DisplayScreen
+        { _scDisplay :: Universe -> Picture
+        }
+
+data MenuOption
+    = Toggle
+        { _moEff :: Universe -> IO (Maybe Universe)
+        , _moString :: Universe -> Either String (String, String)
+        , _moKey :: Scancode
+        }
+    | Toggle2
+        { _moKey1 :: Scancode
+        , _moEff1 :: Universe -> IO (Maybe Universe)
+        , _moKey2 :: Scancode
+        , _moEff2 :: Universe -> IO (Maybe Universe)
+        , _moString :: Universe -> Either String (String, String)
+        }
+    | InvisibleToggle
+        { _moKey :: Scancode
+        , _moEff :: Universe -> IO (Maybe Universe)
+        }
+
+data IntID a = IntID Int a
+
+makeLenses ''Universe
+makeLenses ''ScreenLayer

src/Dodge/Data/Wall.hs

@@ -1,64 +1,63 @@
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DeriveGeneric #-}
-module Dodge.Data.Wall where
-import GHC.Generics
-import Data.Aeson
-import Dodge.Data.Material
-import Geometry
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.Wall (
+    module Dodge.Data.Wall,
+    module Dodge.Data.Material,
+) where
+
 import Color
 import Control.Lens
-data Wall = Wall 
-    { _wlLine           :: (Point2,Point2) 
-    , _wlID             :: Int
-    , _wlColor          :: Color
-    , _wlSeen           :: Bool
-    , _wlOpacity        :: Opacity
-    , _wlPathable       :: Bool
-    , _wlPenetrable     :: Bool
-    , _wlBouncy         :: Bool
-    , _wlWalkable       :: Bool
-    , _wlTouchThrough   :: Bool
-    , _wlFireThrough    :: Bool
-    , _wlReflect        :: Bool
-    , _wlUnshadowed     :: Bool
-    , _wlRotateTo       :: Bool
-    , _wlStructure      :: WallStructure
-    , _wlHeight         :: Float
-    , _wlMaterial       :: Material
+import Data.Aeson
+import Data.Aeson.TH
+import Dodge.Data.Material
+import Geometry
+
+data Wall = Wall
+    { _wlLine :: (Point2, Point2)
+    , _wlID :: Int
+    , _wlColor :: Color
+    , _wlSeen :: Bool
+    , _wlOpacity :: Opacity
+    , _wlPathable :: Bool
+    , _wlPenetrable :: Bool
+    , _wlBouncy :: Bool
+    , _wlWalkable :: Bool
+    , _wlTouchThrough :: Bool
+    , _wlFireThrough :: Bool
+    , _wlReflect :: Bool
+    , _wlUnshadowed :: Bool
+    , _wlRotateTo :: Bool
+    , _wlStructure :: WallStructure
+    , _wlHeight :: Float
+    , _wlMaterial :: Material
     }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Wall  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Wall 
+    deriving (Eq, Ord, Show, Read)
+
 data Opacity
     = SeeThrough
     | SeeAbove
-    | DrawnWall {_opDraw :: WallDraw } -- Wall -> SPic
+    | DrawnWall {_opDraw :: WallDraw} -- Wall -> SPic
     | Opaque
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON Opacity where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON Opacity
+    deriving (Eq, Ord, Show, Read)
+
 data WallDraw = DrawForceField
-  deriving (Eq,Ord,Show,Read,Enum,Bounded,Generic)
-instance ToJSON WallDraw  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON WallDraw 
-data WallStructure 
+    deriving (Eq, Ord, Show, Read, Enum, Bounded)
+
+data WallStructure
     = StandaloneWall
-    | DoorPart    { _wsDoor    :: Int }
-    | MachinePart { _wsMachine :: Int }
-    | BlockPart   { _wsBlock   :: Int }
-    | CreaturePart 
-        { _wlStCreature :: Int 
---        , _wlStDamCreature :: Damage -> Wall -> Int -> World -> World
+    | DoorPart {_wsDoor :: Int}
+    | MachinePart {_wsMachine :: Int}
+    | BlockPart {_wsBlock :: Int}
+    | CreaturePart
+        { _wlStCreature :: Int
         }
-  deriving (Eq,Ord,Show,Read,Generic)
-instance ToJSON WallStructure  where
-    toEncoding = genericToEncoding defaultOptions
-instance FromJSON WallStructure 
+    deriving (Eq, Ord, Show, Read)
+
 makeLenses ''Wall
 makeLenses ''Opacity
 makeLenses ''WallStructure
+deriveJSON defaultOptions ''Wall
+deriveJSON defaultOptions ''Opacity
+deriveJSON defaultOptions ''WallDraw
+deriveJSON defaultOptions ''WallStructure

src/Dodge/Data/World.hs

@@ -0,0 +1,61 @@
+{-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Dodge.Data.World (
+    module Dodge.Data.World,
+    module Dodge.Data.CWorld,
+    module Dodge.Data.RightButtonOptions,
+    module Dodge.Data.SoundOrigin,
+    module Dodge.Data.Hammer,
+) where
+
+import Control.Lens
+import qualified Data.Map.Strict as M
+import qualified Data.Set as S
+import Dodge.Data.CWorld
+import Dodge.Data.Hammer
+import Dodge.Data.RightButtonOptions
+import Dodge.Data.SoundOrigin
+import Geometry.Data
+import SDL (MouseButton, Scancode)
+import Sound.Data
+import StreamingHelp
+import System.Random
+
+data World = World
+    { _cWorld :: CWorld
+    , _randGen :: StdGen
+    , _toPlaySounds :: M.Map SoundOrigin Sound
+    , _playingSounds :: M.Map SoundOrigin Sound
+    , _mousePos :: Point2
+    , _keys :: S.Set Scancode
+    , _mouseButtons :: M.Map MouseButton Bool
+    , _hammers :: M.Map WorldHammer HammerPosition
+    , _testFloat :: Float
+    , _lLine :: (Point2, Point2)
+    , _rLine :: (Point2, Point2)
+    , _lSelect :: Point2
+    , _rSelect :: Point2
+    , _backspaceTimer :: Int
+    , _timeFlow :: TimeFlowStatus
+    , _rbOptions :: RightButtonOptions
+    }
+
+data TimeFlowStatus
+    = RewindingNow
+    | RewindingLastFrame
+    | NormalTimeFlow
+    deriving (Eq, Ord, Show, Read)
+
+data WorldHammer
+    = SubInvHam
+    | DoubleMouseHam
+    deriving (Eq, Ord, Show, Read, Enum, Bounded)
+
+type HitEffect' =
+    Flame ->
+    StreamOf (Point2, Either Creature Wall) ->
+    World ->
+    (World, Maybe Flame)
+
+makeLenses ''World

src/Dodge/Data/WorldEffect.hs

@@ -1,27 +1,20 @@
-{-# LANGUAGE DeriveGeneric #-}
---{-# LANGUAGE DeriveGeneric #-}
---{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
 
 module Dodge.Data.WorldEffect where
 
 import Data.Aeson
+import Data.Aeson.TH
 import Dodge.Data.CreatureEffect
 import Dodge.Data.Item
 import Dodge.Data.SoundOrigin
-import GHC.Generics
 import Geometry.Data
 import Sound.Data
 
 data ItCrWdWd
     = ItCrWdId
     | ItCrWdItemEffect
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON ItCrWdWd where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON ItCrWdWd
+    deriving (Eq, Ord, Show, Read)
 
 data WdWd
     = NoWorldEffect
@@ -36,34 +29,19 @@ data WdWd
     | WdWdNegateTrig Int
     | WdWdFromItixCrixWdWd Int Int ItCrWdWd
     | WdWdFromItCrixWdWd Item Int ItCrWdWd
-    deriving (Eq, Show, Read, Generic)
-
-instance ToJSON WdWd where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON WdWd
+    deriving (Eq, Show, Read)
 
 data WdP2
     = WdP2Const Point2
     | WdYouPos
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON WdP2 where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON WdP2
+    deriving (Eq, Ord, Show, Read)
 
 data MdWdWd
     = MdWdId
     | MdTrigIf MdWdWd MdWdWd
     | MdSetLSCol Point3
     | MdFlickerUpdate
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON MdWdWd where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON MdWdWd
+    deriving (Eq, Ord, Show, Read)
 
 data WdBl
     = WdTrig Int
@@ -73,34 +51,19 @@ data WdBl
     | WdBlCrFilterNearPoint Float Point2 CrBl
     | WdBlBtOn Int
     | WdBlBtNotOff Int
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON WdBl where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON WdBl
+    deriving (Eq, Ord, Show, Read)
 
 data WdP2f
     = WdP2f0
     | WdP2fDoorPosition Int
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON WdP2f where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON WdP2f
+    deriving (Eq, Ord, Show, Read)
 
 data DrWdWd
     = DrWdId
     | DrWdMakeDoorDebris
     | DrWdMechanismStepwise Int [Int] [(Point2, Point2)]
     | DoorMechanism
-    deriving (Eq, Ord, Show, Read, Generic)
-
-instance ToJSON DrWdWd where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON DrWdWd
+    deriving (Eq, Ord, Show, Read)
 
 data TmWdWd
     = TmWdId
@@ -108,9 +71,13 @@ data TmWdWd
     | TmWdWdfromWdWd WdWd
     | TmWdWdTermSound SoundID
     | TmWdWdDoDeathTriggers
-    deriving (Eq, Show, Read, Generic)
+    deriving (Eq, Show, Read)
 
-instance ToJSON TmWdWd where
-    toEncoding = genericToEncoding defaultOptions
-
-instance FromJSON TmWdWd
+deriveJSON defaultOptions ''ItCrWdWd
+deriveJSON defaultOptions ''WdWd
+deriveJSON defaultOptions ''WdP2
+deriveJSON defaultOptions ''MdWdWd
+deriveJSON defaultOptions ''WdBl
+deriveJSON defaultOptions ''WdP2f
+deriveJSON defaultOptions ''DrWdWd
+deriveJSON defaultOptions ''TmWdWd

src/Dodge/Data/Zoning.hs

@@ -1,18 +1,21 @@
-{-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE TemplateHaskell #-}
+
 module Dodge.Data.Zoning where
-import Geometry.Data
+
 import Control.Lens
-import qualified IntMapHelp as IM
 import qualified Data.IntSet as IS
+import Geometry.Data
+import qualified IntMapHelp as IM
 import StreamingHelp
 
 data Zoning t a = Zoning
-    { _znObjects    :: IM.IntMap (IM.IntMap (t a))
-    , _znSize       :: Float
-    , _znFunc       :: Float -> a -> StreamOf Int2
---    , _znInsert     :: a -> t a -> t a
+    { _znObjects :: IM.IntMap (IM.IntMap (t a))
+    , _znSize :: Float
+    , _znFunc :: Float -> a -> StreamOf Int2
+    --    , _znInsert     :: a -> t a -> t a
     }
+
 newtype CrZoning = CrZoning {_getCrZoning :: IM.IntMap (IM.IntMap IS.IntSet)}
 
 makeLenses ''Zoning