2019-09-04 22:56:24 -04:00
|
|
|
{- |
|
|
|
|
|
|
|
|
mtlstats
|
|
|
|
Copyright (C) 2019 Rhéal Lamothe
|
|
|
|
<rheal.lamothe@gmail.com>
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or (at
|
|
|
|
your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
-}
|
|
|
|
|
|
|
|
module Mtlstats.Control (dispatch) where
|
|
|
|
|
2019-09-19 04:01:28 -04:00
|
|
|
import Control.Monad (join, when)
|
2019-10-19 00:41:56 -04:00
|
|
|
import Control.Monad.Extra (ifM)
|
2019-09-13 23:54:36 -04:00
|
|
|
import Control.Monad.Trans.State (gets, modify)
|
2019-09-04 22:56:24 -04:00
|
|
|
import Data.Char (toUpper)
|
2019-10-09 22:15:40 -04:00
|
|
|
import Data.Maybe (fromJust, fromMaybe, isJust)
|
2019-10-11 23:13:00 -04:00
|
|
|
import Lens.Micro ((^.), (.~), (%~))
|
2019-09-13 23:54:36 -04:00
|
|
|
import Lens.Micro.Extras (view)
|
2019-09-04 22:56:24 -04:00
|
|
|
import qualified UI.NCurses as C
|
|
|
|
|
|
|
|
import Mtlstats.Actions
|
2019-10-29 02:00:14 -04:00
|
|
|
import Mtlstats.Control.GoalieInput
|
2019-09-04 22:56:24 -04:00
|
|
|
import Mtlstats.Format
|
2019-09-07 00:27:18 -04:00
|
|
|
import Mtlstats.Handlers
|
2019-09-04 22:56:24 -04:00
|
|
|
import Mtlstats.Menu
|
|
|
|
import Mtlstats.Prompt
|
|
|
|
import Mtlstats.Report
|
|
|
|
import Mtlstats.Types
|
2019-10-01 00:58:15 -04:00
|
|
|
import Mtlstats.Util
|
2019-09-04 22:56:24 -04:00
|
|
|
|
|
|
|
-- | Reads the program state and returs the apropriate controller to
|
|
|
|
-- run
|
|
|
|
dispatch :: ProgState -> Controller
|
|
|
|
dispatch s = case s^.progMode of
|
2019-09-07 00:27:18 -04:00
|
|
|
MainMenu -> mainMenuC
|
|
|
|
NewSeason -> newSeasonC
|
2019-09-04 22:56:24 -04:00
|
|
|
NewGame gs
|
2019-09-19 06:12:02 -04:00
|
|
|
| null $ gs^.gameYear -> gameYearC
|
|
|
|
| null $ gs^.gameMonth -> gameMonthC
|
|
|
|
| null $ gs^.gameDay -> gameDayC
|
|
|
|
| null $ gs^.gameType -> gameTypeC
|
|
|
|
| null $ gs^.otherTeam -> otherTeamC
|
|
|
|
| null $ gs^.homeScore -> homeScoreC
|
|
|
|
| null $ gs^.awayScore -> awayScoreC
|
|
|
|
| null $ gs^.overtimeFlag -> overtimeFlagC
|
|
|
|
| not $ gs^.dataVerified -> verifyDataC
|
2019-09-25 02:44:42 -04:00
|
|
|
| fromJust (unaccountedPoints gs) -> goalInput gs
|
2019-10-09 00:58:49 -04:00
|
|
|
| isJust $ gs^.selectedPlayer -> getPMinsC
|
|
|
|
| not $ gs^.pMinsRecorded -> pMinPlayerC
|
2019-10-29 02:00:14 -04:00
|
|
|
| not $ gs^.goaliesRecorded -> goalieInput gs
|
2019-09-19 06:12:02 -04:00
|
|
|
| otherwise -> reportC
|
2019-09-09 13:04:39 -04:00
|
|
|
CreatePlayer cps
|
2019-09-09 22:57:36 -04:00
|
|
|
| null $ cps^.cpsNumber -> getPlayerNumC
|
|
|
|
| null $ cps^.cpsName -> getPlayerNameC
|
|
|
|
| null $ cps^.cpsPosition -> getPlayerPosC
|
2019-09-10 16:07:46 -04:00
|
|
|
| otherwise -> confirmCreatePlayerC
|
2019-10-22 00:21:51 -04:00
|
|
|
CreateGoalie cgs
|
|
|
|
| null $ cgs^.cgsNumber -> getGoalieNumC
|
|
|
|
| null $ cgs^.cgsName -> getGoalieNameC
|
|
|
|
| otherwise -> confirmCreateGoalieC
|
2019-09-07 00:27:18 -04:00
|
|
|
|
|
|
|
mainMenuC :: Controller
|
|
|
|
mainMenuC = Controller
|
|
|
|
{ drawController = const $ drawMenu mainMenu
|
|
|
|
, handleController = menuHandler mainMenu
|
|
|
|
}
|
|
|
|
|
|
|
|
newSeasonC :: Controller
|
|
|
|
newSeasonC = Controller
|
|
|
|
{ drawController = const $ drawMenu newSeasonMenu
|
|
|
|
, handleController = \e -> do
|
|
|
|
menuHandler newSeasonMenu e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
gameYearC :: Controller
|
|
|
|
gameYearC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt gameYearPrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler gameYearPrompt e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
gameMonthC :: Controller
|
|
|
|
gameMonthC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawMenu gameMonthMenu
|
|
|
|
, handleController = \e -> do
|
|
|
|
menuHandler gameMonthMenu e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
gameDayC :: Controller
|
|
|
|
gameDayC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt gameDayPrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler gameDayPrompt e
|
|
|
|
modify validateGameDate
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
gameTypeC :: Controller
|
|
|
|
gameTypeC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawMenu gameTypeMenu
|
|
|
|
, handleController = \e -> do
|
|
|
|
menuHandler gameTypeMenu e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
otherTeamC :: Controller
|
|
|
|
otherTeamC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt otherTeamPrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler otherTeamPrompt e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
homeScoreC :: Controller
|
|
|
|
homeScoreC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt homeScorePrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler homeScorePrompt e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
awayScoreC :: Controller
|
|
|
|
awayScoreC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt awayScorePrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler awayScorePrompt e
|
|
|
|
modify overtimeCheck
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
overtimeFlagC :: Controller
|
|
|
|
overtimeFlagC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
C.drawString "Did the game go into overtime? (Y/N)"
|
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
|
|
|
modify $ progMode.gameStateL.overtimeFlag .~ ynHandler e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
|
|
|
verifyDataC :: Controller
|
|
|
|
verifyDataC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
let gs = s^.progMode.gameStateL
|
|
|
|
header s
|
|
|
|
C.drawString "\n"
|
2019-09-07 09:06:16 -04:00
|
|
|
C.drawString $ " Date: " ++ gameDate gs ++ "\n"
|
2019-09-07 00:27:18 -04:00
|
|
|
C.drawString $ " Game type: " ++ show (fromJust $ gs^.gameType) ++ "\n"
|
|
|
|
C.drawString $ "Other team: " ++ gs^.otherTeam ++ "\n"
|
|
|
|
C.drawString $ "Home score: " ++ show (fromJust $ gs^.homeScore) ++ "\n"
|
|
|
|
C.drawString $ "Away score: " ++ show (fromJust $ gs^.awayScore) ++ "\n"
|
|
|
|
C.drawString $ " Overtime: " ++ show (fromJust $ gs^.overtimeFlag) ++ "\n\n"
|
|
|
|
C.drawString "Is the above information correct? (Y/N)"
|
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
|
|
|
case ynHandler e of
|
|
|
|
Just True -> do
|
|
|
|
modify $ progMode.gameStateL.dataVerified .~ True
|
2019-09-04 22:56:24 -04:00
|
|
|
modify updateGameStats
|
2019-09-07 00:27:18 -04:00
|
|
|
Just False -> modify $ progMode.gameStateL .~ newGameState
|
|
|
|
Nothing -> return ()
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
2019-09-25 02:44:42 -04:00
|
|
|
goalInput :: GameState -> Controller
|
|
|
|
goalInput gs
|
2019-10-01 00:58:15 -04:00
|
|
|
| null (gs^.goalBy ) = recordGoalC
|
|
|
|
| not (gs^.confirmGoalDataFlag) = recordAssistC
|
|
|
|
| otherwise = confirmGoalDataC
|
2019-09-25 02:44:42 -04:00
|
|
|
|
2019-09-19 06:12:02 -04:00
|
|
|
recordGoalC :: Controller
|
|
|
|
recordGoalC = Controller
|
|
|
|
{ drawController = \s -> let
|
2019-09-26 01:23:34 -04:00
|
|
|
(game, goal) = gameGoal s
|
2019-09-19 06:12:02 -04:00
|
|
|
in drawPrompt (recordGoalPrompt game goal) s
|
|
|
|
, handleController = \e -> do
|
2019-09-26 01:23:34 -04:00
|
|
|
(game, goal) <- gets gameGoal
|
2019-09-19 06:12:02 -04:00
|
|
|
promptHandler (recordGoalPrompt game goal) e
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
2019-09-25 02:44:42 -04:00
|
|
|
recordAssistC :: Controller
|
2019-09-26 01:23:34 -04:00
|
|
|
recordAssistC = Controller
|
|
|
|
{ drawController = \s -> let
|
|
|
|
(game, goal, assist) = gameGoalAssist s
|
|
|
|
in drawPrompt (recordAssistPrompt game goal assist) s
|
|
|
|
, handleController = \e -> do
|
|
|
|
(game, goal, assist) <- gets gameGoalAssist
|
|
|
|
promptHandler (recordAssistPrompt game goal assist) e
|
|
|
|
return True
|
|
|
|
}
|
2019-09-25 02:44:42 -04:00
|
|
|
|
2019-10-01 00:58:15 -04:00
|
|
|
confirmGoalDataC :: Controller
|
|
|
|
confirmGoalDataC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
let
|
|
|
|
(game, goal) = gameGoal s
|
|
|
|
gs = s^.progMode.gameStateL
|
|
|
|
players = s^.database.dbPlayers
|
|
|
|
msg = unlines $
|
|
|
|
[ " Game: " ++ padNum 2 game
|
|
|
|
, " Goal: " ++ show goal
|
|
|
|
, "Goal scored by: " ++
|
|
|
|
playerSummary (fromJust $ gs^.goalBy >>= flip nth players)
|
|
|
|
] ++
|
|
|
|
map
|
|
|
|
(\pid -> " Assisted by: " ++
|
|
|
|
playerSummary (fromJust $ nth pid players))
|
|
|
|
(gs^.assistsBy) ++
|
2019-10-02 01:57:58 -04:00
|
|
|
[ ""
|
|
|
|
, "Is the above information correct? (Y/N)"
|
|
|
|
]
|
2019-10-01 00:58:15 -04:00
|
|
|
C.drawString msg
|
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
|
|
|
case ynHandler e of
|
|
|
|
Just True -> modify recordGoalAssists
|
|
|
|
Just False -> modify resetGoalData
|
|
|
|
Nothing -> return ()
|
|
|
|
return True
|
|
|
|
}
|
|
|
|
|
2019-10-09 00:58:49 -04:00
|
|
|
pMinPlayerC :: Controller
|
2019-10-09 01:24:55 -04:00
|
|
|
pMinPlayerC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
drawPrompt pMinPlayerPrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler pMinPlayerPrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-10-09 00:58:49 -04:00
|
|
|
|
|
|
|
getPMinsC :: Controller
|
2019-10-09 22:15:40 -04:00
|
|
|
getPMinsC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
header s
|
|
|
|
C.drawString $ fromMaybe "" $ do
|
|
|
|
pid <- s^.progMode.gameStateL.selectedPlayer
|
|
|
|
player <- nth pid $ s^.database.dbPlayers
|
|
|
|
Just $ playerSummary player ++ "\n"
|
|
|
|
drawPrompt assignPMinsPrompt s
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler assignPMinsPrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-10-09 00:58:49 -04:00
|
|
|
|
2019-09-07 00:27:18 -04:00
|
|
|
reportC :: Controller
|
|
|
|
reportC = Controller
|
|
|
|
{ drawController = \s -> do
|
2019-10-11 23:13:00 -04:00
|
|
|
(rows, cols) <- C.windowSize
|
|
|
|
C.drawString $ unlines $ slice
|
|
|
|
(s^.scrollOffset)
|
|
|
|
(fromInteger $ pred rows)
|
|
|
|
(report (fromInteger $ pred cols) s)
|
2019-09-07 00:27:18 -04:00
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
2019-10-11 23:13:00 -04:00
|
|
|
case e of
|
2019-10-15 00:16:44 -04:00
|
|
|
C.EventSpecialKey C.KeyUpArrow -> modify scrollUp
|
|
|
|
C.EventSpecialKey C.KeyDownArrow -> modify scrollDown
|
2019-10-11 23:13:00 -04:00
|
|
|
C.EventSpecialKey C.KeyHome -> modify $ scrollOffset .~ 0
|
|
|
|
C.EventSpecialKey _ -> modify backHome
|
|
|
|
C.EventCharacter _ -> modify backHome
|
|
|
|
_ -> return ()
|
2019-09-07 00:27:18 -04:00
|
|
|
return True
|
|
|
|
}
|
2019-09-04 22:56:24 -04:00
|
|
|
|
|
|
|
header :: ProgState -> C.Update ()
|
|
|
|
header s = C.drawString $
|
|
|
|
"*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***\n"
|
2019-09-09 13:04:39 -04:00
|
|
|
|
|
|
|
getPlayerNumC :: Controller
|
|
|
|
getPlayerNumC = Controller
|
|
|
|
{ drawController = drawPrompt playerNumPrompt
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler playerNumPrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-09-09 22:50:44 -04:00
|
|
|
|
|
|
|
getPlayerNameC :: Controller
|
|
|
|
getPlayerNameC = Controller
|
|
|
|
{ drawController = drawPrompt playerNamePrompt
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler playerNamePrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-09-09 22:57:36 -04:00
|
|
|
|
|
|
|
getPlayerPosC :: Controller
|
|
|
|
getPlayerPosC = Controller
|
|
|
|
{ drawController = drawPrompt playerPosPrompt
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler playerPosPrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-09-09 23:35:28 -04:00
|
|
|
|
|
|
|
confirmCreatePlayerC :: Controller
|
|
|
|
confirmCreatePlayerC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
let cps = s^.progMode.createPlayerStateL
|
|
|
|
C.drawString $ " Player number: " ++ show (fromJust $ cps^.cpsNumber) ++ "\n"
|
|
|
|
C.drawString $ " Player name: " ++ cps^.cpsName ++ "\n"
|
|
|
|
C.drawString $ "Player position: " ++ cps^.cpsPosition ++ "\n\n"
|
|
|
|
C.drawString "Create player: are you sure? (Y/N)"
|
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
|
|
|
case ynHandler e of
|
2019-09-19 04:01:28 -04:00
|
|
|
Just True -> do
|
2019-09-09 23:35:28 -04:00
|
|
|
modify addPlayer
|
2019-09-19 04:01:28 -04:00
|
|
|
join $ gets $ view $ progMode.createPlayerStateL.cpsSuccessCallback
|
|
|
|
Just False ->
|
2019-10-30 00:45:16 -04:00
|
|
|
join $ gets $ view $ progMode.createPlayerStateL.cpsFailureCallback
|
2019-09-19 04:01:28 -04:00
|
|
|
Nothing -> return ()
|
2019-09-09 23:35:28 -04:00
|
|
|
return True
|
|
|
|
}
|
2019-09-26 01:23:34 -04:00
|
|
|
|
2019-10-22 00:21:51 -04:00
|
|
|
getGoalieNumC :: Controller
|
2019-10-24 15:53:24 -04:00
|
|
|
getGoalieNumC = Controller
|
|
|
|
{ drawController = drawPrompt goalieNumPrompt
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler goalieNumPrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-10-22 00:21:51 -04:00
|
|
|
|
|
|
|
getGoalieNameC :: Controller
|
2019-10-25 00:45:39 -04:00
|
|
|
getGoalieNameC = Controller
|
|
|
|
{ drawController = drawPrompt goalieNamePrompt
|
|
|
|
, handleController = \e -> do
|
|
|
|
promptHandler goalieNamePrompt e
|
|
|
|
return True
|
|
|
|
}
|
2019-10-22 00:21:51 -04:00
|
|
|
|
|
|
|
confirmCreateGoalieC :: Controller
|
2019-10-25 01:07:04 -04:00
|
|
|
confirmCreateGoalieC = Controller
|
|
|
|
{ drawController = \s -> do
|
|
|
|
let cgs = s^.progMode.createGoalieStateL
|
|
|
|
C.drawString $ unlines
|
|
|
|
[ "Goalie number: " ++ show (fromJust $ cgs^.cgsNumber)
|
|
|
|
, " Goalie name: " ++ cgs^.cgsName
|
|
|
|
, ""
|
|
|
|
, "Create goalie: are you sure? (Y/N)"
|
|
|
|
]
|
|
|
|
return C.CursorInvisible
|
|
|
|
, handleController = \e -> do
|
|
|
|
case ynHandler e of
|
|
|
|
Just True -> do
|
|
|
|
modify addGoalie
|
|
|
|
join $ gets (^.progMode.createGoalieStateL.cgsSuccessCallback)
|
|
|
|
Just False ->
|
|
|
|
join $ gets (^.progMode.createGoalieStateL.cgsFailureCallback)
|
|
|
|
Nothing -> return ()
|
|
|
|
return True
|
|
|
|
}
|
2019-10-22 00:21:51 -04:00
|
|
|
|
2019-09-26 01:23:34 -04:00
|
|
|
gameGoal :: ProgState -> (Int, Int)
|
|
|
|
gameGoal s =
|
|
|
|
( s^.database.dbGames
|
|
|
|
, succ $ s^.progMode.gameStateL.pointsAccounted
|
|
|
|
)
|
|
|
|
|
|
|
|
gameGoalAssist :: ProgState -> (Int, Int, Int)
|
|
|
|
gameGoalAssist s = let
|
|
|
|
(game, goal) = gameGoal s
|
|
|
|
assist = succ $ length $ s^.progMode.gameStateL.assistsBy
|
|
|
|
in (game, goal, assist)
|