!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None,1=>?@AHMSVX'} apecs9Stores that we can request a list of member entities for. apecs+Returns an unboxed vector of member indices apecs+Stores that components can be removed from. apecs)Destroys the component for a given index.apecsStores that can be written.apecs Writes a component to the store.apecsStores that we can read using explGet and  explExists. For some entity e,  eplGet s e" is only guaranteed to be safe if explExists s e returns True.apecsReads a component from the store. What happens if the component does not exist is left undefined, and might not necessarily crash.apecs9Returns whether there is a component for the given index.apecsIndicates that the store s6 can be initialized. Generally, "base" stores like Map c/ can be initialized, but composite stores like  MaybeStore s cannot.apecsInitialize a new empty store.apecs/The type of components stored by a store, e.g. Elem (Map c) = c.apecs Has w m c means that world w can produce a  Storage c.apecsA component is defined by specifying how it is stored. The constraint ensures that stores and components are mapped one-to-one.apecs5A SystemT is a newtype around `ReaderT w m a`, where w0 is the game world variable. Systems serve to7Allow type-based lookup of a component's store through getStore.(Lift side effects into their host Monad.apecsWAn Entity is just an integer, used to index into a component store. In general, use  newEntity, cmap<, and component tags instead of manipulating these directly.}For performance reasons, negative values like (-1) are reserved for stores to represent special values, so avoid using these.    None.=>?@AHVX_klm@,apecsA cache around another store. Caches store their members in a fixed-size vector, so operations run in O(1). Caches can provide huge performance boosts, especially for large numbers of components. The cache size is given as a type-level argument.Note that iterating over a cache is linear in cache size, so sparsely populated caches might actually decrease performance. In general, the exact size of the cache does not matter as long as it reasonably approximates the number of components present.tThe cache uses entity (-2) to internally represent missing entities, so be wary when manually manipulating entities.-apecsmAn empty type class indicating that the store behaves like a regular map, and can therefore safely be cached..apecsA Global9 contains exactly one component. The initial value is  from the component's  instance.eWhen operating on a Global, any entity arguments are ignored. A Global component can be read with get 0 or get 1 or even  get undefined:. This means that you can read and write Globals while cmapping over other components. The integer globalh is defined as -1, and can be used to make operations on a global explicit, i.e. 'Time t <- get global'./apecsA Unique contains zero or one component. Writing to it overwrites both the previous component and its owner. Its main purpose is to be a Map8 optimized for when only ever one component inhabits it.0apecsA map based on Data.IntMap.Strict . O(log(n)) for most operations.,-./00,/.- NoneAapecs7Generate tuple instances for the following tuple sizes.None,1=>?@AHMSVX^JapecsIdentity component.  Identity c is equivalent to c, so mostly useless.Mapecs6Pseudocomponent that when written to, actually writes c9 to its entity argument. Used to dereference during a cmap.Oapecs/Pseudostore used to produce components of type . Always returns True for  explExists*, and echoes back the entity argument for explGet. Used in e.g. cmap $ (a, ety :: Entity) -> b to access the current entity.Sapecs,Pseudocomponent that functions normally for  explExists and  explMembers, but always return Filter for explGet. Can be used in cmap as  cmap $ (Filter :: Filter a) -> b6. Since the above can be written more consicely as cmap $ (_ :: a) -> bT, it is rarely directly. More interestingly, we can define reusable filters like 0movables = Filter :: Filter (Position, Velocity)9. Note that 'Filter c' is equivalent to 'Not (Not c)'.Uapecs Used for r, a logical disjunction between two components. As expected, Either is used to model error values. Getting an  Either a b will first attempt to get a b and return it as Right b", or if it does not exist, get an a as Left a-. Can also be used to set one of two things.Wapecs+Pseudostore used to produce values of type Maybe a. Will always return True for  explExists7. Writing can both set and delete a component using Just and Nothing respectively.Yapecs+Pseudostore used to produce values of type Not a , inverts  explExists, and destroys instead of explSet.[apecs*Psuedocomponent indicating the absence of a. Mainly used as e.g. cmap $ (a, Not b) -> c" to iterate over entities with an a but no b1. Can also be used to delete components, like cmap $ a -> (Not :: Not a) to delete every a component.KLMNOPQRSTUVWXYZ[\[\YZWXUVSTQROPMNKLNone =>?@AXlmpapecsRun a system in a game worldapecsRun a system in a game worldapecsRead a ComponentapecsIWrites a Component to a given Entity. Will overwrite existing Components.apecsset operatorIWrites a Component to a given Entity. Will overwrite existing Components.apecs/Returns whether the given entity has component capecsDestroys component c for the given entity.apecs Applies a function, if possible.apecsmodify operator Applies a function, if possible.apecs)Maps a function over all entities with a cx, and writes their cy.apecs Conditional cmapx, that first tests whether the argument satisfies some property. The entity needs to have both a cx and cp component.apecs-Monadically iterates over all entites with a cx, and writes their cy.apecs-Monadically iterates over all entites with a cxapecs'Fold over the game world; for example, cfold max (minBound :: Foo) will find the maximum value of Foo. Strict in the accumulator.apecsCMonadically fold over the game world. Strict in the accumulator.apecsCMonadically fold over the game world. Strict in the accumulator.22 experimtalNone=>?@AHMVXgvapecs*Wrapper that makes a store read-only. Use  setReadOnly and destroyReadOnly to override.apecsOverrides a store to have history/pushdown semantics. Setting this store adds a new value on top of the stack. Destroying pops the stack. You can view the entire stack using the  wrapper.  experimentalNone =>?@AHSVXeapecs?Allows you to look up entities by component value. Use e.g. rget >>= mapLookup True, to retrieve a list of entities that have a True component.apecs=Prints a message to stdout every time a component is updated.apecs+Wrapper for reactivity around some store s.apecsClass required by Reactive. Given some rN and update information about some component, will run a side-effect in monad m,. Note that there are also instances for (,).apecs Analogous to Elem , but for Reacts instances. For a  Reactive r s to be valid, ReactElem r = Elem sapecsReads r from the game world. None=>?@AHMVXlm apecsuComponent used by newEntity to track the number of issued entities. Automatically added to any world created with  makeWorldapecsbConvenience entity, for use in places where the entity value does not matter, i.e. a global store.apecs,Bumps the EntityCounter and yields its valueapecshWrites the given components to a new entity, and yields that entity. The return value is often ignored.apecs'Explicitly invoke the garbage collectorapecsQuantize turns a world-space coordinate into a table-space coordinate by dividing by the given cell size and rounding towards negative infinity.apecs|Turns a table-space vector into an integral index, given some table size vector. Yields Nothing for out-of-bounds queriesapecsRTests whether a vector is in the region given by 0 and the size vector (inclusive)apecsFor two table-space vectors indicating a region's bounds, gives a list of the vectors contained between them. This is useful for querying a spatial hash.apecs6flatten, but yields garbage for out-of-bounds vectors.apecsQuantization cell sizeapecsVector to be quantizedapecsLower bound for the regionapecsHigher bound for the region NoneHVapecsSame as  , but has no apecs$Same as makeWorld, but also defines  Component instances with a Map store.apecs 7makeWorld "WorldName" [''Component1, ''Component2, ...] turns into >data WorldName = WorldName Component1 Component2 ... EntityCounter instance WorldName `Has` Component1 where ... instance WorldName `Has` Component2 where ... ... instance WorldName `Has` EntityCounter where ... initWorldName :: IO WorldName initWorldName = WorldName <$> initStore <*> initStore <*> ... <*> initStore|None1  ,./0[\1 [\ 0/.,   !"#$%&'()*+,,-../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZZ[[\\]]^^__``aabbcdefghijklmnopqrstuvwxyz{|}~    "apecs-0.7.3-HvUErLUFZ0sL459CjBg4OcApecs Apecs.Core Apecs.StoresApecs.Components Apecs.SystemApecs.Stores.ExtraApecs.Reactive Apecs.UtilApecs.THApecs.THTuplesbaseControl.Monad.IO.ClassliftIO Data.ProxyProxytransformers-0.5.5.0Control.Monad.Trans.Classlift mtl-2.2.2Control.Monad.Reader.ClassasksaskDestroyMembersSetGet ExplMembers explMembers ExplDestroy explDestroyExplSetexplSetExplGetexplGet explExistsExplInitexplInitElemHasgetStore ComponentStorageSystemSystemTunSystemEntityunEntity $fNumEntity $fEqEntity $fOrdEntity $fShowEntity $fEnumEntity$fFunctorSystemT$fMonadSystemT$fApplicativeSystemT$fMonadTransSystemT$fMonadIOSystemT$fMonadReaderSystemTCacheCachableGlobalUniqueMap$fExplMembersmMap$fExplDestroymMap $fExplSetmMap $fExplGetmMap$fExplInitmMap$fExplMembersmUnique$fExplDestroymUnique$fExplSetmUnique$fExplGetmUnique$fExplInitmUnique$fExplSetmGlobal$fExplGetmGlobal$fExplInitmGlobal $fCachableMap$fExplMembersmCache$fExplDestroymCache$fExplSetmCache$fExplGetmCache$fExplInitmCache$fCachableCache$fExplDestroymIdentity$fExplMembersmIdentity$fExplSetmIdentity$fExplGetmIdentity$fHaswmIdentity$fComponentIdentity RedirectStoreRedirect EntityStore FilterStoreFilter EitherStore MaybeStoreNotStoreNot$fExplDestroym() $fExplSetm() $fExplGetm() $fComponent() $fHaswm()$fExplMembersm(,,,,,,,)$fExplDestroym(,,,,,,,)$fExplSetm(,,,,,,,)$fExplGetm(,,,,,,,)$fHaswm(,,,,,,,)$fComponent(,,,,,,,)$fExplMembersm(,,,,,,)$fExplDestroym(,,,,,,)$fExplSetm(,,,,,,)$fExplGetm(,,,,,,)$fHaswm(,,,,,,)$fComponent(,,,,,,)$fExplMembersm(,,,,,)$fExplDestroym(,,,,,)$fExplSetm(,,,,,)$fExplGetm(,,,,,)$fHaswm(,,,,,)$fComponent(,,,,,)$fExplMembersm(,,,,)$fExplDestroym(,,,,)$fExplSetm(,,,,)$fExplGetm(,,,,) $fHaswm(,,,,)$fComponent(,,,,)$fExplMembersm(,,,)$fExplDestroym(,,,)$fExplSetm(,,,)$fExplGetm(,,,) $fHaswm(,,,)$fComponent(,,,)$fExplMembersm(,,)$fExplDestroym(,,)$fExplSetm(,,)$fExplGetm(,,) $fHaswm(,,)$fComponent(,,)$fExplMembersm(,)$fExplDestroym(,) $fExplSetm(,) $fExplGetm(,) $fHaswm(,)$fComponent(,)$fExplSetmNotStore$fExplGetmNotStore $fHaswmNot$fComponentNot$fExplSetmMaybeStore$fExplGetmMaybeStore $fHaswmMaybe$fComponentMaybe$fExplDestroymEitherStore$fExplSetmEitherStore$fExplGetmEitherStore $fHaswmEither$fComponentEither$fExplMembersmFilterStore$fExplGetmFilterStore $fHaswmFilter$fComponentFilter$fExplGetmEntityStore $fHaswmEntity$fComponentEntity$fExplSetmRedirectStore$fHaswmRedirect$fComponentRedirect $fEqFilter $fShowFilter $fEqRedirect$fShowRedirect runSystemrunWithgetset$=existsdestroymodify$~cmapcmapIfcmapMcmapM_cfoldcfoldMcfoldM_ReadOnlyStackgetStackPushdown setReadOnlydestroyReadOnly$fExplMembersmPushdown$fExplDestroymPushdown$fExplSetmPushdown$fExplGetmPushdown$fExplInitmPushdown$fExplMembersmStackStore$fExplDestroymStackStore$fExplSetmStackStore$fExplGetmStackStore $fHaswmStack$fComponentStack$fExplMembersmReadOnly$fExplGetmReadOnly$fExplInitmReadOnly $fEqStack $fShowStack$fFunctorStack$fApplicativeStack $fMonadStack$fFoldableStack $fMonoidStack$fSemigroupStackEnumMapPrinterReactiveReactsremptyreact ReactElemrget mapLookup $fReactsm(,)$fExplMembersmReactive$fExplGetmReactive$fExplDestroymReactive$fExplSetmReactive$fExplInitmReactive$fReactsmPrinter$fReactsmEnumMap EntityCounter getCounterglobal nextEntity newEntityrunGCquantizeflatteninboundsregionflatten'$fComponentEntityCounter$fSemigroupEntityCounter$fMonoidEntityCounter$fEqEntityCounter$fShowEntityCounter makeWorldNoECmakeWorldAndComponents makeWorldGHC.BasememptyMonoid makeInstancestupleInstances Data.EitherEither