h$93%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                      None-2>? S 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. It is parameterized over m to allow stores to be foreign.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.apecsAn 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.     experimentalNone >?/apecsPseudocomponent that can be read like any other component, but will only yield a single member when iterated over. Intended to be used as cmap $ Head (...) -> ...1apecs6Pseudocomponent that when written to, actually writes c to its entity argument. Can be used to write to other entities in a cmap./01212/0 experimental Safe-Inferred\>apecsQuantize turns a world-space coordinate into a table-space coordinate by dividing by the given cell size and rounding towards negative infinity.?apecsTurns a table-space vector into an integral index, given some table size vector. Yields Nothing for out-of-bounds queries@apecsTests whether a vector is in the region given by 0 and the size vector (inclusive)AapecsFor 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.Bapecs6flatten, but yields garbage for out-of-bounds vectors.>apecsQuantization cell sizeapecsVector to be quantizedAapecsLower bound for the regionapecsHigher bound for the region>?@AB>?@ABNone/>?PCapecs3Wrapper that makes a store read-only by hiding its  and  5 instances. This is primarily used to protect the  EntityCounter$ from accidental overwrites. Use I and J to override.DapecsA cache around another store. Caches store their members in a fixed-size vector, so read/write operations become O(1). Caches can provide huge performance boosts, especially when working with large numbers of components.1The 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 decrease performance. In general, the exact size of the cache does not matter as long as it reasonably approximates the number of components present.The cache uses entity (-2) internally to represent missing entities. If you manually manipulate Entity values, be careful that you do not use (-2)The actual cache is not necessarily the given argument, but the next biggest power of two. This is allows most operations to be expressed as bit masks, for a large potential performance boost.EapecsClass of stores that behave like a regular map, and can therefore safely be cached. This prevents stores like G and F , which do not, behave like simple maps, from being cached.FapecsA F9 contains exactly one component. The initial value is  from the component's  instance. Querying a F at any Entity yields this one component, effectively sharing the component between all entities.$A Global component can be read with get 0 or get 1 or even get undefined. The convenience entity global is defined as -1, and can be used to make operations on a global more explicit, i.e. 'Time t <- get global'.-You also can read and write Globals during a cmap over other components.GapecsA Unique contains zero or one component. Writing to it overwrites both the previous component and its owner. Its main purpose is to be a H8 optimized for when only ever one component inhabits it.HapecsA map based on    . O(log(n)) for most operations.CDEFGHIJHDGFECIJNoneapecs7Generate tuple instances for the following tuple sizes.None-2>?"%gapecsIdentity component.  Identity c is equivalent to c, so mostly useless.hapecs/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.lapecs,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) -> b, 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)'.napecs Used for , 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.papecs+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.rapecs+Pseudostore used to produce values of type Not a , inverts  explExists, and destroys instead of explSet.tapecs*Pseudocomponent 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.hijklmnopqrstuturspqnolmjkhiNone >?'hapecsRun a system in a game worldapecsRun a system in a game worldapecsRead a ComponentapecsWrites a Component to a given Entity. Will overwrite existing Components.apecsset operatorWrites 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 cmap, 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.apecsMonadically fold over the game world. Strict in the accumulator.apecsMonadically fold over the game world. Strict in the accumulator.22 experimtalNone>?(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 >?,(apecsAllows you to look up entities by component value. Based on an IOArray c IntSet internallyapecsAllows you to look up entities by component value. Based on a  Map c IntSet internallyapecs?Allows you to look up entities by component value. Use e.g. withReactive $ mapLookup True, to retrieve a list of entities that have a True component. Based on an  IntMap IntSet internally.apecs+Wrapper for reactivity around some store s.apecsClass required by Reactive. Given some r and update information about some component, will run a side-effect in monad m,. Note that there are also instances for (,).apecs/Performs an action with a reactive state token.   None>?.apecsComponent used by newEntity to track the number of issued entities. Automatically added to any world created with  makeWorldapecsConvenience entity, for use in places where the entity value does not matter, i.e. a global store.apecs,Bumps the EntityCounter and yields its valueapecsWrites the given components to a new entity, and yields that entity. The return value is often ignored.apecsWrites the given components to a new entity without yelding the result. Used mostly for convenience.apecs'Explicitly invoke the garbage collector None2`apecsSame as , but does not include an  You don't typically want to use this, but it's exposed in case you know what you're doing.apecsCreates  instances with H storesapecsCalls  and &, i.e. makes a world and also defines  instances with a H store.apecsThe typical way to create a world record, associated ( instances, and initialization function. 5makeWorld "MyWorld" [''Component1, ''Component2, ...] turns into data MyWorld = MyWorld Component1 Component2 ... EntityCounter instance MyWorld `Has` Component1 where ... instance MyWorld `Has` Component2 where ... ... instance MyWorld `Has` EntityCounter where ... initMyWorld :: IO MyWorld initMyWorld = MyWorld <$> initStore <*> initStore <*> ... <*> initStoreNone22  DFGHtu2 tu HGFD !"#$%&'()*+,-./001223456789:;<=>?@ABBCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyyzz{{||}}~~                                      "apecs-0.9.4-8Ldmd6qYyC8Aj8KViln6sXApecs Apecs.CoreApecs.Experimental.ComponentsApecs.Experimental.Util Apecs.StoresApecs.Components Apecs.SystemApecs.Experimental.StoresApecs.Experimental.Reactive Apecs.UtilApecs.TH Data.IntMapStrictApecs.THTuplesbaseControl.Monad.IO.ClassliftIO Data.ProxyProxytransformers-0.5.6.2Control.Monad.Trans.Classlift mtl-2.2.2Control.Monad.Reader.ClassasksaskDestroyMembersSetGet ExplMembers explMembers ExplDestroy explDestroyExplSetexplSetExplGetexplGet explExistsExplInitexplInitElemHasgetStore ComponentStorageSystemSystemTunSystemEntityunEntity$fFunctorSystemT$fMonadSystemT$fApplicativeSystemT$fMonadTransSystemT$fMonadIOSystemT$fMonadThrowSystemT$fMonadCatchSystemT$fMonadMaskSystemT $fNumEntity $fEqEntity $fOrdEntity $fShowEntity $fEnumEntity$fMonadReaderwSystemTHeadRedirect$fExplSetmRedirectStore$fHaswmRedirect$fComponentRedirect$fExplMembersmHeadStore$fExplGetmHeadStore $fHaswmHead$fComponentHead$fEqHead $fShowHead $fEqRedirect$fShowRedirectquantizeflatteninboundsregionflatten'ReadOnlyCacheCachableGlobalUniqueMap setReadOnlydestroyReadOnly$fExplMembersmMap$fExplDestroymMap $fExplSetmMap $fExplGetmMap$fExplInitmMap$fExplMembersmUnique$fExplDestroymUnique$fExplSetmUnique$fExplGetmUnique$fExplInitmUnique$fExplSetmGlobal$fExplGetmGlobal$fExplInitmGlobal $fCachableMap$fExplMembersmCache$fExplDestroymCache$fExplSetmCache$fExplGetmCache$fExplInitmCache$fCachableCache$fExplMembersmReadOnly$fExplGetmReadOnly$fExplInitmReadOnly$fExplDestroymIdentity$fExplMembersmIdentity$fExplSetmIdentity$fExplGetmIdentity$fHaswmIdentity$fComponentIdentity 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 $fEqFilter $fShowFilter runSystemrunWithgetset$=existsdestroymodify$~cmapcmapIfcmapMcmapM_cfoldcfoldMcfoldM_StackgetStackPushdown$fExplMembersmPushdown$fExplDestroymPushdown$fExplSetmPushdown$fExplGetmPushdown$fExplInitmPushdown$fExplMembersmStackStore$fExplDestroymStackStore$fExplSetmStackStore$fExplGetmStackStore $fHaswmStack$fComponentStack $fEqStack $fShowStack$fFunctorStack$fApplicativeStack $fMonadStack$fFoldableStack $fMonoidStack$fSemigroupStackIxMapOrdMapEnumMapReactiveReactsremptyreact withReactive enumLookup ordLookupixLookup$fExplMembersmReactive$fExplGetmReactive$fExplDestroymReactive$fExplSetmReactive$fExplInitmReactive$fReactsmPrinter$fReactsmEnumMap$fReactsmOrdMap$fReactsmIxMap EntityCounter getCounterglobal nextEntity newEntity newEntity_runGC$fComponentEntityCounter$fSemigroupEntityCounter$fMonoidEntityCounter$fEqEntityCounter$fShowEntityCounter makeWorldNoECmakeMapComponentsmakeMapComponentsFormakeWorldAndComponents makeWorldGHC.BasememptyMonoid makeInstancestupleInstances Data.EitherEither