# Difference between revisions of "Haskell Quiz/Yahtzee/Solution Bobstopper"

From HaskellWiki

< Haskell Quiz | Yahtzee

m |
m |
||

Line 293: | Line 293: | ||

-- Attempts to read a string. Returns Nothing if it fails |
-- Attempts to read a string. Returns Nothing if it fails |
||

maybeRead :: Read a => String -> Maybe a |
maybeRead :: Read a => String -> Maybe a |
||

− | maybeRead s = |
+ | maybeRead s = listToMaybe r >>= fst |

− | [] -> Nothing |
||

− | ((x,_):_) -> Just x |
||

where r = reads s |
where r = reads s |
||

## Latest revision as of 00:28, 22 February 2010

This is a bit longer than the ruby solution but is a bit more featureful.

```
import Control.Arrow (first, second, (&&&))
import Control.Monad
import Control.Monad.State
import Data.List
import Data.Maybe
import qualified Data.Map as Map
import System.Exit
import System.Random
-- Possible values of a 6 sided dice roll
data DiceRoll = One | Two | Three | Four | Five | Six
deriving (Eq, Ord, Enum, Bounded, Show)
value = (1+) . fromEnum
-- Some Random Utilities
instance Random DiceRoll where
randomR (min,max) g = first toEnum $ randomR (fromEnum min,fromEnum max) g
random = randomR (minBound,maxBound)
randomIOs :: Random a => IO [a]
randomIOs = fmap randoms newStdGen
rollDice = randomIO :: IO DiceRoll
-- Generates n random dice
rollNDice :: Int -> IO [DiceRoll]
rollNDice n = (take n) `fmap` randomIOs
-- reRollDice ns dice returns a new set of dice with dices at positions
-- given by ns replaced with newly generated dice
reRollDice :: [Int] -> [DiceRoll] -> IO [DiceRoll]
reRollDice [] dice = return dice
reRollDice (n:ns) dice = do
next <- fmap (replace dice n) $ rollDice
reRollDice ns next
replace :: [a] -> Int -> a -> [a]
replace xs i x = (take i xs) ++ [x] ++ (drop (i+1) xs)
-- Scoring logic
-- Yahtzee categories which can be scored against
data Category = Ones | Twos | Threes | Fours | Fives | Sixes
| ThreeOfAKind | FourOfAKind | FullHouse
| SmallStraight | LargeStraight | Chance | Yahtzee
deriving (Show, Read, Ord, Eq)
-- Small Mapping just for counting
type Count = Map.Map DiceRoll Int
initCount = Map.fromAscList [ (One, 0), (Two, 0), (Three, 0)
, (Four, 0), (Five, 0), (Six, 0)]
-- Count how many of each DiceRoll there is in a hand
countDice :: [DiceRoll] -> Count
countDice = foldr (Map.adjust (+1)) initCount
-- Count how many of a specific DiceRoll there is in a hand
numberMatching :: DiceRoll -> [DiceRoll] -> Int
numberMatching = (length .) . filter . (==)
-- Test if a list is ascending incrementally
isStraight :: (Bounded a, Enum a, Eq a) => [a] -> Bool
isStraight [] = True
isStraight xs = and $ zipWith isSucc xs (tail xs)
where isSucc x y | x == maxBound = False
| otherwise = y == succ x
-- Determine a hand's score against a specific category
score :: [DiceRoll] -> Category -> Int
score dice Ones = numberMatching One dice
score dice Twos = (numberMatching Two dice) * 2
score dice Threes = (numberMatching Three dice) * 3
score dice Fours = (numberMatching Four dice) * 4
score dice Fives = (numberMatching Five dice) * 5
score dice Sixes = (numberMatching Six dice) * 6
score dice ThreeOfAKind | Map.null $ Map.filter (>=3) $ countDice dice = 0
| otherwise = sum (map value dice)
score dice FourOfAKind | Map.null $ Map.filter (>=4) $ countDice dice = 0
| otherwise = sum (map value dice)
score dice Yahtzee | Map.null $ Map.filter (==5) $ countDice dice = 0
| otherwise = 50
score dice FullHouse | Map.size gt2 == 1 && head (Map.elems gt2) == 5 = 25
| Map.size gt2 == 2
&& (not $ Map.null $ Map.filter (==3) gt2)
= 25
| otherwise = 0
where gt2 = Map.filter (>=2) $ countDice dice
score dice SmallStraight | (isStraight $ tail $ sort dice)
|| (isStraight $ take 4 $ sort dice) = 30
| otherwise = 0
score dice LargeStraight | isStraight $ sort dice = 40
| otherwise = 0
score dice Chance = sum $ map value dice
-- The Game Logic
type PlayerName = String
type PlayerTotal = (PlayerName, Int)
type ScoreCard = Map.Map Category (Maybe Int)
maxReRolls = 2
-- An initial score with all categories unscored
clearScore = Map.fromAscList [ (Ones, Nothing), (Twos, Nothing)
, (Threes, Nothing), (Fours, Nothing)
, (Fives, Nothing), (Sixes, Nothing)
, (ThreeOfAKind, Nothing), (FourOfAKind, Nothing)
, (FullHouse, Nothing), (SmallStraight, Nothing)
, (LargeStraight, Nothing), (Chance, Nothing)
, (Yahtzee, Nothing) ]
data GameState = GameState { playerQueue :: [ PlayerName ]
, players :: Map.Map PlayerName ScoreCard
, reRolls :: Int }
-- Generate a new game using the player names given
newGame :: [PlayerName] -> GameState
newGame [] = error "Need to define at least one player"
newGame ps = GameState { playerQueue = cycle ps
, players = Map.fromList $ zip ps (repeat clearScore)
, reRolls = maxReRolls }
-- Change a specific player's score by scoring the given hand against
-- the given category
adjustScore :: PlayerName -> Category -> [DiceRoll] -> GameState -> GameState
adjustScore n c ds g = g { players =
Map.adjust (adjustCategory c (score ds c))
n (players g) }
-- Adjust the score for a specific category in a scorecard
adjustCategory :: Category -> Int -> ScoreCard -> ScoreCard
adjustCategory Yahtzee x s = Map.adjust (maybe (Just 50) (Just . (+x)))
Yahtzee s
adjustCategory c x s = Map.adjust (maybe (Just x)
(error "Category already used"))
c s
currentPlayer :: GameState -> PlayerName
currentPlayer = head . playerQueue
-- Get the current scorecard of the given player
playerScore :: PlayerName -> GameState -> ScoreCard
playerScore n g = Map.findWithDefault err n (players g)
where err = error $ "Couldn't find Player " ++ n ++ " in game!"
-- Get the current scorecard for the current player
currentPlayerScore :: GameState -> ScoreCard
currentPlayerScore g = playerScore (currentPlayer g) g
-- Uses up one of the available rerolls
useReRoll :: GameState -> GameState
useReRoll g = g { reRolls = (reRolls g)-1 }
-- Reset the game for the next player
newRound :: GameState -> GameState
newRound g = g { reRolls = maxReRolls
, playerQueue = tail $ playerQueue g }
-- Returns the number of rounds in a game
gameLength :: GameState -> Int
gameLength = (13*) . Map.size . players
-- Look up the score of the given category from a scorecard
category :: Category -> ScoreCard -> Maybe Int
category c s = Map.findWithDefault err c s
where err = error $ "Couldn't find Category " ++ (show c) ++
" in player's score!"
-- Determines whether it is ok to place a score against the category
-- This function should always be used prior to scoring a category
categoryOK :: Category -> ScoreCard -> Bool
categoryOK Yahtzee _ = True
categoryOK c s = isNothing $ category c s
-- Calculates the "upper" total of the scorecard
scoreUpper :: ScoreCard -> Int
scoreUpper s = sum $ mapMaybe ((flip category) s)
[Ones,Twos,Threes,Fours,Fives,Sixes]
-- Calculates the "lower" total of the scorecard
scoreLower :: ScoreCard -> Int
scoreLower s = sum $ mapMaybe ((flip category) s)
[ ThreeOfAKind, FourOfAKind, FullHouse
, SmallStraight, LargeStraight, Yahtzee, Chance ]
-- Calculates the grand total of the scorecard
scoreTotal :: ScoreCard -> Int
scoreTotal = (uncurry (+)) . (scoreUpper &&& scoreLower)
-- Data structure to account for draws as well as outright winners
data GameOutcome = Winner PlayerTotal | Draw [PlayerTotal]
-- Determines the winner between two players
winner :: PlayerTotal -> GameOutcome -> GameOutcome
winner y (Winner x) | (snd x) > (snd y) = Winner x
| (snd x) < (snd y) = Winner y
| otherwise = Draw [x,y]
winner y (Draw xs@(x:_)) | (snd x) > (snd y) = Draw xs
| (snd x) < (snd y) = Winner y
| otherwise = Draw $ y:xs
-- Score printing utilities
-- Prints the player's score
printScore :: PlayerName -> Yahtzee ()
printScore p = do
score <- gets (playerScore p)
liftIO $ print score
-- Prints the player's final score totals
printFinalScore :: PlayerName -> ScoreCard -> IO ()
printFinalScore n s = do
putStrLn $ "*** Final Score for " ++ n ++ " ***"
putStrLn $ "Lower Score: " ++ (show $ scoreLower s)
putStrLn $ "Upper Score: " ++ (show $ scoreUpper s)
newline
putStrLn $ "TOTAL Score: " ++ (show $ scoreTotal s)
-- Print the overall winner(s) and their score(s)
printWinner :: GameOutcome -> IO ()
printWinner (Winner (n,s)) =
putStrLn $ n++ " is the winner with " ++ (show s) ++ "!"
printWinner (Draw ws) = do
putStrLn "The game is a Draw!"
mapM_ (\(n,s) -> putStrLn $ n++ "with " ++ (show s)) ws
-- The Interface
-- Valid user input types
data Input = Accept Category | ShowScore | ReRoll [Int] | ReRollAll
| Quit | Help | CategoryHelp
deriving Read
-- The game monad
type Yahtzee a = StateT GameState IO a
newline = putStrLn ""
-- Persists in asking the given question until a valid answer is given.
-- Valid answers are determined and returned by the given function
ask :: String -> (String -> Maybe a) -> IO a
ask question f = do
putStr (question ++ "> ")
x <- fmap f getLine
case x of
(Just answer) -> return answer
Nothing -> putStrLn "Invalid input. Try again" >> ask question f
-- Attempts to read a string. Returns Nothing if it fails
maybeRead :: Read a => String -> Maybe a
maybeRead s = listToMaybe r >>= fst
where r = reads s
-- The Game start and completion
main :: IO ()
main = do
playerNames <- getPlayerNames
let game = newGame playerNames
gameOver <- execStateT (replicateM_ (gameLength game) playerUp) game
let scores = Map.toList $ players gameOver
mapM_ (uncurry printFinalScore) scores
let topScore = foldr winner (Winner ("Nobody",0))
(map (second scoreTotal) scores)
printWinner topScore
-- Ask for each player names until a blank line is reached
getPlayerNames :: IO [PlayerName]
getPlayerNames = do
name <- ask "Enter player name (blank line to finish)" Just
if null name
then return []
else fmap (name:) getPlayerNames
-- Start a round for the next player
playerUp :: Yahtzee ()
playerUp = do
player <- gets currentPlayer
liftIO $ newline
liftIO $ putStrLn "Next Round"
liftIO $ newline
printScore player
liftIO $ newline
liftIO $ putStrLn $ player ++ ", you're up!"
(liftIO $ rollNDice 5) >>= userAction
modify newRound
-- Interact with the user during the round
userAction :: [DiceRoll] -> Yahtzee ()
userAction dice = do
liftIO $ putStrLn $ "Your roll is " ++ (show dice)
input <- liftIO $ ask "Input Action (type Help for help)" maybeRead
processInput input dice
-- Process a user's input
processInput :: Input -> [DiceRoll] -> Yahtzee ()
processInput (Accept c) ds = do
player <- gets currentPlayer
playerScore <- gets $ playerScore player
if categoryOK c playerScore
then do modify $ adjustScore player c ds
printScore player
else do (liftIO $ putStrLn ("Category " ++ (show c) ++ " already used"))
userAction ds
processInput ShowScore ds = gets currentPlayer >>= printScore >> userAction ds
processInput (ReRoll is) ds = maybeReRoll ds $
modify useReRoll >> (liftIO $ reRollDice is ds)
processInput ReRollAll ds = maybeReRoll ds $
modify useReRoll >> (liftIO $ rollNDice 5)
processInput Quit _ = liftIO $ exitWith ExitSuccess
processInput Help ds = do
liftIO $ putStrLn "* Command List *"
liftIO $ putStrLn "Accept category: Accept this roll and score against category"
liftIO $ putStrLn "Score: Print your current score"
liftIO $ putStrLn "ReRoll indexes: reroll the dice specified by the Haskell list of Ints in indexes"
liftIO $ putStrLn "ReRollAll: discard all dice and roll a fresh set"
liftIO $ putStrLn "Quit: Exit the game"
liftIO $ putStrLn "Help: Display this help"
liftIO $ putStrLn "CategoryHelp: Display available categories"
liftIO $ newline
userAction ds
processInput CategoryHelp ds = do
liftIO $ putStrLn "* Category List *"
liftIO $ putStrLn "Ones | Twos | Threes | Fours | Fives | Sixes"
liftIO $ putStrLn "| ThreeOfAKind | FourOfAKind | FullHouse"
liftIO $ putStrLn "| SmallStraight | LargeStraight | Yahtzee | Chance"
userAction ds
-- takes a current diceroll and a command to reroll.
-- Performs the reroll action only if the player has rerolls left.
-- Otherwise tells the player no rerolls are left
maybeReRoll :: [DiceRoll] -> Yahtzee [DiceRoll] -> Yahtzee ()
maybeReRoll dice cmd = do
nextRound <- gets ((<=0) . reRolls)
if nextRound
then (liftIO $ putStrLn "No rolls left. Accept a category") >>
userAction dice
else cmd >>= userAction
```