1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
{-# LANGUAGE ViewPatterns, FlexibleContexts, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances, OverloadedStrings, RankNTypes #-}
module Sequence.Utils
( withArg, withFocus, withFocus'
, focusState
, toName, toDesc
, Argument(..)
, Completion(..)
, module Sequence.Utils.Ask
) where
import Sequence.Types
import Control.Monad.State.Strict
import Control.Monad.Trans.Maybe
import Control.Applicative
import Control.Monad
import Control.Lens
import Data.Bimap (Bimap)
import qualified Data.Bimap as Bimap
import Data.CaseInsensitive (CI)
import qualified Data.CaseInsensitive as CI
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Function
import Data.Default
import Data.Maybe
import Text.Read (readMaybe)
import Data.List
import Data.Bool
import Data.Char
import System.Console.Shell
import System.Console.Shell.ShellMonad
import System.Console.Shell.Backend.Haskeline
import Sequence.Utils.Ask
import Sequence.Contact.Types
import Sequence.Formula
class Argument a st | a -> st where
arg :: String -> Sh st (Maybe a)
withArg :: Argument a st => (a -> Sh st ()) -> (Completable a -> Sh st ())
withArg f (Completable str) = arg str >>= \a -> case a of
Nothing -> shellPutErrLn $ "Could not parse ‘" ++ str ++ "’"
Just a -> f a
withFocus :: (EntityIdentifier -> Sh GameState ()) -> Sh GameState ()
withFocus f = use gFocus >>= maybe (shellPutErrLn $ "Currently not focusing any entity") f
withFocus' :: (Entity -> Sh GameState a) -> Sh GameState (Maybe a)
withFocus' f = preuse gFocus' >>= maybe (Nothing <$ shellPutErrLn "Currently not focusing any entity") (fmap Just . f)
focusState :: MonadState s m => Traversal' s a -> StateT a (MaybeT m) b -> m (Maybe b)
focusState lens action = runMaybeT $ uncurry (<$) . over _2 (lens .=) =<< runStateT action =<< MaybeT (preuse lens)
unaligned = view faction' def
toName :: MonadState GameState m => EntityIdentifier -> m String
toName ident = do
let number = review entityId' ident
isShadowed <- uses gEntityNames . Bimap.memberR $ view entityName number
let number' = bool id ('#':) isShadowed $ number
fromMaybe number' . fmap (review entityName) . Bimap.lookup ident <$> use gEntityNames
toDesc :: (MonadState GameState m, MonadIO m) => EntityIdentifier -> m String
toDesc ident = do
name <- toName ident
health <- runMaybeT $ do
maxVit <- MaybeT . focusState (gEntities . ix ident) . evalFormula' name =<< (MaybeT . preuse $ gEntities . ix ident . eStats . sMaxVitality)
hDamage <- MaybeT . preuse $ gEntities . ix ident . eStats . sTotalDamage
fDamage <- MaybeT . preuse $ gEntities . ix ident . eStats . sFatigue
return $ (maxVit - hDamage, maxVit - fDamage)
case health of
Just dmg -> return $ name ++ " " ++ show dmg
Nothing -> return name
instance Completion EntityIdentifier GameState where
completableLabel _ = "<entity>"
complete _ st prefix = return . filter ((isPrefixOf `on` CI.foldCase) prefix) . map ((evalState ?? st) . toName) . Map.keys $ st ^. gEntities
instance Argument EntityIdentifier GameState where
arg = \str -> do
fromForcedIdR <- fromForcedId str
fromNameR <- fromName str
fromIdR <- fromId str
return $ fromForcedIdR <|> fromNameR <|> fromIdR
where
fromName (EntityName . CI.mk -> name) = Bimap.lookupR name <$> use gEntityNames
fromId (preview entityId' -> Just n) = (n <$) . guard . Map.member n <$> use gEntities
fromId _ = return Nothing
fromForcedId ('#':str) = fromId str
fromForcedId _ = return Nothing
instance Completion Faction GameState where
completableLabel _ = "<faction>"
complete _ st prefix = return . filter ((isPrefixOf `on` CI.foldCase) prefix) . nub . sort $ unaligned : map (view faction') (st ^. inhabitedFactions)
instance Argument Faction GameState where
arg = return . Just . flip (set faction') def
instance Completion (Set Hitzone) GameState where
completableLabel _ = "<hitzones>"
complete _ st (over each reverse . span (/= ',') . reverse -> (wPrefix, lPrefix))
| not $ null wPrefix
, all (== '*') wPrefix = return . pure . join $ hitzones
| otherwise = return . map (lPrefix ++) . filter ((isPrefixOf `on` CI.foldCase) wPrefix) $ hitzones
where
hitzones = sort . map (review hitzone) $ fromMaybe [] (Map.keys <$> preview (gFocus' . eStats . sHitzones) st)
join [] = ""
join [x] = x
join (x:xs) = x ++ "," ++ join xs
instance Argument (Set Hitzone) GameState where
arg protoWs = runMaybeT $ do
let
trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace
split = foldr (\c l@(w:ws) -> if c == ',' then "" : l else (c : w) : ws) [""]
ws = Set.fromList . map CI.mk . filter (not . null) . map trim . split $ protoWs
hasGlob = Set.member "*" ws
hitzones <- Set.map (view _Hitzone) . Map.keysSet <$> MaybeT (preuse $ gFocus' . eStats . sHitzones)
guard (hasGlob || ws `Set.isSubsetOf` hitzones)
return . Set.map (review _Hitzone) $ if hasGlob then hitzones else ws
instance Completion DamageType GameState where
completableLabel _ = "<damageType>"
complete _ _ prefix = return . filter ((isPrefixOf `on` CI.foldCase) prefix) $ map show ([minBound .. maxBound] :: [DamageType])
instance Argument DamageType GameState where
arg (CI.mk -> word) = return $ Map.lookup word types
where
types = Map.fromList [(CI.mk $ show dType, dType) | dType <- [minBound .. maxBound]]
|
