{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
module Swarm.Game.Robot (
module Swarm.Game.Log,
RobotPhase (..),
RID,
RobotR,
Robot,
TRobot,
RobotUpdate (..),
RobotContext,
defTypes,
defReqs,
defVals,
defStore,
emptyRobotContext,
robotEntity,
robotName,
trobotName,
robotCreatedAt,
robotDisplay,
robotLocation,
unsafeSetRobotLocation,
trobotLocation,
robotOrientation,
robotInventory,
equippedDevices,
robotLog,
robotLogUpdated,
inventoryHash,
robotCapabilities,
robotContext,
trobotContext,
robotID,
robotParentID,
robotHeavy,
machine,
systemRobot,
selfDestruct,
tickSteps,
runningAtomic,
mkRobot,
instantiateRobot,
robotKnows,
isActive,
waitingUntil,
getResult,
hearingDistance,
) where
import Control.Lens hiding (contains)
import Data.Aeson (FromJSON, ToJSON)
import Data.Hashable (hashWithSalt)
import Data.Maybe (fromMaybe, isNothing)
import Data.Sequence (Seq)
import Data.Sequence qualified as Seq
import Data.Set (Set)
import Data.Text (Text)
import Data.Yaml ((.!=), (.:), (.:?))
import GHC.Generics (Generic)
import Linear
import Swarm.Game.CESK
import Swarm.Game.Display (Display, curOrientation, defaultRobotDisplay, invisible)
import Swarm.Game.Entity hiding (empty)
import Swarm.Game.Log
import Swarm.Language.Capability (Capability)
import Swarm.Language.Context qualified as Ctx
import Swarm.Language.Requirement (ReqCtx)
import Swarm.Language.Syntax (toDirection)
import Swarm.Language.Typed (Typed (..))
import Swarm.Language.Types (TCtx)
import Swarm.Language.Value as V
import Swarm.Util.Location
import Swarm.Util.Yaml
import System.Clock (TimeSpec)
data RobotContext = RobotContext
{ RobotContext -> TCtx
_defTypes :: TCtx
, RobotContext -> ReqCtx
_defReqs :: ReqCtx
, RobotContext -> Env
_defVals :: Env
, RobotContext -> Store
_defStore :: Store
}
deriving (RobotContext -> RobotContext -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RobotContext -> RobotContext -> Bool
$c/= :: RobotContext -> RobotContext -> Bool
== :: RobotContext -> RobotContext -> Bool
$c== :: RobotContext -> RobotContext -> Bool
Eq, RID -> RobotContext -> ShowS
[RobotContext] -> ShowS
RobotContext -> String
forall a.
(RID -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RobotContext] -> ShowS
$cshowList :: [RobotContext] -> ShowS
show :: RobotContext -> String
$cshow :: RobotContext -> String
showsPrec :: RID -> RobotContext -> ShowS
$cshowsPrec :: RID -> RobotContext -> ShowS
Show, forall x. Rep RobotContext x -> RobotContext
forall x. RobotContext -> Rep RobotContext x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RobotContext x -> RobotContext
$cfrom :: forall x. RobotContext -> Rep RobotContext x
Generic, Value -> Parser [RobotContext]
Value -> Parser RobotContext
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [RobotContext]
$cparseJSONList :: Value -> Parser [RobotContext]
parseJSON :: Value -> Parser RobotContext
$cparseJSON :: Value -> Parser RobotContext
FromJSON, [RobotContext] -> Encoding
[RobotContext] -> Value
RobotContext -> Encoding
RobotContext -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [RobotContext] -> Encoding
$ctoEncodingList :: [RobotContext] -> Encoding
toJSONList :: [RobotContext] -> Value
$ctoJSONList :: [RobotContext] -> Value
toEncoding :: RobotContext -> Encoding
$ctoEncoding :: RobotContext -> Encoding
toJSON :: RobotContext -> Value
$ctoJSON :: RobotContext -> Value
ToJSON)
makeLenses ''RobotContext
emptyRobotContext :: RobotContext
emptyRobotContext :: RobotContext
emptyRobotContext = TCtx -> ReqCtx -> Env -> Store -> RobotContext
RobotContext forall t. Ctx t
Ctx.empty forall t. Ctx t
Ctx.empty forall t. Ctx t
Ctx.empty Store
emptyStore
type instance Index RobotContext = Ctx.Var
type instance IxValue RobotContext = Typed Value
instance Ixed RobotContext
instance At RobotContext where
at :: Index RobotContext
-> Lens' RobotContext (Maybe (IxValue RobotContext))
at Index RobotContext
name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens RobotContext -> Maybe (Typed Value)
getter RobotContext -> Maybe (Typed Value) -> RobotContext
setter
where
getter :: RobotContext -> Maybe (Typed Value)
getter RobotContext
ctx =
do
Poly Type
typ <- forall t. Var -> Ctx t -> Maybe t
Ctx.lookup Index RobotContext
name (RobotContext
ctx forall s a. s -> Getting a s a -> a
^. Lens' RobotContext TCtx
defTypes)
Value
val <- forall t. Var -> Ctx t -> Maybe t
Ctx.lookup Index RobotContext
name (RobotContext
ctx forall s a. s -> Getting a s a -> a
^. Lens' RobotContext Env
defVals)
Requirements
req <- forall t. Var -> Ctx t -> Maybe t
Ctx.lookup Index RobotContext
name (RobotContext
ctx forall s a. s -> Getting a s a -> a
^. Lens' RobotContext ReqCtx
defReqs)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall v. v -> Poly Type -> Requirements -> Typed v
Typed Value
val Poly Type
typ Requirements
req
setter :: RobotContext -> Maybe (Typed Value) -> RobotContext
setter RobotContext
ctx Maybe (Typed Value)
Nothing =
RobotContext
ctx
forall a b. a -> (a -> b) -> b
& Lens' RobotContext TCtx
defTypes forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> Ctx t -> Ctx t
Ctx.delete Index RobotContext
name
forall a b. a -> (a -> b) -> b
& Lens' RobotContext Env
defVals forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> Ctx t -> Ctx t
Ctx.delete Index RobotContext
name
forall a b. a -> (a -> b) -> b
& Lens' RobotContext ReqCtx
defReqs forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> Ctx t -> Ctx t
Ctx.delete Index RobotContext
name
setter RobotContext
ctx (Just (Typed Value
val Poly Type
typ Requirements
req)) =
RobotContext
ctx
forall a b. a -> (a -> b) -> b
& Lens' RobotContext TCtx
defTypes forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> t -> Ctx t -> Ctx t
Ctx.addBinding Index RobotContext
name Poly Type
typ
forall a b. a -> (a -> b) -> b
& Lens' RobotContext Env
defVals forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> t -> Ctx t -> Ctx t
Ctx.addBinding Index RobotContext
name Value
val
forall a b. a -> (a -> b) -> b
& Lens' RobotContext ReqCtx
defReqs forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ forall t. Var -> t -> Ctx t -> Ctx t
Ctx.addBinding Index RobotContext
name Requirements
req
type RID = Int
data RobotPhase
=
TemplateRobot
|
ConcreteRobot
type family RobotLocation (phase :: RobotPhase) :: * where
RobotLocation 'TemplateRobot = Maybe Location
RobotLocation 'ConcreteRobot = Location
type family RobotID (phase :: RobotPhase) :: * where
RobotID 'TemplateRobot = ()
RobotID 'ConcreteRobot = RID
data RobotR (phase :: RobotPhase) = RobotR
{ forall (phase :: RobotPhase). RobotR phase -> Entity
_robotEntity :: Entity
, forall (phase :: RobotPhase). RobotR phase -> Inventory
_equippedDevices :: Inventory
, forall (phase :: RobotPhase). RobotR phase -> Set Capability
_robotCapabilities :: Set Capability
, forall (phase :: RobotPhase). RobotR phase -> Seq LogEntry
_robotLog :: Seq LogEntry
, forall (phase :: RobotPhase). RobotR phase -> Bool
_robotLogUpdated :: Bool
, forall (phase :: RobotPhase). RobotR phase -> RobotLocation phase
_robotLocation :: RobotLocation phase
, forall (phase :: RobotPhase). RobotR phase -> RobotContext
_robotContext :: RobotContext
, forall (phase :: RobotPhase). RobotR phase -> RobotID phase
_robotID :: RobotID phase
, forall (phase :: RobotPhase). RobotR phase -> Maybe RID
_robotParentID :: Maybe RID
, forall (phase :: RobotPhase). RobotR phase -> Bool
_robotHeavy :: Bool
, forall (phase :: RobotPhase). RobotR phase -> CESK
_machine :: CESK
, forall (phase :: RobotPhase). RobotR phase -> Bool
_systemRobot :: Bool
, forall (phase :: RobotPhase). RobotR phase -> Bool
_selfDestruct :: Bool
, forall (phase :: RobotPhase). RobotR phase -> RID
_tickSteps :: Int
, forall (phase :: RobotPhase). RobotR phase -> Bool
_runningAtomic :: Bool
, forall (phase :: RobotPhase). RobotR phase -> TimeSpec
_robotCreatedAt :: TimeSpec
}
deriving (forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (phase :: RobotPhase) x.
Rep (RobotR phase) x -> RobotR phase
forall (phase :: RobotPhase) x.
RobotR phase -> Rep (RobotR phase) x
$cto :: forall (phase :: RobotPhase) x.
Rep (RobotR phase) x -> RobotR phase
$cfrom :: forall (phase :: RobotPhase) x.
RobotR phase -> Rep (RobotR phase) x
Generic)
deriving instance (Show (RobotLocation phase), Show (RobotID phase)) => Show (RobotR phase)
deriving instance (Eq (RobotLocation phase), Eq (RobotID phase)) => Eq (RobotR phase)
deriving instance (ToJSON (RobotLocation phase), ToJSON (RobotID phase)) => ToJSON (RobotR phase)
let exclude = ['_robotCapabilities, '_equippedDevices, '_robotLog]
in makeLensesWith
( lensRules
& generateSignatures .~ False
& lensField . mapped . mapped %~ \fn n ->
if n `elem` exclude then [] else fn n
)
''RobotR
type TRobot = RobotR 'TemplateRobot
type Robot = RobotR 'ConcreteRobot
robotEntity :: Lens' (RobotR phase) Entity
robotCreatedAt :: Lens' Robot TimeSpec
robotName :: Lens' Robot Text
robotName :: Lens' Robot Var
robotName = forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity Var
entityName
trobotName :: Lens' TRobot Text
trobotName :: Lens' TRobot Var
trobotName = forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity Var
entityName
robotDisplay :: Lens' Robot Display
robotDisplay :: Lens' Robot Display
robotDisplay = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Robot -> Display
getDisplay forall {phase :: RobotPhase}.
RobotR phase -> Display -> RobotR phase
setDisplay
where
getDisplay :: Robot -> Display
getDisplay Robot
r =
(Robot
r forall s a. s -> Getting a s a -> a
^. forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity Display
entityDisplay)
forall a b. a -> (a -> b) -> b
& Lens' Display (Maybe Direction)
curOrientation forall s t a b. ASetter s t a b -> b -> s -> t
.~ ((Robot
r forall s a. s -> Getting a s a -> a
^. Lens' Robot (Maybe Heading)
robotOrientation) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Heading -> Maybe Direction
toDirection)
setDisplay :: RobotR phase -> Display -> RobotR phase
setDisplay RobotR phase
r Display
d = RobotR phase
r forall a b. a -> (a -> b) -> b
& forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity Display
entityDisplay forall s t a b. ASetter s t a b -> b -> s -> t
.~ Display
d
robotLocation :: Getter Robot Location
unsafeSetRobotLocation :: Location -> Robot -> Robot
unsafeSetRobotLocation :: Location -> Robot -> Robot
unsafeSetRobotLocation Location
loc Robot
r = Robot
r {_robotLocation :: RobotLocation 'ConcreteRobot
_robotLocation = Location
loc}
trobotLocation :: Lens' TRobot (Maybe Location)
trobotLocation :: Lens' TRobot (Maybe Location)
trobotLocation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens forall (phase :: RobotPhase). RobotR phase -> RobotLocation phase
_robotLocation (\TRobot
r Maybe Location
l -> TRobot
r {_robotLocation :: RobotLocation 'TemplateRobot
_robotLocation = Maybe Location
l})
robotOrientation :: Lens' Robot (Maybe Heading)
robotOrientation :: Lens' Robot (Maybe Heading)
robotOrientation = forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity (Maybe Heading)
entityOrientation
robotInventory :: Lens' Robot Inventory
robotInventory :: Lens' Robot Inventory
robotInventory = forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Entity Inventory
entityInventory
robotContext :: Lens' Robot RobotContext
trobotContext :: Lens' TRobot RobotContext
trobotContext :: Lens' TRobot RobotContext
trobotContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens forall (phase :: RobotPhase). RobotR phase -> RobotContext
_robotContext (\TRobot
r RobotContext
c -> TRobot
r {_robotContext :: RobotContext
_robotContext = RobotContext
c})
robotID :: Getter Robot RID
instantiateRobot :: RID -> TRobot -> Robot
instantiateRobot :: RID -> TRobot -> Robot
instantiateRobot RID
i TRobot
r =
TRobot
r
{ _robotID :: RobotID 'ConcreteRobot
_robotID = RID
i
, _robotLocation :: RobotLocation 'ConcreteRobot
_robotLocation = forall a. a -> Maybe a -> a
fromMaybe forall (f :: * -> *) a. (Additive f, Num a) => f a
zero (forall (phase :: RobotPhase). RobotR phase -> RobotLocation phase
_robotLocation TRobot
r)
}
robotParentID :: Lens' Robot (Maybe RID)
robotHeavy :: Lens' Robot Bool
equippedDevices :: Lens' Robot Inventory
equippedDevices :: Lens' Robot Inventory
equippedDevices = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens forall (phase :: RobotPhase). RobotR phase -> Inventory
_equippedDevices forall {phase :: RobotPhase}.
RobotR phase -> Inventory -> RobotR phase
setEquipped
where
setEquipped :: RobotR phase -> Inventory -> RobotR phase
setEquipped RobotR phase
r Inventory
inst =
RobotR phase
r
{ _equippedDevices :: Inventory
_equippedDevices = Inventory
inst
, _robotCapabilities :: Set Capability
_robotCapabilities = Inventory -> Set Capability
inventoryCapabilities Inventory
inst
}
robotLog :: Lens' Robot (Seq LogEntry)
robotLog :: Lens' Robot (Seq LogEntry)
robotLog = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens forall (phase :: RobotPhase). RobotR phase -> Seq LogEntry
_robotLog forall {phase :: RobotPhase}.
RobotR phase -> Seq LogEntry -> RobotR phase
setLog
where
setLog :: RobotR phase -> Seq LogEntry -> RobotR phase
setLog RobotR phase
r Seq LogEntry
newLog =
RobotR phase
r
{ _robotLog :: Seq LogEntry
_robotLog = Seq LogEntry
newLog
,
_robotLogUpdated :: Bool
_robotLogUpdated =
forall (phase :: RobotPhase). RobotR phase -> Bool
_robotLogUpdated RobotR phase
r Bool -> Bool -> Bool
|| forall a. Seq a -> RID
Seq.length (forall (phase :: RobotPhase). RobotR phase -> Seq LogEntry
_robotLog RobotR phase
r) forall a. Eq a => a -> a -> Bool
/= forall a. Seq a -> RID
Seq.length Seq LogEntry
newLog
}
robotLogUpdated :: Lens' Robot Bool
inventoryHash :: Getter Robot Int
inventoryHash :: Getter Robot RID
inventoryHash = forall (p :: * -> * -> *) (f :: * -> *) s a.
(Profunctor p, Contravariant f) =>
(s -> a) -> Optic' p f s a
to (\Robot
r -> RID
17 forall a. Hashable a => RID -> a -> RID
`hashWithSalt` (Robot
r forall s a. s -> Getting a s a -> a
^. (forall (phase :: RobotPhase). Lens' (RobotR phase) Entity
robotEntity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getter Entity RID
entityHash)) forall a. Hashable a => RID -> a -> RID
`hashWithSalt` (Robot
r forall s a. s -> Getting a s a -> a
^. Lens' Robot Inventory
equippedDevices))
robotKnows :: Robot -> Entity -> Bool
robotKnows :: Robot -> Entity -> Bool
robotKnows Robot
r Entity
e = Entity -> Inventory -> Bool
contains0plus Entity
e (Robot
r forall s a. s -> Getting a s a -> a
^. Lens' Robot Inventory
robotInventory) Bool -> Bool -> Bool
|| Entity -> Inventory -> Bool
contains0plus Entity
e (Robot
r forall s a. s -> Getting a s a -> a
^. Lens' Robot Inventory
equippedDevices)
robotCapabilities :: Getter Robot (Set Capability)
robotCapabilities :: Getter Robot (Set Capability)
robotCapabilities = forall (p :: * -> * -> *) (f :: * -> *) s a.
(Profunctor p, Contravariant f) =>
(s -> a) -> Optic' p f s a
to forall (phase :: RobotPhase). RobotR phase -> Set Capability
_robotCapabilities
machine :: Lens' Robot CESK
systemRobot :: Lens' Robot Bool
selfDestruct :: Lens' Robot Bool
tickSteps :: Lens' Robot Int
runningAtomic :: Lens' Robot Bool
mkRobot ::
RobotID phase ->
Maybe Int ->
Text ->
[Text] ->
RobotLocation phase ->
Heading ->
Display ->
CESK ->
[Entity] ->
[(Count, Entity)] ->
Bool ->
Bool ->
TimeSpec ->
RobotR phase
mkRobot :: forall (phase :: RobotPhase).
RobotID phase
-> Maybe RID
-> Var
-> [Var]
-> RobotLocation phase
-> Heading
-> Display
-> CESK
-> [Entity]
-> [(RID, Entity)]
-> Bool
-> Bool
-> TimeSpec
-> RobotR phase
mkRobot RobotID phase
rid Maybe RID
pid Var
name [Var]
descr RobotLocation phase
loc Heading
dir Display
disp CESK
m [Entity]
devs [(RID, Entity)]
inv Bool
sys Bool
heavy TimeSpec
ts =
RobotR
{ _robotEntity :: Entity
_robotEntity =
Display
-> Var -> [Var] -> [EntityProperty] -> [Capability] -> Entity
mkEntity Display
disp Var
name [Var]
descr [] []
forall a b. a -> (a -> b) -> b
& Lens' Entity (Maybe Heading)
entityOrientation forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Heading
dir
forall a b. a -> (a -> b) -> b
& Lens' Entity Inventory
entityInventory forall s t a b. ASetter s t a b -> b -> s -> t
.~ [(RID, Entity)] -> Inventory
fromElems [(RID, Entity)]
inv
, _equippedDevices :: Inventory
_equippedDevices = Inventory
inst
, _robotCapabilities :: Set Capability
_robotCapabilities = Inventory -> Set Capability
inventoryCapabilities Inventory
inst
, _robotLog :: Seq LogEntry
_robotLog = forall a. Seq a
Seq.empty
, _robotLogUpdated :: Bool
_robotLogUpdated = Bool
False
, _robotLocation :: RobotLocation phase
_robotLocation = RobotLocation phase
loc
, _robotContext :: RobotContext
_robotContext = RobotContext
emptyRobotContext
, _robotID :: RobotID phase
_robotID = RobotID phase
rid
, _robotParentID :: Maybe RID
_robotParentID = Maybe RID
pid
, _robotHeavy :: Bool
_robotHeavy = Bool
heavy
, _robotCreatedAt :: TimeSpec
_robotCreatedAt = TimeSpec
ts
, _machine :: CESK
_machine = CESK
m
, _systemRobot :: Bool
_systemRobot = Bool
sys
, _selfDestruct :: Bool
_selfDestruct = Bool
False
, _tickSteps :: RID
_tickSteps = RID
0
, _runningAtomic :: Bool
_runningAtomic = Bool
False
}
where
inst :: Inventory
inst = [Entity] -> Inventory
fromList [Entity]
devs
instance FromJSONE EntityMap TRobot where
parseJSONE :: Value -> ParserE EntityMap TRobot
parseJSONE = forall e a.
String -> (Object -> ParserE e a) -> Value -> ParserE e a
withObjectE String
"robot" forall a b. (a -> b) -> a -> b
$ \Object
v -> do
Bool
sys <- forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE forall a b. (a -> b) -> a -> b
$ Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"system" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
let defDisplay :: Display
defDisplay = Display
defaultRobotDisplay forall a b. a -> (a -> b) -> b
& Lens' Display Bool
invisible forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
sys
forall (phase :: RobotPhase).
RobotID phase
-> Maybe RID
-> Var
-> [Var]
-> RobotLocation phase
-> Heading
-> Display
-> CESK
-> [Entity]
-> [(RID, Entity)]
-> Bool
-> Bool
-> TimeSpec
-> RobotR phase
mkRobot () forall a. Maybe a
Nothing
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name")
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description" forall a. Parser (Maybe a) -> a -> Parser a
.!= [])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"loc")
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"dir" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall (f :: * -> *) a. (Additive f, Num a) => f a
zero)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall e' e (f :: * -> *) a. (e' -> e) -> With e f a -> With e' f a
localE (forall a b. a -> b -> a
const Display
defDisplay) (Object
v forall e a. FromJSONE e a => Object -> Var -> ParserE e (Maybe a)
..:? Var
"display" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
..!= Display
defDisplay)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Maybe ProcessedTerm -> CESK
mkMachine forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"program"))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall e a. FromJSONE e a => Object -> Var -> ParserE e (Maybe a)
..:? Var
"devices" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
..!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall e a. FromJSONE e a => Object -> Var -> ParserE e (Maybe a)
..:? Var
"inventory" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
..!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
sys
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a e. Functor f => f a -> With e f a
liftE (Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"heavy" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure TimeSpec
0
where
mkMachine :: Maybe ProcessedTerm -> CESK
mkMachine Maybe ProcessedTerm
Nothing = Value -> Store -> Cont -> CESK
Out Value
VUnit Store
emptyStore []
mkMachine (Just ProcessedTerm
pt) = ProcessedTerm -> Env -> Store -> CESK
initMachine ProcessedTerm
pt forall a. Monoid a => a
mempty Store
emptyStore
isActive :: Robot -> Bool
{-# INLINE isActive #-}
isActive :: Robot -> Bool
isActive = forall a. Maybe a -> Bool
isNothing forall b c a. (b -> c) -> (a -> b) -> a -> c
. Robot -> Maybe (Value, Store)
getResult
waitingUntil :: Robot -> Maybe Integer
waitingUntil :: Robot -> Maybe Integer
waitingUntil Robot
robot =
case forall (phase :: RobotPhase). RobotR phase -> CESK
_machine Robot
robot of
Waiting Integer
time CESK
_ -> forall a. a -> Maybe a
Just Integer
time
CESK
_ -> forall a. Maybe a
Nothing
getResult :: Robot -> Maybe (Value, Store)
{-# INLINE getResult #-}
getResult :: Robot -> Maybe (Value, Store)
getResult = CESK -> Maybe (Value, Store)
finalValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' Robot CESK
machine
hearingDistance :: Num i => i
hearingDistance :: forall i. Num i => i
hearingDistance = i
32