h*JD      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                        0.9.6  Safe-Inferred/6 * 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.     experimental Safe-Inferred'3e0apecs>Pseudocomponent that produces all child entities for a parent.A useful property of this pseudocomponent is that it may be destroyed, which does a cascading ! on all of the parent's children: -- Remove all of player 1 entity's hitboxes: destroy player1 $ Proxy @(ChildList Hitbox)The cascading  behavior is provided for convenience, but note that if you assigned additional components to the child entities, those components will not be destroyed. In this case, you should destroy all components on the children explicitly, e.g.: ChildList children :: ChildList Hitbox <- get player1 for_ children $ \child -> do destroy child $ Proxy @ComponentsToDestroy2apecsAccessor pseudocomponent that produces just the underlying component value as opposed to 4' which also produces the parent entity.(For best performance, you should prefer 2 over 4 if your system is iterating over children and does not need the parent entities.apecs augments another store with support for one-to-many parent-child relationships.2This wrapper is not exported. If the user wants a Foo component to be treated as a child component, they declare their component when building their world as type  Child Foo. This will cause the Children# store wrapper to be used via the Storage/Elem type relation.4apecsThe 4 component wraps the parent entity and the child entity's underlying component value.If you want a Foo component in your game to be treated as a child component, specify the component type as  Child Foo when declaring your world: newtype Hitbox = Hitbox AABB deriving Show instance Component Hitbox where type Storage Hitbox = Map Hitbox -- A type alias solely for TH quoting's sake. type ChildHitbox = Child Hitbox makeWorld "World" [''ChildHitbox]%If your system is iterating over the 49 component but does not need the parent entity, use the 21 pseudocomponent instead for better performance..Note that if you delete a parent entity (i.e. 6 all of the parent entity's components), consider a + on the parent entity's children too. See 0 for assistance on this. This is more from a memory management point of view than one of safety: nothing via standard usage of this library will break if a child "outlives" its parent. However, both trying to directly  some component value of a child's non-existent parent or trying to directly  a parent's non-existent 0, will result in runtime errors. Raw use of  is inherently dangerous and its risk is not specific to the behavior provided by this module.452301452301 experimental Safe-Inferred  KapecsPseudocomponent 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 (...) -> ...Mapecs6Pseudocomponent that when written to, actually writes c to its entity argument. Can be used to write to other entities in a cmap.MNKLMNKL experimental Safe-InferredOZapecsQuantize 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)]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.ZapecsQuantization cell sizeapecsVector to be quantized]apecsLower bound for the regionapecsHigher bound for the regionZ[\]^Z[\]^ Safe-Inferred1&P_apecs3Wrapper that makes a store read-only by hiding its  and  5 instances. This is primarily used to protect the  EntityCounter$ from accidental overwrites. Use e and f to override.`apecsA 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.aapecsClass of stores that behave like a regular map, and can therefore safely be cached. This prevents stores like c and b , which do not, behave like simple maps, from being cached.bapecsA b9 contains exactly one component. The initial value is  from the component's  instance. Querying a b 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.capecsA Unique contains zero or one component. Writing to it overwrites both the previous component and its owner. Its main purpose is to be a d8 optimized for when only ever one component inhabits it.dapecsA map based on  . O(log(n)) for most operations.d`cba_efd`cba_ef Safe-Inferred&apecs7Generate tuple instances for the following tuple sizes. Safe-Inferred/6.@apecsIdentity component.  Identity c is equivalent to c, so mostly useless.apecs/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.apecs,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)'.apecs 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.apecs+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.apecs+Pseudostore used to produce values of type Not a , inverts  explExists, and destroys instead of explSet.apecs*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. Safe-Inferred 4apecsRun 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.apecsCollect matching components into a list by using the specified test/process function. You can use this to preprocess data before returning. And you can do a test here that depends on data from multiple components. Pass Just! to simply collect all the items.22  experimental Safe-Inferred6AapecsOverrides 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.  experimental Safe-Inferred  initStore <*> initStore <*> ... <*> initStore Safe-InferredCb4  dcb`4  dcb` !"#$%&'()*+,-./012344566789:;<=>?@ABCDEFGGHHIIJKLMNOPQRSTUVWXYZ[\]^__``abcdefghijklmnopqrstuvwxyz{|}~                                                                         "apecs-0.9.6-5Dabvg0cojLHO195CHtm4tApecs Apecs.CoreApecs.Experimental.ChildrenApecs.Experimental.ComponentsApecs.Experimental.Util Apecs.StoresApecs.Components Apecs.SystemApecs.Experimental.StoresApecs.Experimental.Reactive Apecs.UtilApecs.THapecsdestroyget Data.IntMapStrictApecs.THTuplesbase Data.ProxyProxyControl.Monad.IO.ClassliftIO mtl-2.3.1Control.Monad.Reader.Classaskaskstransformers-0.6.1.0Control.Monad.Trans.ClassliftDestroyMembersSetGet ExplMembers explMembers ExplDestroy explDestroyExplSetexplSetExplGetexplGet explExistsExplInitexplInitElemHasgetStore ComponentStorageSystemSystemTunSystemEntityunEntity$fFunctorSystemT$fMonadSystemT$fApplicativeSystemT$fMonadTransSystemT$fMonadIOSystemT$fMonadThrowSystemT$fMonadCatchSystemT$fMonadMaskSystemT$fMonadUnliftIOSystemT $fNumEntity $fEqEntity $fOrdEntity $fShowEntity $fEnumEntity$fMonadReaderwSystemT ChildList ChildValueChild$fExplDestroymChildren$fExplSetmChildren$fExplGetmChildren$fExplMembersmChildren$fExplInitmChildren$fComponentChild$fExplGetmChildValueStore$fExplMembersmChildValueStore$fHaswmChildValue$fComponentChildValue$fExplDestroymChildListStore$fExplGetmChildListStore$fExplMembersmChildListStore$fHaswmChildList$fComponentChildList $fEqChildList$fShowChildList$fEqChildValue$fShowChildValue $fEqChild $fShowChildHeadRedirect$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 runSystemrunWithset$=existsmodify$~cmapcmapIfcmapMcmapM_cfoldcfoldMcfoldM_collectStackgetStackPushdown$fExplMembersmPushdown$fExplDestroymPushdown$fExplSetmPushdown$fExplGetmPushdown$fExplInitmPushdown$fExplMembersmStackStore$fExplDestroymStackStore$fExplSetmStackStore$fExplGetmStackStore $fHaswmStack$fComponentStack $fEqStack $fShowStack$fFunctorStack$fApplicativeStack $fMonadStack$fFoldableStack $fMonoidStack$fSemigroupStackComponentCountcomponentCountCurrentcomponentCountMaxComponentCounterIxMapOrdMapEnumMapPrinterReactiveReactsremptyreact withReactive enumLookup ordLookupixLookupreadComponentCount$fExplMembersmReactive$fExplGetmReactive$fExplDestroymReactive$fExplSetmReactive$fExplInitmReactive$fReactsmPrinter$fReactsmEnumMap$fReactsmOrdMap$fReactsmIxMap$fReactsmComponentCounter$fEqComponentCount$fShowComponentCount EntityCounter getCounterglobal nextEntity newEntity newEntity_runGC$fComponentEntityCounter$fSemigroupEntityCounter$fMonoidEntityCounter$fEqEntityCounter$fShowEntityCounter makeWorldNoECmakeMapComponentsmakeMapComponentsFormakeWorldAndComponents makeWorldChildrenGHC.BasememptyMonoid makeInstancestupleInstances Data.EitherEithermakeMapComponentFor