move pickDecks into separate module.

Tested-on: collins x86_64 GNU/Linux

Dominion.hs

@@ -1,8 +1,10 @@
 module Dominion ( module Dominion.Game, module Dominion.Cards,
-                  module Dominion.Types, shuffleIO, Pretty(pretty) ) where
+                  module Dominion.Types, shuffleIO, Pretty(pretty),
+                  pickDecks ) where
 
 import Dominion.Game
 import Dominion.Cards
 import Dominion.Types
 import Dominion.Stack ( shuffleIO )
 import Dominion.Pretty ( Pretty(pretty) )
+import Dominion.Bots ( pickDecks )

Dominion/Bots.hs

@@ -0,0 +1,19 @@
+module Dominion.Bots ( pickDecks ) where
+
+import Dominion.Types ( Card, cardPrice )
+import Dominion.Cards ( allRecommended, allDecks )
+import Dominion.Stack ( shuffleIO )
+
+import System.Random ( randomRIO )
+import Data.List ( sortBy )
+import Data.Ord ( comparing )
+
+pickDecks :: [Card] -> IO [Card]
+pickDecks cs = do let sets = filter ((==10).length.snd) allRecommended
+                  r <- randomRIO (1,100)
+                  decks <- if r > (10 :: Int) || not (null cs)
+                           then (take 10 . (cs++)) `fmap` shuffleIO allDecks
+                           else do (sn,d) <- head `fmap` shuffleIO sets
+                                   putStrLn ("Using set "++sn)
+                                   return d
+                  return $ sortBy (comparing cardPrice) decks

HTTP/Dominion.hs

@@ -2,18 +2,16 @@
 
 module HTTP.Dominion ( dominionHandler, MessageToGame(..) ) where
 
-import Dominion ( Card, MessageToClient(Question, Info), QId, Answer,
+import Dominion ( MessageToClient(Question, Info), QId, Answer,
                   ResponseFromClient(ResponseFromClient),
-                  play, evalGame, pretty,
-                  shuffleIO, allRecommended, allDecks )
+                  play, evalGame, pretty, pickDecks )
 import qualified Dominion ( start )
 import TCP.Chan ( Output, pipe, readInput, writeOutput )
 
 import HTTP.Response ( Response, jsPrintf, blank200, error404 )
 import HTTP.LoginServer ( Agent )
 import HTTP.Handlers ( Handler(..), Message(..) )
 
-import System.Random ( randomRIO )
 import Data.Maybe ( fromMaybe )
 import Control.Monad ( forM_, forever )
 import Control.Concurrent ( forkIO )
@@ -122,13 +120,3 @@ sayto sendmess ags a s =
 say :: (Agent -> String -> IO ()) -> DomState -> String -> IO ()
 say sendmess ags s =
     forM_ (clients ags) $ \(a,f) -> sendmess a (f s)
-
-pickDecks :: [Card] -> IO [Card]
-pickDecks cs = do let sets = filter ((==10).length.snd) allRecommended
-                  r <- randomRIO (1,100)
-                  decks <- if r > (10 :: Int) || not (null cs)
-                           then (take 10 . (cs++)) `fmap` shuffleIO allDecks
-                           else do (sn,d) <- head `fmap` shuffleIO sets
-                                   putStrLn ("Using set "++sn)
-                                   return d
-                  return decks

testdom.hs

@@ -14,8 +14,6 @@ import Control.Monad ( forever, replicateM )
 import Control.Monad.State ( execStateT,
                              StateT, runStateT, put, get, modify, liftIO )
 import Data.Char ( toLower, isSpace )
-import Data.List ( sortBy )
-import Data.Ord ( comparing )
 import System.IO ( hFlush, stdout )
 import System.Environment ( getArgs )
 import System.Random ( randomRIO )
@@ -272,16 +270,6 @@ mainArgs cs as
           lookupBy f s (x:xs) | lc (f x) == lc s = Just x
                               | otherwise        = lookupBy f s xs
 
-pickDecks :: [Card] -> IO [Card]
-pickDecks cs = do let sets = filter ((==10).length.snd) allRecommended
-                  r <- randomRIO (1,100)
-                  decks <- if r > (10 :: Int) || not (null cs)
-                           then (take 10 . (cs++)) `fmap` shuffleIO allDecks
-                           else do (sn,d) <- head `fmap` shuffleIO sets
-                                   putStrLn ("Using set "++sn)
-                                   return d
-                  return $ sortBy (comparing cardPrice) decks
-
 twoPlayer :: [Card] -> IO ()
 twoPlayer cs = do
           (c1i, c1o) <- pipe